Spring Boot Database Operations with @Repository

🗄️ Database Optimization is a Game Changer Earlier, I focused only on Java code. But real performance issues often come from DB. Lessons I learned: ✔ Avoid unnecessary queries ✔ Use indexes wisely ✔ Don’t fetch everything 👉 Backend performance = Code + Database Ignoring DB = slow applications. Do you spend time optimizing queries? #SQL #BackendDevelopment #Java

🚀 Day 5 of My Advanced Java Journey – ACID Properties in JDBC Today, I learned how transactions work in databases and why ACID properties are critical for maintaining data integrity. 🔹 What are ACID Properties? ACID ensures reliable and consistent database transactions: Atomicity → Transaction is all or nothing (100% success or rollback) Consistency → Database moves from one valid state to another Isolation → Transactions are independent of each other Durability → Once committed, data remains safe even after failures 🔹 Real-Time Scenario: Money Transfer 💸 Transferring money between two accounts must be handled as a single transaction. 👉 Steps involved: 1️⃣ Load Driver & Establish Connection 2️⃣ Disable AutoCommit con.setAutoCommit(false); 3️⃣ Get sender, receiver, and amount 4️⃣ Debit amount from sender UPDATE acc_details SET balance = balance - ? WHERE name = ? 5️⃣ Credit amount to receiver UPDATE acc_details SET balance = balance + ? WHERE name = ? 6️⃣ Commit or Rollback if(i == 1 && j == 1){ con.commit(); } else { con.rollback(); } 🔹 Key Understanding Both debit and credit must succeed → ensures Atomicity Database remains valid → ensures Consistency Transaction is isolated until completion → ensures Isolation Data persists after commit → ensures Durability 🔍 What I explored beyond the session Importance of setAutoCommit(false) in transaction management Using rollback() to prevent partial updates Handling exceptions properly to avoid data inconsistency Concept of transaction boundaries in real-world applications Basic idea of savepoints for partial rollbacks 💡 ACID properties are the foundation of secure and reliable database systems. 🙌 Special thanks to the amazing trainers at TAP Academy: kshitij kenganavar Sharath R MD SADIQUE Bibek Singh Hemanth Reddy Vamsi yadav Harshit T Ravi Magadum Somanna M G Rohit Ravinder TAP Academy 📌 Learning in public. Building strong fundamentals every day. #Java #AdvancedJava #JDBC #ACID #Database #BackendDevelopment #LearningInPublic #VamsiLearns

Spring Boot Logging – What really happens when INFO is disabled? In production, we usually turn off INFO logs. It feels like those log statements are completely ignored — but that’s not always true. The key thing to understand is this: Java evaluates the log statement before the logging framework decides to ignore it. Take this example: log.info("User data: " + user); Here, the string concatenation happens first. That means user.toString() is executed and a new String object is created. Only after that, the logging framework checks the log level and ignores it. So even though nothing is printed, you still created objects, used memory, and added work for the Garbage Collector. Over time, this leads to more GC activity and unnecessary CPU usage. Now compare it with: log.info("User data: {}", user); This looks similar, but behaves very differently. In this case, the logging framework checks whether INFO is enabled before formatting the message. If INFO is disabled, it simply skips everything — no string creation, no extra objects, no GC work, and minimal CPU usage. There’s one more subtle case: log.info("User data: {}", getUser()); Even though you’re using {}, the method getUser() is still executed before the log call. So the object gets created anyway, consuming CPU and again adding pressure on the Garbage Collector — even when the log is disabled. To truly avoid unnecessary work, especially for expensive operations, you need to guard it: if (log.isInfoEnabled()) { log.info("User data: {}", getUser()); } Now, the method runs only when INFO logging is actually enabled, avoiding wasted computation, object creation, GC cycles, and CPU overhead. The takeaway is simple: Logging frameworks can skip formatting, but they cannot stop Java from executing expressions. Writing log statements the right way can save memory, reduce GC pressure, and improve CPU efficiency — especially in high-scale applications. #Java #SpringBoot #Logging #Performance #GarbageCollection #CleanCode

🚀 Day 2 of My Advanced Java Journey – JDBC Deep Dive Today, I explored deeper into JDBC, focusing on retrieving data, scrollable ResultSets, and metadata. 🔹 Retrieving Data from ResultSet JDBC provides multiple methods to fetch data from each column. We can retrieve data using: Column Index (int) Column Name (String) 👉 Common methods: getInt() getString() getFloat() getDouble() ✔️ Example concept: Using while(res.next()), we can iterate through rows and fetch values like id, name, designation, and salary. 🔹 Scrollable ResultSet (TYPE_SCROLL_SENSITIVE) Unlike normal ResultSets, scrollable ResultSets allow moving the cursor in multiple directions. 👉 Important methods: beforeFirst() afterLast() first() last() next() previous() absolute(int row) 💡 Helps in flexible data navigation. 🔹 ResultSet Metadata Metadata means data about data. Using ResultSetMetaData, we can get: Number of columns → getColumnCount() Column names → getColumnName(int column) Column types → getColumnType(int column) 🔍 What I explored beyond the session Difference between TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, and TYPE_SCROLL_SENSITIVE Importance of CONCUR_READ_ONLY vs CONCUR_UPDATABLE Additional methods like getBoolean(), getDate(), getLong() Why column names are preferred over index (better readability & maintainability) 💡 Mastering ResultSet handling makes JDBC much more powerful for real-world backend applications. 🙌 Special thanks to the amazing trainers at TAP Academy: kshitij kenganavar Sharath R MD SADIQUE Bibek Singh Hemanth Reddy Vamsi yadav Harshit T Ravi Magadum Somanna M G Rohit Ravinder TAP Academy 📌 Learning in public. Growing every day. #Java #AdvancedJava #JDBC #BackendDevelopment #LearningInPublic #100DaysOfCode #VamsiLearns

🚀 Day 3 of My Advanced Java Journey — Going Deeper into JDBC! Continuing my journey in Advanced Java, today I explored some powerful JDBC concepts that are widely used in real-world applications. 📚 What I Learned Today: 🔹 CallableStatement Learned how to call stored procedures from Java, making database operations more efficient and reusable. 🔹 ResultSet & Its Types Understood how data is retrieved and processed using ResultSet. Explored different types like: 👉 Forward Only 👉 Scrollable (Insensitive & Sensitive) 🔹 Types of JDBC Drivers Learned about different driver types and how they work: 1️⃣ JDBC-ODBC Bridge 2️⃣ Native API Driver 3️⃣ Network Protocol Driver 4️⃣ Thin Driver (Pure Java) 💡 Key Takeaway: Understanding how JDBC works internally (drivers, result handling, stored procedures) helps in writing efficient, scalable, and production-ready backend code. 🎯 Goal: To master Advanced Java and build strong backend systems with optimized database interactions. 📅 Continuing my Daily Advanced Java Learning Series Stay tuned for Day 4 🔥 #Java #AdvancedJava #JDBC #CallableStatement #ResultSet #JDBCDrivers #LearningInPublic #100DaysOfCode #BackendDevelopment #JavaDeveloper #StudentDeveloper #CareerGrowth

🚀 Day 31/45 – Learning JDBC (Database Connectivity) in Java On Day 31 of my Java learning journey, I explored JDBC (Java Database Connectivity), which allows Java applications to interact with databases. This is a crucial concept for building real-world applications that require data storage and retrieval. 📚 What I Learned Today Today I learned: ✔ What JDBC is and how it works ✔ Steps to connect Java with a database ✔ Executing SQL queries using Java ✔ Retrieving data using ResultSet 💻 Practice Work To apply my learning, I implemented: • A program to connect Java with MySQL database • Fetching and displaying records from a table 🎯 Key Takeaway JDBC is essential for building dynamic applications that interact with databases. Understanding database connectivity opens the door to backend development. This is an important step toward becoming a full-stack developer. #Java #Programming #LearningInPublic #CodingJourney #Database #JDBC

🚀 Day 2 of My Advanced Java Journey — Diving Deeper into JDBC & Security! Continuing my learning journey in Advanced Java, today I explored some very important real-world concepts related to JDBC and database security. 📚 What I Learned Today: 🔹 Retrieving Data using JDBC Learned how to use SELECT queries and process results using ResultSet. 🔹 SQL Injection (A Major Security Risk) Understood how attackers can manipulate queries through user input and gain unauthorized access. 🔹 PreparedStatement (Solution 💡) Learned how PreparedStatement helps prevent SQL Injection by separating SQL logic from user input. 📌 Key Difference: 👉 Statement → Vulnerable to SQL Injection 👉 PreparedStatement → Secure & Precompiled 💡 Key Takeaway: Writing code is not just about functionality, it's also about security. Using PreparedStatement makes applications more secure, efficient, and reliable. 🎯 Goal: To build secure backend applications with best coding practices. 📅 Continuing my Daily Advanced Java Learning Series Stay tuned for Day 3 🔥 #Java #AdvancedJava #JDBC #SQLInjection #PreparedStatement #LearningInPublic #100DaysOfCode #BackendDevelopment #JavaDeveloper #StudentDeveloper #CareerGrowth

Day 1 of my Java Full Stack Journey Today, I started learning JDBC (Java Database Connectivity). Here’s what I understood: • JDBC is used to connect Java applications with databases. • It acts as a bridge between Java code and SQL databases. • It allows us to execute queries and retrieve data. Key takeaway: JDBC is the foundation of backend development because it enables interaction between the application and the database. I also conducted a presentation after class, which helped me improve my understanding. #Java #JDBC #FullStackDeveloper #BackendDevelopment #SoftwareDevelopment #Programming #CodingJourney #LearnToCode #TechLearning #DeveloperLife #CodeNewbie #100DaysOfCode

Day 20: 🧑💻 Read Replicas - Scale Reads Horizontally, Free the Primary (Java + Spring Boot) What Are Read Replicas? Read Replicas are copies of your primary database that continuously receive updates via replication (WAL streaming / binary log). All writes go to the primary; reads are distributed across replicas — offloading the primary and enabling horizontal read scale. Without Replicas:  All traffic → Single Primary  90% reads + 10% writes fighting for same connections  Primary saturates → everything slows down With Read Replicas:  Writes → Primary only  Reads → Replica 1, Replica 2, Replica 3 (load balanced)  Primary free for writes → faster writes  Add replicas = scale reads linearly Key Takeaways — Plain English :   1. Read Replicas = copies of primary — receive updates via replication 2. All writes → Primary — replicas are read-only 3. All reads → Replicas — offloads primary, enables horizontal scale 4. readOnly=true = Spring routes automatically to replica via AbstractRoutingDataSource 5. Replica lag= milliseconds behind primary — eventual consistency 6. Read-after-write = don't write then immediately read from replica 7. Failover = if primary fails, promote replica (RDS/Aurora does this automatically) 8. Monitor lag = SELECT EXTRACT(EPOCH FROM now()-pg_last_xact_replay_timestamp()); 9. Rule: every SELECT-only method should have @Transactional(readOnly=true) — no exceptions #SystemDesign #ReadReplicas #Database #PostgreSQL #SpringBoot #Java #Microservices