Spring Dependency Injection: Constructor vs Field Injection

🚀 Day 13/100 - Spring Boot Annotations - 4️⃣ @Configuration & @Bean ➡️ @Configuration 🔹What is it - A class-level annotation which tells Spring that this class contains bean definitions for the IoC container. - It is a modern replacement for XML-based configuration. 🔹Why to use - Makes configuration type-safe - Easy to read and maintain - Fully Java-based (no XML) ➡️ @Bean 🔹What is it - A method-level annotation used inside a @Configuration class to explicitly create and register a bean in the Spring container. 🔹Why to use - Useful when you cannot modify a class (e.g., third-party libraries) - Gives full control over object creation and configuration 📌 Key Takeaway @Configuration → where beans are defined @Bean → how a bean is created Next post: https://lnkd.in/d3pztG-x Previous post: https://lnkd.in/d8NzCVkB #100Days #SpringBoot #Java #BackendDevelopment #SoftwareEngineering

🛑 @Autowired on Fields in Spring Boot? STOP I see this pattern all the time: public class MyService {    @Autowired    private UserRepository userRepository; } ✅ Quick to write ❌ But a ticket to technical debt Here’s why Constructor Injection wins every time: 1️⃣ Testable 🧪 No Spring context needed. Just pass mocks to the constructor. Unit testing becomes effortless. 2️⃣ Immutable 🔒 Make dependencies final. Safer, predictable, clean. 3️⃣ Hidden Dependencies 🙈 Too many @Autowired fields? A big red flag. It’s a sign your class is violating the Single Responsibility Principle. 💡 The Fix: Use explicit constructors (Spring Boot 3.x style) public class MyService {    private final UserRepository userRepository;    public MyService(UserRepository userRepository) {        this.userRepository = userRepository;    } } ✅ Key takeaway: Constructor injection doesn’t just make testing easier—it also reveals hidden design problems that field injection can hide. ✅ Cleaner ✅ Safer ✅ Easier to test #SpringBoot #Java #CleanCode #SoftwareEngineering #BestPractices #ConstructorInjection

✅ Here’s another fix: If Lombok dependency is already in the project, simply use @RequiredArgsConstructor with final fields, no need to write constructors manually. Same benefits, zero boilerplate. 🚀 #springboot #java #lombok #cleancode #selflearning

🚀 Spring Tip: Mastering @ControllerAdvice & @RestControllerAdvice! 🚀 Did you know? With @ControllerAdvice and @RestControllerAdvice, you can centralize exception handling, data binding, and model population across all your Spring controllers! 🌐 A few pro tips: - @ControllerAdvice applies to all controllers by default, but you can target specific ones using annotations, packages, or class types. - @RestControllerAdvice = @ControllerAdvice + @ResponseBody for seamless API error responses. Global exception handlers in advice classes kick in after local ones, while global model/binder methods run before local ones. Keep your code DRY, robust, and maintainable! 💡 #SpringBoot #Java #Backend #CleanCode #ExceptionHandling

💡 **5 Spring Boot mistakes I stopped making** When I started, I thought “convention over configuration” meant I could skip understanding what’s happening under the hood. That didn’t go well. 😅 **1. Field Injection Instead of Constructor Injection** ❌ Bad: ```java @Autowired private UserService userService; ``` ✅ Better: ```java private final UserService userService; public UserController(UserService userService) { this.userService = userService; } ``` Why? Immutability, easier testing, compile-time safety. **2. Not Configuring Thread Pools for @Async** I added @Async and got a new thread for EVERY call. Always configure your executor: ```java @Bean public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); return executor; } ``` **3. Returning Entities from Controllers** ❌ Exposes database structure ❌ Causes lazy loading issues ❌ Makes API changes painful ✅ Use DTOs instead for clean separation. **4. Try-Catch in Every Controller** Use @RestControllerAdvice for global exception handling instead of repeating try-catch blocks everywhere. **5. Hardcoding Values** Use @ConfigurationProperties instead of @Value scattered everywhere. Type-safe and organized. ----- **Biggest lesson:** Spring Boot makes things easy, but understanding the “why” makes you a better developer. **What Spring Boot mistakes did you make?** Drop them below! 👇 ----- #SpringBoot #Java #BackendDevelopment #SoftwareEngineering #Learning

Post No: 022 Why Field Injection Is a Bad Idea in Spring Boot? Field injection (using @Autowired directly on variables) looks clean and easy, but it hides important details. When dependencies are injected into fields, you can’t easily see what a class really needs to work. This makes the code harder to understand, harder to test, and easier to break. In unit tests, you often have to use reflection or Spring itself just to create the object, which defeats the purpose of simple testing. Constructor injection is a better choice because it makes dependencies clear and mandatory. If something is required, it must be passed in the constructor, so the object is always created in a valid state. It also makes your code easier to test, more readable, and safer for future changes. Clean code is not about writing less code—it’s about writing code that’s easy to maintain. #SpringBoot #Java #CleanCode #BackendDevelopment #SoftwareEngineering

🚨 Spring Boot Circular Dependency – Explained Definition: A circular dependency occurs when Bean A depends on Bean B, and Bean B depends back on Bean A. Why it happens: Usually due to shared or misplaced business logic across services. Example: OrderService → DiscountVoucherService → OrderService ❌ How Spring detects it: Spring maintains a "currently creating beans" list. When creating DiscountVoucherService, it’s added to the list. DiscountVoucherService needs OrderService → added to list. OrderService needs DiscountVoucherService → already in list → cycle detected. Why to avoid: Causes startup failure, broken transactions, and tight coupling. Common mistake: Injecting concrete service implementations instead of interfaces or abstractions. Bad fix: spring.main.allow-circular-references=true (hides the design flaw, not a solution). Right solution: Extract shared logic into a separate helper/domain service. Rule of thumb: Services at the same layer should never depend on each other 🔁 #SpringBoot #Java #Microservices #BackendDevelopment #SoftwareEngineering #CleanCode #DependencyInjection #JavaDeveloper #TechTips #Programming #SpringFramework #BestPractices

🚀 How a DTO Saved Me in Spring Boot I had a form that needed to save data into two tables from one page. Binding directly to two entities? Errors everywhere. 😅 Solution? DTO. I created a DTO holding all fields, bound the form to it, and then mapped it to the two entities. Result: clean code, no binding errors, form submits perfectly. 💥 Lesson: Sometimes a simple DTO is all it takes to fix complex binding problems. #SpringBoot #Java #DTO #BackendDevelopment #DeveloperLife

While implementing a partial update (PATCH) API in a Spring Boot service layer, I used Spring’s ReflectionUtils.findRequiredField() to dynamically update entity fields. Instead of writing multiple conditional setter calls, I leveraged Java Reflection to update only the fields provided in the request. Field field = ReflectionUtils.findRequiredField(Employee.class, fieldName); field.setAccessible(true); ReflectionUtils.setField(field, employee, value); Why I used findRequiredField: 1. Ensures the field must exist in the entity 2. Follows a fail-fast approach (throws exception if field is missing) 3. Keeps service-layer logic clean and generic 4. Ideal for controlled/internal PATCH operations. Key takeaway: findRequiredField() is best used when field names are validated or predefined, while findField() is safer for untrusted user inputs. This approach helped me reduce boilerplate code and improve maintainability in Spring Boot applications. #Reflection bypass encapsution, so it should be used carefully with proper validation and type handling. #Java #SpringBoot #Reflection #RESTAPI #PATCH #BackendDevelopment #Microservices #CleanCode #LearningJourney