SQL vs ORM: Simplify Your Code

🔁 Weekly Review Day Yesterday I was focused on revisiting fundamentals instead of learning something new. ✔️ Quick Java practice with arrays and small programs ✔️ SQL queries involving filtering and grouping I’m realizing that regular revision helps strengthen memory and highlights areas that still need more clarity. Small weekly reviews can make a big difference in long-term learning. #Java #SQL #LearningInPublic #Consistency #DeveloperJourney

🚀 Lazy Loading vs Eager Loading in JPA Understanding how data is fetched in JPA can make or break your application's performance. 🐢 Lazy Loading (FetchType.LAZY) Data is loaded only when needed. ✔ Improves performance ✔ Saves memory ⚠ Can cause N+1 query problem ⚠ Risk of LazyInitializationException ⚡ Eager Loading (FetchType.EAGER) Data is loaded immediately with the parent entity. ✔ Simple and easy access ✔ No extra queries ⚠ Loads unnecessary data ⚠ Poor performance for large datasets 👉 Rule of Thumb: Prefer LAZY by default, and use JOIN FETCH when needed. 💡 Smart fetching = Better performance + Scalable applications #Java #JPA #Hibernate #SpringBoot #BackendDevelopment #JavaDeveloper #SoftwareEngineering #CleanCode #PerformanceOptimization #WebDevelopment #Programming #Developers #CodingLife #TechTips #DatabaseDesign #FullStackDeveloper

In this video, I demonstrate how to create a bar graph in a Java report using JasperReports. The example groups patient ages and visualizes the data to show how reporting tools can transform raw data into meaningful insights. #Java #JasperReports #DataVisualization #SoftwareDevelopment #ReportingTools

🧠 Java Logic + SQL Concept Practice Today I focused on strengthening basic logic through small problems. ✔️ Counted even numbers in an array ✔️ Found the largest element ✔️ Calculated string length without using built-in methods Also revisited a key SQL concept around JOINs, especially understanding which JOIN returns all rows from the left table. These small exercises help improve logical thinking and deepen understanding of core concepts. #Java #SQL #DSA #ProgrammingFundamentals #LearningInPublic

🚀 From Temporary Memory to Persistent Data — My Deep Dive into Java File Handling While studying Java File Handling, I realized an important concept about how programs manage data. When a program runs, data is stored in RAM (temporary memory). But once the program stops, that data disappears. So the real challenge is: How do applications preserve data even after the program stops running? This is where File Handling becomes essential. It allows programs to store data on disk (files) so it can be read again later. 📂 File Class Java provides the File class to interact with the file system. Operations I explored: • createNewFile() → create a file • mkdir() / mkdirs() → create directories • exists() → check file existence • list() → list files inside a directory Important: The File class manages files, but it does not read or write data. 📦 Streams — Reading & Writing Data Actual data operations are done using Streams. File → Program → Input Stream (Read) Program → File → Output Stream (Write) Examples: FileInputStream FileOutputStream Streams process data byte by byte, allowing efficient file handling. ⚡ Buffered Streams To improve performance, Java uses Buffered Streams. A buffer temporarily stores data before transferring it. Program → Buffer → File Examples: BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter This significantly improves I/O performance. 🔐 Serialization & Deserialization Serialization converts a Java object into a byte stream so it can be stored or transmitted. Key concepts: Serializable interface serialVersionUID transient keyword ObjectOutputStream The reverse process, Deserialization, converts the byte stream back into the original object using ObjectInputStream. 💡 Key Insight Java File Handling connects multiple core concepts: • RAM vs Disk storage • Data persistence • Stream-based data flow • Buffered I/O optimization • Object serialization & deserialization Understanding this helped me see how Java applications store, manage, and retrieve data in real systems. Grateful to my mentor Prasoon Bidua at REGex Software Services for guiding us to understand the “why behind the technology.” #Java #JavaDeveloper #FileHandling #Serialization #JavaIO #BackendDevelopment

Exploring Java Stack Data Structure 🚀 In this simple example, I used Java's Stack to store different data types using Object type. It helped me better understand: - LIFO (Last In First Out) principle - How Stack works in Java - Storing multiple data types in one structure Always learning, always improving. 💻 import java.util.Stack; public class Main {   public static void main(String[] args) {     Stack<Object> my_stack =new Stack<>();     my_stack.push(1.25);     my_stack.push(78);     my_stack.push(true);     my_stack.push("engin");     my_stack.push(9999999L);     my_stack.push('E');     System.out.println(my_stack);           } } https://lnkd.in/d3hZN9B4 #Java #DataStructures #Programming #Learning

The Hidden Mechanism Behind ThreadLocal in Java ThreadLocal is often explained simply as: “Data stored per thread.” That’s true — but the interesting part is how it actually works internally. Most developers think the data lives inside ThreadLocal. It doesn’t. How ThreadLocal Works Internally Each Thread object maintains its own internal structure: Thread └── ThreadLocalMap ├── ThreadLocal → Value ├── ThreadLocal → Value The important detail: The map belongs to the Thread, not to ThreadLocal. ThreadLocal simply acts as a key. Basic Flow When you call: ThreadLocal.set(value) Internally: Copy code thread = currentThread map = thread.threadLocalMap map.put(ThreadLocal, value) When you call: ThreadLocal.get() It retrieves the value from the current thread’s map. Each thread therefore has its own independent copy. Where This Is Used in Real Systems You’ll find ThreadLocal used in many frameworks: • Spring Security → SecurityContextHolder • Transaction management → TransactionSynchronizationManager • Logging correlation IDs • Request scoped context It allows frameworks to store request-specific data without passing it through every method. The Hidden Danger If you forget to call: Copy code ThreadLocal.remove() You can create memory leaks. Why? Because thread pools reuse threads. Old values may remain attached to long-lived threads. ThreadLocal is simple conceptually. But its internal design is what makes many Java frameworks work efficiently. Have you used ThreadLocal in production code? #Java #CoreJava #Multithreading #ThreadLocal #SpringBoot #BackendEngineering #InterviewPreparation

Do we need @Repository on Spring Data JPA repositories? — Spring Boot Interview Question Short answer: No, you usually don’t need @Repository Spring Data JPA repositories. But there are a few important nuances to understand. Checkout the detailed explanation: https://lnkd.in/gpyz4pHq Subscribe and Join 6000+ Java & Spring Boot devs: https://lnkd.in/gwiRqWBV

3 years of Spring Boot and this still made me pause for a second. The best engineers question the defaults. Reposting because every Java dev should know this. 🧠

🔹 Concept: ORM using JPA In my backend project, I used Spring Data JPA to simplify database operations and interact with the database using Java objects. 📌 What is ORM? ORM (Object Relational Mapping) is a technique that maps Java objects to database tables. This allows developers to work with objects in code instead of writing complex SQL queries. 📌 Why is ORM useful? • Reduces the need for manual SQL queries • Simplifies CRUD operations (Create, Read, Update, Delete) • Improves code readability and maintainability • Speeds up backend development 📌 Example from my project: @Entity public class Order {  private Long id;  private String productName; } With JPA, this Java class automatically maps to a database table, making it easier to store and retrieve data. Understanding ORM and JPA is essential when building scalable backend systems with Spring Boot. #JPA #ORM #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #JavaDevelopment #Programming #Developers #TechCommunity #CodingJourney