Java Reflection API: Powerful Yet Dangerous

🚨 The Hidden Performance Killer in Java: The N+1 Problem If you’ve worked with JPA / Hibernate, chances are you’ve already faced the infamous N+1 query problem — sometimes without even realizing it. 💡 What is it? The N+1 problem happens when your application executes: 1 query to fetch a list of entities N additional queries to fetch related data for each entity For example: You load 100 users… and then trigger 100 extra queries to load their orders. Total: 101 queries instead of 1. ⚠️ Why is it dangerous? Works fine on small datasets → silently breaks in production Causes serious performance degradation Increases DB load and latency Hard to detect without proper monitoring 🔍 Common cause Lazy loading of relationships: @OneToMany(fetch = FetchType.LAZY) private List<Order> orders; Looks harmless, but accessing orders inside a loop triggers additional queries. 🛠️ How to fix it? Here are a few practical approaches: 1. Use JOIN FETCH SELECT u FROM User u JOIN FETCH u.orders Use @EntityGraph 2. @EntityGraph(attributePaths = {"orders"}) List<User> findAll(); 3. Batch fetching (Hibernate) hibernate.default_batch_fetch_size=50 4. DTO projections (best for read-heavy endpoints) 📊 Pro tip: Always monitor generated SQL (e.g., enable logging or use tools like p6spy). What looks like “one query” in code may actually be hundreds under the hood. — The N+1 problem isn’t a beginner mistake — it’s something that can easily slip into production code in complex systems. Have you encountered N+1 issues in your projects? How did you detect and fix them? #Java #SpringBoot #Hibernate #JPA #BackendDevelopment #Performance #SystemDesign #SoftwareEngineering

Java is quietly becoming more expressive This is not the Java you learned 5 years ago. Modern Java (21 → 25) is becoming much more concise and safer. 🧠 Old Java if (obj instanceof User) { User user = (User) obj; return user.getName(); } else if (obj instanceof Admin) { Admin admin = (Admin) obj; return admin.getRole(); } 👉 verbose 👉 error-prone 👉 easy to forget cases 🚀 Modern Java return switch (obj) { case User user -> user.getName(); case Admin admin -> admin.getRole(); default -> throw new IllegalStateException(); }; ⚡ Even better with sealed classes Java sealed interface Account permits User, Admin {} 👉 Now the compiler knows all possible types 👉 and forces you to handle them 💥 Why this matters less boilerplate safer code (exhaustive checks) fewer runtime bugs 👉 the compiler does more work for you ⚠️ What I still see in real projects old instanceof patterns manual casting everywhere missing edge cases 🧠 Takeaway Modern Java is not just about performance. It’s about writing safer and cleaner code. 🔍 Bonus Once your code is clean, the next challenge is making it efficient. That’s what I focus on with: 👉 https://joptimize.io Are you still writing Java 8-style code in 2025? #JavaDev #Java25 #Java21 #CleanCode #Backend #SoftwareEngineering

#Java #Wrapper #Class Why we need Wrapper Class in Java ? 👉 Wrapper classes = convert primitive → object Examples: int → Integer, char → Character, double → Double ✅ Main Reasons (Simple Points) 1. 📦 Use in Collections Java collections like ArrayList, HashMap work with objects only ❌ Cannot use int ✅ Use Integer 👉 Example: ArrayList<Integer> list = new ArrayList<>(); 2. 🔄 Conversion (Primitive ↔ Object) Convert data easily int → Integer (Autoboxing) Integer → int (Unboxing) 3. 🧰 Utility Methods Wrapper classes provide useful methods 👉 Example: Integer.parseInt("123"); Double.valueOf("10.5"); 4. ❌ Handle Null Values Primitive cannot store null Wrapper can store null 5. 💾 Required in Frameworks Many frameworks (like Spring, Hibernate) need objects Wrapper classes are required

Starting from JDK25, you can write a simple Java entry point (JVM main method) program as, ``` void main() { IO.println("Hello, World!"); } ``` and more interactively, ``` void main() { String name = IO.readln("Please enter your name: "); IO.print("Pleased to meet you, "); IO.println(name); } ``` 1. Both the above variants are single-file source-code programs (compact source file) 2. Automatically imports commonly used base packages such as java.io, java.math, and java.util via automatic import of the java.base module 3. To evolve a compact source file into a ordinary source file, all you need to do is wrap its fields and methods in an explicit class declaration and add an import declaration Assuming this program is in the file HelloWorld.java, you can run it directly with the source-code launcher: $ java HelloWorld.java Previously, the above simple Java program would look like below, ``` public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } ``` where, 1. "public" access modifier & "class" declaration provides for proper encapsulation boundaries 2. "static" modifier provides for a class-object modelling 3. String[] args parameter provides for the program execution inputs 4. System.out.println provides utilities for printing to the console More details in the JEP512 - https://lnkd.in/g5JBAWwe advocating the simplification

Java finally made a 𝗳𝗶𝗻𝗮𝗹 keyword mean 𝗙𝗶𝗻𝗮𝗹 and everyone is talking about it... Previously, the final keyword in Java indicated that a variable's value cannot be changed once initialized. However, through the use of the deep reflection 𝘀𝗲𝘁𝗔𝗰𝗰𝗲𝘀𝘀𝗶𝗯𝗹𝗲 and 𝘀𝗲𝘁 methods of the 𝗷𝗮𝘃𝗮.𝗹𝗮𝗻𝗴.𝗿𝗲𝗳𝗹𝗲𝗰𝘁.𝗙𝗶𝗲𝗹𝗱 class, it was possible to override this behavior. Consider the following example: ``` // A normal class with a final field class C {   final int x;   C() { x = 100; } } // 1. Perform a deep reflection over the final field in C java.lang.reflect.Field f = C.class.getDeclaredField("x"); f.setAccessible(true);   // Make C's final field mutable // 2. Create an instance of C C obj = new C(); System.out.println(obj.x); // Prints 100 // 3. Mutate the final field in the object f.set(obj, 200); System.out.println(obj.x); // Prints 200 f.set(obj, 300); System.out.println(obj.x); // Prints 300 ``` However, with the upcoming Java 26 release, the final keyword will truly mean final. This change is one of the intriguing updates in Java 26, and I look forward to discussing more of the new features. For further details, check out the official JEP: https://lnkd.in/gsKzzr6R #java

💡 Choosing GC in Java: What You Control vs What You Don’t While diving into JVM internals, I found a key concept about Garbage Collection (GC) that’s often misunderstood 👇 👉 In Java, we can choose which Garbage Collector to use But… 👉 We cannot control when it actually runs 🔍 Which GC is used by default? ✔ Before Java 8 → Parallel GC (Throughput Collector) ✔ Java 9 and above → G1 GC (Garbage First) ✅ ⚙️ How to choose a GC? (JVM Commands) 👉 Run your program like this: java -XX:+UseSerialGC MyProgram java -XX:+UseParallelGC MyProgram java -XX:+UseG1GC MyProgram java -XX:+UseZGC MyProgram 🧠 Basic Functionality of Popular GCs 🔹 Parallel GC (Throughput GC) ✔ Uses multiple threads for garbage collection ✔ Focuses on maximum throughput (performance) ❌ Causes Stop-The-World (STW) pauses 👉 Best for applications where speed > pause time 🔹 G1 GC (Garbage First) ✔ Divides heap into regions instead of generations ✔ Collects regions with maximum garbage first ✔ Provides low and predictable pause times 👉 Best for large-scale and modern applications 💡 Even if you call: System.gc(); ❌ It does NOT guarantee GC ✔ It’s just a request — JVM may ignore it 🔑 Key Takeaways: ✔ We control the type of GC (policy) ✔ JVM controls execution (timing & behavior) ✔ GC runs based on memory usage & internal algorithms ✔ Forcing GC can hurt performance 🚀 Interview Insight: “System.gc() is a suggestion, not a command.” Understanding this changed how I see JVM — it's highly optimized and smarter than manual control. 👉 We choose the GC, but JVM decides its execution. #Java #JVM #GarbageCollection #BackendDevelopment #JavaDeveloper #Programming #InterviewPreparation

🚀 Java Series – Day 28 📌 Reflection API in Java (How Spring Uses It) 🔹 What is it? The **Reflection API** allows Java programs to **inspect and manipulate classes, methods, fields, and annotations at runtime**. It allows operations like **creating objects dynamically, invoking methods, and reading annotations** without hardcoding them. 🔹 Why do we use it? Reflection helps in: ✔ Dependency Injection – automatically injects beans ✔ Annotation Processing – reads `@Autowired`, `@Service`, `@Repository` ✔ Proxy Creation – supports AOP and transactional features For example: In Spring, it can detect a class annotated with `@Service`, create an instance, and inject it wherever required without manual wiring. 🔹 Example: `import java.lang.reflect.*; @Service public class DemoService { public void greet() { System.out.println("Hello from DemoService"); } } public class Main { public static void main(String[] args) throws Exception { Class<?> clazz = Class.forName("DemoService"); // load class dynamically Object obj = clazz.getDeclaredConstructor().newInstance(); // create instance Method method = clazz.getMethod("greet"); // get method method.invoke(obj); // invoke method dynamically } }` 🔹 Output: `Hello from DemoService` 💡 Key Takeaway: Reflection makes Spring **dynamic, flexible, and powerful**, enabling features like DI, AOP, and annotation-based configuration without manual coding. What do you think about this? 👇 #Java #ReflectionAPI #SpringBoot #JavaDeveloper #BackendDevelopment #TechLearning #CodingTips

🚀 Java Revision Journey – Day 18 Today I revised the List Interface and ArrayList in Java, which are fundamental for handling ordered data collections. 📝 List Interface Overview The List interface (from java.util) represents an ordered collection where: 📌 Key Features: • Maintains insertion order • Allows duplicate elements • Supports index-based access • Allows null values (depends on implementation) • Supports bidirectional traversal using ListIterator 💻 Common Implementations • ArrayList • LinkedList 👉 Example: List<Integer> list = new ArrayList<>(); ⚙️ Basic List Operations • Add → add() • Update → set() • Search → indexOf(), lastIndexOf() • Remove → remove() • Access → get() • Check → contains() 🔁 Iterating a List • For loop (using index) • Enhanced for-each loop 📌 ArrayList in Java ArrayList is a dynamic array that can grow or shrink as needed. 💡 Features: • Maintains order • Allows duplicates • Fast random access • Not thread-safe 🛠️ Constructors • new ArrayList<>() • new ArrayList<>(collection) • new ArrayList<>(initialCapacity) ⚡ Internal Working (Simplified) Starts with default capacity Stores elements in an array When capacity exceeds → resizes automatically (grows dynamically) 💡 Understanding List and ArrayList is essential for managing dynamic data efficiently in Java applications. Continuing to strengthen my Java fundamentals step by step 💪 #Java #JavaLearning #ArrayList #Collections #JavaDeveloper #BackendDevelopment #Programming #JavaRevisionJourney 🚀

🚀 Spring Framework 🌱 | Day 3 – Spring Bean Lifecycle – Step by Step Flow 1️⃣ Container Starts The Spring container starts and reads configuration. Example sources: XML configuration Java Config Annotations (@Component, @Bean) 2️⃣ Bean Instantiation Spring creates the bean object. Example: UserService userService = new UserService(); 3️⃣ Dependency Injection Spring injects required dependencies. Example: @Autowired PaymentService paymentService; Spring sets properties and constructor dependencies. 4️⃣ Aware Interfaces (Optional) If the bean implements Aware interfaces, Spring provides container details. Examples: BeanNameAware ApplicationContextAware BeanFactoryAware 5️⃣ BeanPostProcessor (Before Initialization) Spring runs BeanPostProcessor before initialization. Method: postProcessBeforeInitialization() Used for custom processing. 6️⃣ Initialization Spring runs initialization methods. Possible ways: @PostConstruct afterPropertiesSet() (InitializingBean) custom init-method 7️⃣ BeanPostProcessor (After Initialization) Spring runs: postProcessAfterInitialization() Here frameworks often create proxies (AOP). 8️⃣ Bean Ready to Use Now the bean is fully initialized and available for use in the application. 9️⃣ Bean Destruction (Shutdown) When the container stops: Spring calls destruction methods. Examples: @PreDestroy destroy() (DisposableBean) custom destroy-method Simple Flow Diagram Container Start ↓ Bean Instantiation ↓ Dependency Injection ↓ Aware Interfaces ↓ BeanPostProcessor (Before Init) ↓ Initialization ↓ BeanPostProcessor (After Init) ↓ Bean Ready to Use ↓ Bean Destroyed ✅ Short Interview Answer > In Spring, the IoC container manages the bean lifecycle. It starts with bean instantiation, performs dependency injection, executes aware interfaces, calls BeanPostProcessor before and after initialization, runs initialization methods, makes the bean ready for use, and finally calls destruction methods when the container shuts down. #SpringFramework #Java #BackendDevelopment #InterviewPreparation #Learning #Developers #SpringBoot

🔹 Java 8 (Released 2014) – Foundation Release This is still widely used in many projects. Key Features: Lambda Expressions Functional Interfaces Streams API Method References Optional Class Default & Static methods in interfaces Date & Time API (java.time) Nashorn JavaScript Engine 👉 Example: Java list.stream().filter(x -> x > 10).forEach(System.out::println); 🔹 Java 17 (LTS – 2021) – Modern Java Standard Most companies are moving to this LTS version. Key Features: Sealed Classes Pattern Matching (instanceof) Records (finalized) Text Blocks (multi-line strings) New macOS rendering pipeline Strong encapsulation of JDK internals Removed deprecated APIs (like Nashorn) 👉 Example: Java record Employee(String name, int salary) {} 🔹 Java 21 (LTS – 2023) – Latest Stable LTS 🚀 Highly recommended for new projects. Key Features: Virtual Threads (Project Loom) ⭐ (BIGGEST CHANGE) Structured Concurrency (preview) Scoped Values (preview) Pattern Matching for switch (final) Record Patterns Sequenced Collections String Templates (preview) 👉 Example (Virtual Thread): Java Thread.startVirtualThread(() -> { System.out.println("Lightweight thread"); }); 🔹 Java 26 (Future / Latest Enhancements – Expected 2026) ⚡ (Not all finalized yet, but based on current roadmap & previews) Expected / Emerging Features: Enhanced Pattern Matching Primitive Types in Generics (Project Valhalla) ⭐ Value Objects (no identity objects) Improved JVM performance & GC Better Foreign Function & Memory API More concurrency improvements Scoped/Structured concurrency finalized 👉 Example (Concept): Java List<int> numbers; // possible future feature