Spring Boot: Ditch @Autowired for Constructor Injection

Just went LIVE with Lecture 2 of my Spring Boot Backend series 🚀 In this session, we deep-dived into Spring Boot Controllers — the core layer that handles real-world HTTP requests in production systems. 🔹 @RestController vs @Controller 🔹 GET, POST, PUT, DELETE APIs 🔹 Clean controller structure 🔹 Building the Lovable Clone backend step by step This series is focused on backend-first system design, not just theory. 🎥 Watch the live lecture here: 👉 https://lnkd.in/gf7_zkeg More lectures coming soon. Let’s build real backends, not just demos. 💻🔥 #SpringBoot #BackendDevelopment #Java #LiveCoding #SystemDesign #RESTAPI #SoftwareEngineering

Most developers use Spring Beans daily. Very few understand what actually happens inside the container. Here’s the Spring Bean lifecycle — technically simplified: 🔁 Container Startup 1️⃣ Instantiation Bean object is created (via reflection). 2️⃣ Dependency Injection @Autowired / constructor injection resolves dependencies. 3️⃣ Aware Interfaces (optional) BeanNameAware, ApplicationContextAware, etc. 4️⃣ BeanPostProcessor (Before Init) postProcessBeforeInitialization() runs. 5️⃣ Initialization Phase @PostConstruct InitializingBean.afterPropertiesSet() Custom init-method 6️⃣ BeanPostProcessor (After Init) postProcessAfterInitialization() runs. 👉 This is where Spring may wrap your bean with a proxy. That’s how @Transactional, @Async, @Cacheable, and AOP work. The injected object is often a proxy — not your original class. 7️⃣ Bean Ready for Use 🔻 Shutdown Phase 8️⃣ Destruction @PreDestroy DisposableBean.destroy() (Default applies to singletons.) Why this matters: • @Transactional fails in self-invocation • Proxy-based behavior confuses debugging • Prototype inside Singleton behaves unexpectedly • Circular dependency issues during early creation Once you understand the lifecycle, Spring stops feeling like magic. It becomes predictable. #SpringBoot #SpringFramework #Java #BackendEngineering #AOP #Microservices

How I Detect Bean Initialization Issues in Spring Boot When facing bean initialization issues in large applications, I follow these steps: ✔️ Check startup logs carefully ✔️ Look for exceptions like BeanCreationException or dependency errors From here we will clearly show which bean is failed and why. ✔️ Identify the exact bean from the stack trace ✔️ Check for circular dependencies If two beans depends on each other in that scenario spring throws an error. ✔️ Verify active profiles I will check is there any missing or wrong profiles configured. ✔️ Ensure proper component scanning and base package structure I will make sure all classes are inside base package of main class annotated with @SpringBootApplication. Most of the time, reading logs properly helps find the root cause quickly. #SpringBoot #Java #BackendDevelopment #Debugging

🌱 Bean Creation in Spring — More Important Than It Looks In Spring Boot, we use beans everywhere — but many developers don’t fully think about how they are created and managed. A Spring Bean is simply an object managed by the IoC (Inversion of Control) container. 🔹 Beans can be created using: • @Component, @Service, @Repository • @Configuration + @Bean • Auto-configuration 🔹 Why Bean management matters: • Dependency Injection reduces tight coupling • Singleton scope improves performance (default scope) • Lifecycle management (@PostConstruct, @PreDestroy) ensures controlled initialization Good backend systems are not just about writing classes — they’re about letting the container manage object creation efficiently. Understanding bean lifecycle = better Spring architecture. #Java #SpringBoot #SpringFramework #DependencyInjection #BackendEngineering

As many of you know, the Spring community has strongly recommended constructor injection over field injection starting from newer versions of Spring Framework. If you’ve recently migrated from an older version of Spring Boot to a newer one, updating your code. 🔎 Key Change in Test Classes One common issue I’ve noticed during migration: ❌ Overusing @SpringBootTest which causes failure of some of the test cases. @SpringBootTest loads the full application context, which: Increases test execution time Makes tests heavier than necessary Reduces test isolation ✅ Recommended Approach Instead of using @SpringBootTest everywhere, prefer more focused test annotations depending on what you're testing: @WebMvcTest → For controller layer @DataJpaTest → For repository layer @RestClientTest → For REST client components @ExtendWith(MockitoExtension.class) → For pure unit tests with mocks This ensures: ✔ Faster test execution ✔ Better separation of concerns ✔ Cleaner and more maintainable test code Migration is not just about “making it work” — it’s about aligning with best practices for performance, maintainability, and clean architecture. #SpringBoot #Java #UnitTesting #SoftwareEngineering #CleanCode

💡 A design lesson from a real Spring Boot challenge Recently, I faced an interesting problem while working on a service that depended on multiple beans of the same type. At first glance, @Qualifier looks like the obvious fix. But there was a catch. I wanted this service to remain a generic utility, not a client-specific service. Using qualifiers would have tightly coupled the service to concrete client implementations, making it harder to reuse and extend as more clients get added. Because these clients couldn’t be clubbed into a single bean (due to bean creation constraints), injecting one directly resulted in bean ambiguity errors. 👉 What I did instead: I redesigned the service as a pure utility and passed the required client as a method argument, rather than injecting it at the class level. Why this approach worked better: • Avoided bean ambiguity without relying on qualifiers • Kept the service generic and reusable • Prevented tight coupling to specific client beans • Made the design more extensible for future clients This was a good reminder that while Spring gives us powerful tools, sometimes the better solution is a design change, not an annotation change. Curious how others approach multiple beans of the same type in Spring 👇 #SpringBoot #Java #BackendEngineering #CleanArchitecture #SoftwareDesign #LearningInPublic

📌 Spring Boot Annotation Series – Part 8 ✅ @Component annotation The @Component annotation is used to mark a class as a Spring-managed bean 👇 🔹 Why do we use @Component? To tell Spring: 👉 “Create an object of this class and manage it.” - To enable dependency injection - To let Spring detect the class during component scanning 🔹 How does it work? When Spring Boot starts: - It scans packages (using @ComponentScan) - Finds classes annotated with @Component - Creates and registers them as beans in the Spring container 🔹 Simple example @Component public class EmailService { public void sendEmail() { System.out.println("Email sent"); } } Now this class can be injected using: @Autowired private EmailService emailService; 🔹 In simple words @Component tells Spring to automatically create and manage this class as a bean. 👉 🧠 Quick Understanding - Marks a class as a Spring bean - Detected during component scanning - Enables dependency injection #SpringBoot #Java #Component #BackendDevelopment #LearningInPublic

☕ Trying to Understand, Not Memorize Right now, I’m trying to better understand how Spring Boot manages beans and their lifecycle. Instead of memorizing annotations, I’m focusing on: • when objects are created • how dependencies are injected • why lifecycle management matters Taking a slower approach is helping concepts stick better. #SpringBoot #Java #BackendDevelopment #LearningInPublic #Upskilling

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝗧𝗶𝗽 🔥 💎 𝗥𝗲𝘀𝘁𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 𝘃𝘀 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗘𝗻𝗱𝗽𝗼𝗶𝗻𝘁𝘀 ✅ 𝗥𝗲𝘀𝘁𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 have been the traditional way of building web APIs in Spring Boot. They provide a more organized and structured approach, especially for larger applications with multiple endpoints and complex routing. ✅ 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗘𝗻𝗱𝗽𝗼𝗶𝗻𝘁𝘀 were introduced in Spring 5 and aim to simplify the process of building reactive APIs with less ceremony. They are more concise and focus on functional programming style with RouterFunction and HandlerFunction. 💡 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗘𝗮𝗰𝗵 ◾ Use 𝗥𝗲𝘀𝘁𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 when you have a larger, more complex API with many endpoints and you need the structure and organization that controllers provide. ◾ Use 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗘𝗻𝗱𝗽𝗼𝗶𝗻𝘁𝘀 when you have a reactive application with WebFlux and want a more composable, functional approach. Functional endpoints are well-suited for microservices and reactive systems. 🔥 𝗛𝗼𝘄 𝘁𝗼 𝗖𝗼𝗻𝘃𝗲𝗿𝘁 𝗥𝗲𝘀𝘁𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 𝘁𝗼 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗘𝗻𝗱𝗽𝗼𝗶𝗻𝘁  ◾ 𝗗𝗿𝗼𝗽 𝗰𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿𝘀: Use RouterFunction with route() builder instead. ◾ 𝗜𝗻𝗷𝗲𝗰𝘁 𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆: Pass them as @Bean parameters or use constructor injection. ◾ 𝗨𝘀𝗲 𝗦𝗲𝗿𝘃𝗲𝗿𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗲 𝗳𝗼𝗿 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗲𝘀: Use ok(), created(), notFound() methods. ◾ 𝗟𝗼𝘀𝗲 𝘁𝗵𝗲 𝗮𝗻𝗻𝗼𝘁𝗮𝘁𝗶𝗼𝗻𝘀: Routing happens in the RouterFunction directly. #java #springboot #programming #softwareengineering #softwaredevelopment

Added Bucket4j Dependency… Build Successful… But What Actually Happened?” Yesterday a junior dev told me: “Bhai dependency add kiya, build successful, rate limiter chal gaya… but andar kya hua?” That question shows growth. 🔥 Let’s break it like an Architect. 🧩 Step 1: When You Add Bucket4j in pom.xml <dependency> <groupId>com.bucket4j</groupId> <artifactId>bucket4j-core</artifactId> </dependency> What actually happens? ✔ Maven downloads the JAR ✔ Adds it to project classpath ✔ Compiler can now see io.github.bucket4j classes ✔ No error → build successful But remember: Nothing is active yet. You only added capability. 🧠 Step 2: When Spring Boot Starts Spring Boot: Creates ApplicationContext Scans Beans Registers Filters Instantiates Singletons When you create: @Bean public Bucket bucket() { return Bucket.builder() .addLimit(Bandwidth.simple(10, Duration.ofMinutes(1))) .build(); } Now Spring: ✔ Registers BeanDefinition ✔ Creates Bucket instance ✔ Stores in ApplicationContext ✔ Injects where needed Now rate limiter is alive in memory. 🪣 Step 3: What Bucket4j Actually Does It uses Token Bucket Algorithm. Each request: bucket.tryConsume(1); Internally: Checks current time Refills tokens if needed Atomically decrements counter Allows or rejects request Thread-safe. Lock-free. High performance. 🛡 Where Should Rate Limiting Be Applied? Best layer: Client ↓ Filter (Rate Limit Here) ↓ Controller Why Filter? ✔ Stops traffic early ✔ Saves DB ✔ Saves CPU ✔ Protects downstream services 🏗 Production-Level Thinking Application-level limiter is good. Gateway-level limiter is better. Both together = defense in depth. ⚠ Important Lesson Dependency ≠ Feature You added a library. Spring managed lifecycle. Bucket4j handled algorithm. JVM executed atomic operations. Everything worked together. That’s engineering. Not magic. The day you start asking “Behind the scenes kya ho raha hai?” That’s the day you move from coder to architect. 🚀 #Java #SpringBoot #Bucket4j #SystemDesign #RateLimiting #BackendEngineering