Ditch Field Injection in Spring Boot for Constructor Injection

For a long time, I used @Autowired and @Bean without really thinking about what happens in between. The bean exists. It works. Move on. But going deep on Spring Boot means stopping at the things that just work and asking how exactly it happens. The bean lifecycle is one of those things. Spring doesn't just create your object and hand it to you. It goes through a sequence like parsing the definition, instantiation, dependency injection, Aware interfaces, post-processors, initialisation, and eventually destruction. Each phase has a purpose. And each one is a place where things can go quietly wrong if you don't know it exists. The one that surprised me most is you cannot rely on @Autowired fields inside a constructor, because dependency injection hasn't happened yet at that point. The constructor runs first. The fields are populated later. That kind of detail doesn't show up in tutorials. It shows up when something behaves unexpectedly and you have no idea where to look. This article by Hüsna Poyraz explains the full lifecycle clearly, worth reading if you're learning Spring Boot seriously. Link in the comments. #SpringBoot #Java #BackendDevelopment

🚀 Day 20/100: Spring Boot From Zero to Production Topic: Custom Auto-Configuration We covered Auto-Configuration. We covered disabling it. But does it stop there? Nope. 👀 Spring Boot lets you build your own auto-configuration too. 🔧 But, How It Works? You create a @Configuration class and slap conditionals on it. Spring Boot only loads it if your conditions are met. Two most common ones: @ConditionalOnClass → Load only if a class exists on the classpath @ConditionalOnProperty → Load only if a property is set in application.properties 💡 See the code attached below. ⬇️ No DataSource on classpath? → Skipped entirely db.enabled=false? → Skipped entirely Bean already defined by user? → Your default is skipped ✅ 📌 Don't forget to register it In META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports: -> com.yourpackage.MyDataAutoConfiguration Without this, Spring Boot won't pick it up. Checkout the previous posts on Auto-Config & disabling it to better understand the sequence. See you in the next one! #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend #AutoConfiguration

📘 Spring Framework Today I explored how Spring handles dynamic values, external configuration, and stereotype annotations. 🔹 Spring Expression Language (SpEL) 🔹 Using @Value for injecting properties 🔹 Externalized configuration with properties files 🔹 Stereotype annotations (@Component, @Service, @Repository, @Controller) 🔹 Understanding how Spring organizes application layers What I’m realizing while learning Spring is that it’s not just about creating beans — it’s about managing application flow in a structured and maintainable way 💡 Documenting my journey one concept at a time 🚀 From next Post... Journey to Spring Boot will begin... #SpringFramework #JavaDeveloper #SpringBoot #BackendDevelopment #LearnInPublic #CodingJourney

🧠 After learning Dependency Injection, I explored one practical Spring Boot best practice today 👀 Constructor Injection vs Field Injection At first, field injection looked easier 👇 @Autowired private UserService service; But while going deeper, I realized why most production-grade projects prefer constructor injection 🚀 ✅ Dependencies are explicit ✅ Easier to unit test ✅ Works well with final fields ✅ Better immutability ✅ Cleaner and safer design 💡 My takeaway: Field injection may feel quick, but constructor injection makes the architecture much more maintainable in real-world applications. Tiny design choices create huge long-term impact ⚡ #Java #SpringBoot #DependencyInjection #BackendDevelopment #LearningInPublic

While working on code standardization in our Spring Boot services, I revisited something very fundamental — how we inject dependencies. Earlier, many classes were using field injection (@Autowired). As part of cleanup and consistency, I refactored them to constructor injection using @RequiredArgsConstructor. At first, it looked like a small structural change… but it actually brought some meaningful improvements: 1. Immutability by design Dependencies are now final, which means they can’t be reassigned after object creation. This makes the code safer and more predictable. 2. No partially initialized objects With constructor injection, a class cannot be created without its required dependencies. This avoids hidden null risks that can occur with field injection. 3. Improved testability We can now instantiate classes directly with mocks, without needing to spin up the Spring context. This makes unit testing faster and cleaner. 4. Clear and explicit dependencies The constructor clearly shows what the class depends on, improving readability and maintainability. 5. Early detection of design issues Constructor injection helps catch circular dependencies at startup rather than at runtime. What started as a “standardization task” ended up reinforcing how small design choices can significantly impact code quality, testability, and maintainability. Curious to know , do you still see field injection being used in your projects, or has your team fully moved to constructor injection? #BackendDevelopement #Java #SpringBoot #LowLevelDesign

⚙️ @Autowired vs Constructor Injection — Which One Should You Use? Most beginners use @Autowired everywhere… But in real-world projects, that’s not the best practice. Let’s understand 👇 👉 @Autowired (Field Injection) @Autowired private UserService userService; ✔ Easy to write ❌ Hard to test ❌ Not recommended for production 👉 Constructor Injection (Recommended) private final UserService userService; public UserController(UserService userService) { this.userService = userService; } ✔ Better testability ✔ Immutability (final fields) ✔ Recommended by Spring 💡 Why Constructor Injection is better: Dependencies are explicit Easier for unit testing Prevents null issues 🚀 In my Spring Boot project, I switched to constructor injection and it made my code cleaner & more maintainable. 🧠 Key Insight: Good code is not just working code — it’s maintainable code. Which one are you using in your projects? #Java #SpringBoot #CleanCode #BackendDevelopment #FullStackDeveloper

In one of my projects, we built a service using Spring Boot that looked perfectly fine in development 💻 Minimal configuration. Embedded server. Everything just worked ✨ That’s what Spring Boot is great. It removes a lot of setup so you can focus on building features 💫 But after deployment, we started seeing inconsistent behavior. Some requests were slow 🐢 A few started timing out under load ⏱️ My task was to figure out what was going on. I started digging into logs and enabled Actuator metrics 📊 At first, nothing obvious. Then it became clear. We were relying heavily on defaults ⚠️ Spring Boot had auto configured everything for us: thread pools, connection pools, HTTP clients ⚙️ Which is great… until your traffic pattern doesn’t match those defaults. Under load, threads were getting blocked. External calls had no proper timeouts. Connection limits were being hit 🚫 We tuned the configs, added proper timeouts and improved observability. Things stabilized 📈 That experience changed how I see Spring Boot. Auto configuration is powerful, but you should understand what it’s configuring 🧠 Defaults are helpful, but not production ready for every case ⚙️ Actuator and metrics are essential, not optional 📊 Spring Boot makes it easy to start. But running it reliably in production is a different skill. What’s one thing Spring Boot taught you only after working with it in production? #Java #SpringBoot #SoftwareEngineering #BackendDevelopment

🚨 Spring Boot gotcha that cost me hours… I thought my "@Transactional" was working perfectly… Until it silently stopped working 😶 The culprit? 👉 Self Invocation (internal method calls) --- 💥 What works: When a method is called from outside the bean ➡️ Spring Proxy intercepts the call ➡️ Transaction starts ✅ --- ❌ What DOESN’T work: When a method calls another method inside the same class this.placeOrderInternal(); // ❌ bypasses proxy ➡️ No proxy ➡️ No transaction ➡️ No rollback 😬 --- ⚠️ Same problem happens with: - "@Async" - Custom annotations (AOP) - Multi-tenant filters (ThreadLocal based) 👉 Especially when using "@Async" Your logic runs in a different thread ➡️ Filter context is LOST ➡️ Tenant info = NULL 💣 --- 🧠 Why this happens? Spring uses proxies (AOP) No proxy = No magic --- 🛠️ Fixes: ✔️ Call method from another bean ✔️ Inject self proxy ✔️ Use "TransactionTemplate" ✔️ Pass context manually for "@Async" (ThreadLocal won’t work automatically) --- 💡 Real lesson: If Spring can't intercept your call… 👉 Your annotation is just decoration. --- Have you ever debugged something like this for hours? 😅 Drop your experience 👇 #SpringBoot #Java #Backend #Microservices #Programming #100DaysOfCode

Most beginners make one big mistake in Spring Boot. They put all their logic inside the controller. I used to do the same — until I realized how messy and unmaintainable it becomes. So I created a simple project to show how to properly separate Controller and Service layers - the way it’s done in real-world applications. In this first part of my “Clean Spring Boot” series, you’ll learn: • Why separating layers matters • How to structure Controller and Service • How dependency injection works • How request flow works in a Spring Boot application I also recorded a step-by-step video while building the project 🎥 📖 Read the article: https://lnkd.in/gxk7bw2p 🎥 Watch the video: https://lnkd.in/g5EWy9z2 Part 2 coming soon — we’ll integrate a database using JPA #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #Programming #CleanCode