Mastering Spring Boot: IoC, DI, and Spring Framework

𝗝𝗮𝘃𝗮 𝗥𝗼𝗮𝗱𝗺𝗮𝗽 𝟮𝟬𝟮𝟲 𝗝𝗮𝘃𝗮 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 Start with the core building blocks of Java programming. 🔹 Syntax & structure 🔹 Variables, data types, operators 🔹 Control flow (if/else, loops, switch) 🔹 Functions / methods 🔹 Arrays & strings 𝗢𝗯𝗷𝗲𝗰𝘁-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 (𝗢𝗢𝗣) Java is built on OOP — master it deeply. 🔹 Classes & objects 🔹 Encapsulation, inheritance, polymorphism, abstraction 🔹 Interfaces & abstract classes 🔹 Constructors & method overloading 🔹 Access modifiers 𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀 Work efficiently with data structures. 🔹 List, Set, Map interfaces 🔹 ArrayList, LinkedList 🔹 HashMap, TreeMap 🔹 HashSet, TreeSet 🔹 Iterators & comparators 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 Write robust and fault-tolerant applications. 🔹 Try-catch-finally 🔹 Checked vs unchecked exceptions 🔹 Custom exceptions 🔹 Best practices 𝗙𝗶𝗹𝗲 𝗜/𝗢 & 𝗦𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 Handle data storage and transfer. 🔹 File reading/writing 🔹 Buffered streams 🔹 Object serialization 🔹 NIO (New I/O) 𝗠𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴 & 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 Build high-performance applications. 🔹 Threads & Runnable 🔹 Synchronization & locks 🔹 Executors & thread pools 🔹 CompletableFuture 🔹 Concurrent collections 𝗝𝗮𝘃𝗮 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 Modern Java (Java 8+) features. 🔹 Lambda expressions 🔹 Streams API 🔹 Functional interfaces 🔹 Optional class 🔹 Method references 𝗝𝗮𝘃𝗮 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 Build scalable applications faster. 🔹 Spring Framework 🔹 Spring Boot 🔹 Spring MVC 🔹 Hibernate / JPA 🔹 Micronaut / Quarkus 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 & 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗲 Store and manage application data. 🔹 JDBC 🔹 SQL (MySQL, PostgreSQL) 🔹 ORM (Hibernate) 🔹 Transactions & connection pooling 𝗕𝘂𝗶𝗹𝗱 𝗧𝗼𝗼𝗹𝘀 & 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 Manage and build projects efficiently. 🔹 Maven 🔹 Gradle 🔹 Project structure 🔹 Dependency management 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 Ensure code quality and reliability. 🔹 JUnit 🔹 Mockito 🔹 Integration testing 🔹 Test-driven development (TDD) 𝗗𝗲𝘃𝗢𝗽𝘀 & 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 Take your Java apps to production. 🔹 Docker & containerization 🔹 CI/CD pipelines 🔹 Cloud deployment (AWS, Azure) 🔹 Monitoring & logging 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗳𝗼𝗿 𝗝𝗮𝘃𝗮 Design scalable backend systems. 🔹 REST APIs & microservices 🔹 Caching (Redis) 🔹 Message queues (Kafka, RabbitMQ) 🔹 Load balancing & scaling 𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 Apply your knowledge practically. 🔹 RESTful API with Spring Boot 🔹 E-commerce backend system 🔹 Authentication system (JWT) 🔹 Microservices architecture project 🔹 Banking or payment system Mastering this roadmap will take you from beginner to a professional Java developer capable of building scalable, production-ready applications. Get the complete Java Handbook here: 👉 https://lnkd.in/er4NMnG2

𝗝𝗮𝘃𝗮 𝗥𝗼𝗮𝗱𝗺𝗮𝗽 𝟮𝟬𝟮𝟲 𝗝𝗮𝘃𝗮 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 Start with the core building blocks of Java programming. 🔹 Syntax & structure 🔹 Variables, data types, operators 🔹 Control flow (if/else, loops, switch) 🔹 Functions / methods 🔹 Arrays & strings 𝗢𝗯𝗷𝗲𝗰𝘁-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 (𝗢𝗢𝗣) Java is built on OOP — master it deeply. 🔹 Classes & objects 🔹 Encapsulation, inheritance, polymorphism, abstraction 🔹 Interfaces & abstract classes 🔹 Constructors & method overloading 🔹 Access modifiers 𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀 Work efficiently with data structures. 🔹 List, Set, Map interfaces 🔹 ArrayList, LinkedList 🔹 HashMap, TreeMap 🔹 HashSet, TreeSet 🔹 Iterators & comparators 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 Write robust and fault-tolerant applications. 🔹 Try-catch-finally 🔹 Checked vs unchecked exceptions 🔹 Custom exceptions 🔹 Best practices 𝗙𝗶𝗹𝗲 𝗜/𝗢 & 𝗦𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 Handle data storage and transfer. 🔹 File reading/writing 🔹 Buffered streams 🔹 Object serialization 🔹 NIO (New I/O) 𝗠𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴 & 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 Build high-performance applications. 🔹 Threads & Runnable 🔹 Synchronization & locks 🔹 Executors & thread pools 🔹 CompletableFuture 🔹 Concurrent collections 𝗝𝗮𝘃𝗮 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 Modern Java (Java 8+) features. 🔹 Lambda expressions 🔹 Streams API 🔹 Functional interfaces 🔹 Optional class 🔹 Method references 𝗝𝗮𝘃𝗮 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 Build scalable applications faster. 🔹 Spring Framework 🔹 Spring Boot 🔹 Spring MVC 🔹 Hibernate / JPA 🔹 Micronaut / Quarkus 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 & 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗲 Store and manage application data. 🔹 JDBC 🔹 SQL (MySQL, PostgreSQL) 🔹 ORM (Hibernate) 🔹 Transactions & connection pooling 𝗕𝘂𝗶𝗹𝗱 𝗧𝗼𝗼𝗹𝘀 & 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 Manage and build projects efficiently. 🔹 Maven 🔹 Gradle 🔹 Project structure 🔹 Dependency management 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 Ensure code quality and reliability. 🔹 JUnit 🔹 Mockito 🔹 Integration testing 🔹 Test-driven development (TDD) 𝗗𝗲𝘃𝗢𝗽𝘀 & 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 Take your Java apps to production. 🔹 Docker & containerization 🔹 CI/CD pipelines 🔹 Cloud deployment (AWS, Azure) 🔹 Monitoring & logging 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗳𝗼𝗿 𝗝𝗮𝘃𝗮 Design scalable backend systems. 🔹 REST APIs & microservices 🔹 Caching (Redis) 🔹 Message queues (Kafka, RabbitMQ) 🔹 Load balancing & scaling 𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 Apply your knowledge practically. 🔹 RESTful API with Spring Boot 🔹 E-commerce backend system 🔹 Authentication system (JWT) 🔹 Microservices architecture project 🔹 Banking or payment system Mastering this roadmap will take you from beginner to a professional Java developer capable of building scalable, production-ready applications.

🚀 Spring Boot Series – Part 6: What Happens When You Click the RUN Button in a Spring Boot Application? We do it every day: Write code → click Run → application starts. But what actually happens behind the scenes? 🤔 Let’s break it down step by step 👇 1️⃣ JVM starts the application When you click Run, the Java Virtual Machine (JVM) starts your Java program and looks for the main() method. 2️⃣ SpringApplication.run() gets executed This is the line that bootstraps the entire Spring Boot application. SpringApplication.run(MyApplication.class, args); 3️⃣ Spring Boot detects @SpringBootApplication Spring Boot detects the main annotation and understands that it needs to configure, auto-configure, and scan your application. 4️⃣ Spring Boot prepares the startup Spring Boot now prepares important things like: • ApplicationContext • Environment • Listeners • Initializers 5️⃣ ApplicationContext is created Spring creates the ApplicationContext, which is the Spring Container that manages all beans. 6️⃣ The environment is prepared Spring Boot reads configuration from: • application.properties / application.yml • Environment variables • Command-line arguments • Profiles 7️⃣ Component scanning and bean loading happen Spring scans classes annotated with: • @Component • @Service • @Repository • @Controller • @RestController • @Configuration It also processes @Bean methods and identifies what beans need to be created. 8️⃣ Auto Configuration kicks in Spring Boot checks the dependencies available on the classpath and automatically configures required beans. For example: • Web dependency → web-related beans • JPA dependency → data-related beans 9️⃣ ApplicationContext is refreshed At this stage, Spring actually starts creating beans, injecting dependencies, and initializing the application. This is where the application starts taking real shape in memory. 🔟 Embedded server starts If it is a web application, Spring Boot starts the embedded server (usually Tomcat). Now your application is capable of handling requests. 1️⃣1️⃣ Application is fully ready At this point: ✔ Beans are created ✔ Dependencies are injected ✔ Configuration is loaded ✔ Server is running 👉 Your Spring Boot application is now ready to serve requests. 🎯 Key Takeaway When you click Run, Spring Boot does much more than just execute your code. 👉 It creates the Spring container, reads configurations, scans components, applies auto-configuration, creates beans, injects dependencies, starts the server, and prepares the application to serve requests. Have you ever explored what actually happens inside SpringApplication.run() before? 🔍 In the next post of this series, we’ll explore Maven. Stay tuned. 💡 Save this post for future reference if you found it helpful. #SpringBoot #SpringFramework #Java #BackEndDevelopment #SoftwareEngineering #Programming #TechCommunity

I've seen developers write 200 lines of config code. All of it could've been replaced with 3 annotations. That's the power of Spring Boot — if you know the right annotations. Most developers only scratch the surface. Here's the complete breakdown you actually need: BOOTSTRAP → @SpringBootApplication — main entry point, enables everything → @EnableAutoConfiguration — auto-configures beans from classpath → @ComponentScan — scans and registers Spring components LAYERED ARCHITECTURE → @Component — generic Spring-managed bean → @Service — business logic layer → @Repository — data access with exception translation → @RestController — builds REST APIs returning JSON/XML DEPENDENCY INJECTION → @Autowired — injects dependencies automatically → @Qualifier — resolves ambiguity between multiple beans → @Primary — marks default bean implementation WEB & REST APIs → @GetMapping / @PostMapping / @PutMapping / @DeleteMapping → @RequestBody — maps payload to Java object → @PathVariable — extracts values from URL → @RequestParam — reads query parameters DATABASE & JPA → @Entity — maps class to DB table → @Transactional — ensures atomic operations with rollback → @GeneratedValue — auto-generates primary key VALIDATION → @Valid — triggers validation on request → @NotNull / @NotBlank / @Email / @Pattern — enforce input rules EXCEPTION HANDLING → @ExceptionHandler — handles specific exceptions → @RestControllerAdvice — global error handling for REST APIs SECURITY → @EnableWebSecurity — enables Spring Security → @PreAuthorize — role/permission check before method execution ADVANCED → @Scheduled — runs cron jobs → @Async — executes methods asynchronously → @Cacheable / @CacheEvict — cache and invalidate results I've compiled all of this into a structured PDF carousel. Comment SPRING and I'll send it to your DMs. ♻ Repost if this helped someone on your network. Follow Narendra K. for more Java & Spring Boot content. #SpringBoot #Java #BackendDevelopment #JavaDeveloper #SpringFramework #SoftwareEngineering #WebDevelopment #Programming #InterviewPreparation

Building scalable backend systems with Java multi-module (Maven) + Hexagonal Architecture. In complex backend systems, structure matters more than code. One approach that has worked really well for me is combining: Java multi-module (Maven parent + child modules) Hexagonal Architecture Vertical slicing by feature --------------------------------------------------------------- 🧱 Multi-module Maven: more than just organization Using a parent project with multiple modules allows you to: Separate concerns at build level Enforce clear boundaries between components Reuse shared logic without tight coupling Typical structure: project-parent ├── transfer-domain ├── transfer-application ├── transfer-infrastructure ├── transfer-entrypoints --------------------------------------------------------------- 🔷 Hexagonal Architecture: protect your core Each module aligns naturally with hexagonal layers: Domain → business rules, entities Application → use cases Infrastructure → DB, files, external systems Entrypoints → APIs, schedulers, batch 👉 This keeps your domain clean and independent from frameworks. 🔥 Vertical slicing: real scalability Instead of organizing by technical layers only, you split by feature: payment-module transfer-module customer-module --------------------------------------------------------------- ⚖️ Trade-offs (the part nobody tells you) 1. More initial complexity More modules More configuration More discipline required Risk of over-engineering If the system is small: This structure can slow you down instead of helping.

I built Spring Perf Analyzer — because performance bugs are cheap to fix in dev and expensive to debug in prod. Most teams find N+1 queries, missing caches, and slow service calls through production incidents. This moves that discovery into your local development loop — zero infrastructure, one annotation. ⚙️ Zero-Friction Setup Step 1 — Drop the dependency. Step 2 — Add @EnablePerfAnalyzer to your main class. One annotation. Spring Boot's auto-configuration does the rest — the full instrumentation stack registers itself into your application context on startup. No XML. No manual wiring. No agent. No sidecar. Start your application. Every request is now instrumented. 🔧 How It Works Under the Hood Each layer was chosen because it's the earliest possible interception point for that class of problem: Hibernate StatementInspector sits at the JDBC boundary — before execution. Queries are tracked per-request via ThreadLocal, then analyzed post-request for structural repetition. That's where N+1s live, and that's exactly where they're caught. MVC HandlerInterceptor stamps request entry and exit timestamps directly into request attributes. No object allocation. No thread contention. Accurate latency measurement with negligible overhead. AspectJ @Around Advice wraps every @Service method and tracks invocation frequency against parameter signatures. A method called 3+ times with identical arguments, each taking over 100ms — that's not a coincidence. That's a missing cache, and it gets flagged with the exact method signature. Servlet Filter coordinates the entire analysis at the request boundary. After the response completes, findings are pushed to a non-blocking report queue. Your latency numbers stay clean. 🆚 Why This, and Not What You Already Have Datadog and New Relic are built for production — they need infrastructure, agents, and an incident to justify the signal. Hibernate's show_sql gives you a wall of text with no aggregation. Actuator surfaces metrics, not root causes. None of them are designed to give you actionable, request-scoped diagnostics inside a local dev loop with nothing to configure. That's the gap. This fills it. 📈 What's Next Thread pool saturation detection → JFR-based memory allocation profiling → CI/CD performance regression gates → Prometheus metrics export The direction is the same throughout: make performance observable by default, not discoverable by accident. Stack: Java 17 | Spring Boot 3.2.3 | Hibernate StatementInspector | AspectJ | HandlerInterceptor | Maven

**Adopting Quarkus after years of Spring Boot** After years working with Spring Boot, I recently started using Quarkus on real projects. Not just hype. The shift is deeper and architectural. At first glance, both solve the same problems: REST, DI, persistence, security, cloud. But the real difference is not features. It’s when errors appear and how predictable the system is. Spring Boot is flexible and runtime-driven (auto-config, scanning, reflection). You move fast, but some issues appear late (integration or prod). Quarkus flips the model: build-time first, fail fast, less implicit behavior, more deterministic system. It validates early: • injection • configuration • wiring • integrations Result: less runtime logic, fewer surprises. --- **Build-time vs runtime (real impact)** Spring → validates late Quarkus → validates early In practice: • missing config → build error • invalid JPA mapping → early detection • ambiguous injection → build fails Dev loop changes completely. Spring: fast start, delayed issues Quarkus: stricter start, immediate feedback --- **Minimal example** Spring Boot: @Service class PaymentServiceV1 {} @Service class PaymentServiceV2 {} @Autowired PaymentService service → app starts → ambiguity handled later Quarkus: @ApplicationScoped @Named("v1") class PaymentServiceV1 {} @ApplicationScoped @Named("v2") class PaymentServiceV2 {} @Inject PaymentService service → build fails immediately Fix: @Inject @Named("v1") PaymentService service Same feature: Spring tolerates Quarkus enforces --- **What changes in practice** • clearer dependencies • fewer hidden bugs • faster debugging • more stable production At first: more friction Then: more control --- **Architecture impact** Spring: • runtime-heavy • implicit behavior • strong ecosystem Quarkus: • deterministic • explicit wiring • reduced reflection (native friendly) --- **Execution model** Spring (MVC): • blocking • 1 thread per request Quarkus: • reactive + non-blocking (Vert.x) • better scalability if used correctly But: blocking code in non-blocking flow = performance issues --- **Persistence** Both use Hibernate. Spring: • repository pattern • flexible Quarkus (Panache): • less boilerplate • faster for simple CRUD • needs discipline --- **Cloud & native** Spring = cloud compatible Quarkus = cloud-native by design • fast startup • low memory • native (GraalVM) ready --- **Reality check** Spring: • huge ecosystem • best for complex/legacy Quarkus: • more predictable • better for microservices But requires: • discipline • understanding of model --- **My takeaway** Not about performance. It’s about predictability. Less “why in prod?” More “I know why” --- Have you tried Quarkus in production? --- #Java #Quarkus #SpringBoot #Backend #SoftwareArchitecture #Microservices #CloudNative #GraalVM #TechLead #SoftwareEngineering

💡 Autowiring in Spring – Simplifying Dependency Injection While working with the Spring Framework, one of the most powerful features that improves development efficiency is Autowiring. It allows Spring to automatically inject dependencies into a bean without requiring explicit configuration in XML or manual object creation. Autowiring helps reduce boilerplate code and makes applications cleaner, more readable, and easier to maintain. Instead of manually wiring objects, the Spring container identifies and injects the required dependencies at runtime. Spring provides different annotations to support autowiring: 🔹 @Autowired – Automatically injects dependencies based on type. It is the most commonly used annotation and can be applied on fields, constructors, or setter methods. 🔹 @Qualifier – Used along with @Autowired when there are multiple beans of the same type. It helps Spring choose the correct bean by specifying its name. 🔹 @Primary – Marks a bean as the default choice when multiple candidates are available. If no qualifier is specified, Spring selects the bean marked as @Primary. With autowiring, developers can focus more on business logic rather than configuration, making development faster and more efficient. In simple terms: ✔️ @Autowired → Inject by type automatically ✔️ @Qualifier → Resolve multiple bean confusion ✔️ @Primary → Set default bean Autowiring promotes loose coupling, improves code quality, and is widely used in real-world Spring and Spring Boot applications. Mastering this concept is essential for building scalable and maintainable backend systems 🚀 Thank you sir Anand Kumar Buddarapu #Java #Spring #SpringBoot #DependencyInjection #Autowiring #BackendDevelopment #Programming #TechLearning

🚀 Spring Framework Deep Dive - Day 26 🚨 I used RestTemplate for months. Lines of code just to make ONE API call. Boilerplate everywhere. Error handling scattered all over. Then I discovered Feign Client. And never looked back. Here's the difference every Java developer must know 👇 🔹 RestTemplate (Old way): → Manual HTTP calls → Lots of boilerplate code → You handle everything yourself → Error prone and verbose → Still works — but not recommended for new projects 🔹 Feign Client (Modern way): → Declarative HTTP client → Just define an interface — Spring does the rest → Clean, readable, minimal code → Built-in integration with Eureka + Load Balancer ✔ → Recommended for Microservices ✔ 🚀 Real-world example: Calling Payment Service from Order Service 💳 ❌ RestTemplate way: 👉 Create RestTemplate bean 👉 Build URL manually 👉 Handle response manually 👉 Handle errors manually 👉 10+ lines for ONE call 😩 ✔ Feign Client way: 👉 Define interface with @FeignClient 👉 Add method with @GetMapping 👉 Inject and call — done ✔ 👉 3 lines. Clean. Simple. Readable 🚀 💡 Simple way to remember: RestTemplate = Manual car 🚗 → You control everything yourself Feign Client = Automatic car 🚘 → Just tell it where to go — it handles the rest 🔥 The hard truth: RestTemplate is not deprecated yet. But every modern Spring Boot project uses Feign Client. 👉 Learn both — but BUILD with Feign Client ✔ 💡 Pro Tip: Feign Client + Eureka + Circuit Breaker = Complete Microservices communication stack 🚀 More deep dives coming 🚀 💬 Are you using RestTemplate or Feign Client in your projects? Comment below 👇 #SpringBoot #FeignClient #RestTemplate #JavaDeveloper #BackendDevelopment #FullStackDeveloper #OpenToWork #Java #100DaysOfCode

⚠️ Hot Reload in Spring Boot Isn’t Magic. It’s ClassLoader Isolation. When you change code and see: 👉 App restarts in seconds 👉 No full JVM restart What’s really happening? 1️⃣ Two ClassLoaders — The Core Idea Spring Boot DevTools splits your app into: Base ClassLoader   → dependencies (stable) Restart ClassLoader → your application code (changing) 2️⃣ Why This Matters Dependencies (like Spring, Hibernate): Loaded once Heavy to reload Rarely change Your code: Changes frequently Needs fast reload So only your code is reloaded. 3️⃣ What Happens on Code Change You modify a .class file DevTools detects change (file watcher) Discards Restart ClassLoader Creates a new one Reloads your classes Base ClassLoader stays untouched 4️⃣ Why It’s Faster Than Full Restart Without DevTools: JVM restarts All classes reloaded Framework reinitialized With DevTools: Only your classes reload Dependencies reused Startup drastically reduced 5️⃣ What Actually Gets Restarted? Spring ApplicationContext Beans created again Config reloaded But: 👉 JVM process stays alive 👉 Core libraries remain loaded 6️⃣ Common Gotcha (Very Important) Static state survives in Base ClassLoader. Example: static Map cache = new HashMap(); If loaded by base loader: It won’t reset after reload Leads to weird bugs 7️⃣ Why Some Changes Don’t Reload DevTools won’t reload when: Dependency JAR changes Config outside classpath changes Native resources updated Requires full restart 8️⃣ Comparison With Other Tools Tool Approach DevTools ClassLoader restart JRebel Bytecode rewriting HotSwap Limited JVM replacement DevTools doesn’t “reload classes” It replaces the ClassLoader that loaded them #Java #SpringBoot #JVM #ClassLoader #HotReload #BackendEngineering #SoftwareEngineering #LearnInPublic