Spring Constructor Injection Explained

I'm starting a new series: Learn Java Reflection by building a Mini Spring Framework from scratch. Not just reading about it. Actually building it. Most Java developers use Spring every day — `@Component`, `@Autowired`, `@Transactional` — without ever understanding what's happening underneath. The answer to all of it is one API: Java Reflection. In this series, we use Reflection as the lens AND the tool. Every concept we cover, we immediately apply to build a real piece of the framework. Theory and implementation, side by side. By the end, you won't just know how Reflection works. You'll know how frameworks think. First blog is live now 👇

Spring Core DAY 11 – Spring Bean Life Cycle 🚀 What is Spring Bean Life Cycle? In Spring Framework, a Bean is simply an object that is created, configured, and managed by the Spring IOC Container. But have you ever wondered what happens behind the scenes when Spring creates a bean? 🤔 That complete journey is called the Spring Bean Life Cycle. 🔄 Complete Life Cycle Flow 1️⃣ Bean Instantiation (Creation) The IOC container creates the bean object. This happens using the constructor (default or parameterized). 👉 At this stage, the object exists but is not fully ready. 2️⃣ Dependency Injection Spring injects required dependencies. Injection can be done using: Constructor Injection Setter Injection Field Injection ✔ Now the bean is configured with required dependencies. 3️⃣ Bean Name Awareness (Optional) If the bean implements: BeanNameAware BeanFactoryAware ApplicationContextAware Spring provides additional information like: Bean name Bean factory reference Application context 4️⃣ Pre-Initialization Phase BeanPostProcessor methods are called. postProcessBeforeInitialization() runs. 👉 Used for custom modifications before initialization. 5️⃣ Initialization Phase Now Spring calls: @PostConstruct method OR afterPropertiesSet() (InitializingBean) OR Custom init-method ✔ Bean is now fully initialized and ready to use. 6️⃣ Bean Usage The bean is now available for application use. It remains active inside the Spring container. Used by controllers, services, repositories, etc. 7️⃣ Pre-Destruction Phase When the container is shutting down: @PreDestroy method OR destroy() (DisposableBean) OR Custom destroy-method ✔ Used to release resources (DB connections, files, threads). 🎯 Why Understanding Bean Life Cycle is Important? ✔ Proper resource management ✔ Avoid memory leaks ✔ Improve performance ✔ Helps in debugging Spring applications ✔ Frequently asked in interviews Imagine a Database Connection Bean: Created → Connection object created Injected → DB credentials injected Initialized → Connection opened Used → Queries executed Destroyed → Connection closed Spring handles everything automatically 🤖 🧠 Interview Tip 👉 Difference between: @PostConstruct vs Constructor @PreDestroy vs destroy-method Singleton vs Prototype lifecycle behavior ⚠️ Remember: Destruction callbacks are not called for Prototype scope beans. 📌 In short: Create ➝ Inject ➝ Initialize ➝ Use ➝ Destroy That’s the complete Spring Bean Journey.

 DAY 10 – Dependency Injection (DI) 📘 Spring Core – Day 10 💡 What is Dependency Injection? In real-world applications, classes often depend on other classes to do their job. The traditional approach is creating those dependencies using the new keyword — which tightly couples the code. 🚀 Dependency Injection (DI) changes this mindset. Instead of a class creating its own dependencies, Spring injects them from outside. This simple shift makes your application more flexible, maintainable, and test-friendly. 🔧 Types of Dependency Injection in Spring 🔹 Constructor Injection Dependencies are provided through the class constructor. ✔ Ensures required dependencies are available at object creation ✔ Preferred approach in modern Spring applications ✔ Encourages immutability and clean design 🔹 Setter Injection Dependencies are provided using setter methods after object creation. ✔ Useful for optional dependencies ✔ Allows flexibility when dependencies may change later 🎯 Why Dependency Injection matters so much? ✅ Loose Coupling – Classes depend on interfaces, not implementations ✅ Cleaner Code – No hardcoded object creation logic ✅ Easy Unit Testing – Dependencies can be mocked effortlessly ✅ Better Scalability – Code is easier to extend and modify ✨ Spring + Dependency Injection = Production-ready, professional Java applications If you truly want to write enterprise-level code, DI is not optional — it’s essential.

Hi everyone 👋 Continuing the Spring Boot Validation Series part 28 👇 📌 Validation Annotation – @Size The @Size annotation is used to define minimum and maximum length for a field 👇 🔹 Why do we use @Size? Sometimes we need to restrict input length. 👉 Example: - Username should be at least 3 characters - Password should be at least 8 characters @Size helps us enforce these rules. 🔹 Simple Example - public class User { @Size(min = 3, max = 20) private String name; @Size(min = 8) private String password; } @PostMapping("/users") public String createUser(@Valid @RequestBody User user) { return "User created"; } 👉 If value is too short or too long → validation fails ❌ 🔹 Important Point 👉 @Size works with: - String - Collection (List, Set, etc.) - Arrays 🔹 Example with List @Size(min = 1, max = 5) private List<String> roles; 👉 Ensures list size is between 1 and 5 🔹 Common Mistake 👉 @Size does NOT check for null ❌ So often we combine it with: @NotNull @Size(min = 3, max = 20) private String name; 🔹 In simple words @Size controls how short or long a value can be. 👉 🧠 Quick Understanding - Used for length validation - Works on String, List, Array #SpringBoot #Java #Validation #SizeAnnotation #BackendDevelopment #LearningInPublic

🚀 Internal Working of IOC (Inversion of Control) in Spring. Understanding how Spring manages your application behind the scenes 👇 📌 Step-by-Step Flow: 1️⃣ Configuration Loading → Spring reads config (@Component, @Bean, etc.) 2️⃣ Bean Definition → Classes are identified & metadata is created 3️⃣ IOC Container → ApplicationContext initializes 4️⃣ Bean Creation → Objects created by Spring (no "new") 5️⃣ Dependency Injection → Dependencies injected (@Autowired) 6️⃣ Initialization → Init methods called (@PostConstruct) 7️⃣ Ready to Use → Bean is fully configured ✅ 8️⃣ Lifecycle Management → Create → Use → Destroy 9️⃣ Destruction → Cleanup (@PreDestroy) 💡 In Short: Spring handles object creation & dependencies, you focus only on business logic! ✨ IOC = Less effort, more control #Java #SpringBoot #SpringFramework #IOC #DependencyInjection #BackendDevelopment #Coding #InterviewPreparation

🚀 DAY 9 — Spring Revision (Day 1 → Day 8) 🔥 Before starting Spring Boot, I revised everything I learned so far 👇 📌 🔁 QUICK REVISION (IMPORTANT POINTS) ✅ Day 1 — Why Spring? Too many technologies earlier (JSP, Servlet, JDBC) Spring reduces complexity Provides one ecosystem for backend ✅ Day 2 — IoC & DI IoC → Spring controls object creation DI → Spring injects dependencies Loose coupling achieved ✅ Day 3 — Spring vs Spring Boot Spring → more configuration Spring Boot → auto configuration + embedded server Boot = faster development ✅ Day 4 — Constructor Injection Dependency passed via constructor Recommended way ✔️ No new keyword ✅ Day 5 — XML vs Annotation XML → old, more config Annotation → modern, less code Needs @ComponentScan ✅ Day 6 — Core Annotations @Component → bean @Service → business logic @Repository → DB @Controller → request @Autowired → DI ✅ Day 7 — Bean Basics Bean = object managed by Spring Created by IoC container Scope: Singleton (default), Prototype ✅ Day 8 — Bean Lifecycle Create → Inject → Init → Use → Destroy @PostConstruct → after init @PreDestroy → before destroy 🎯 🔥 INTERVIEW QUESTIONS (MUST KNOW) ❓ What is Spring? 👉 Framework for building Java applications, reduces complexity ❓ What is IoC? 👉 Control of object creation given to Spring ❓ What is Dependency Injection? 👉 Injecting required objects instead of creating manually ❓ Types of DI? 👉 Constructor, Setter, Field (Constructor preferred) ❓ What is Bean? 👉 Object managed by Spring container ❓ Bean Scope? 👉 Singleton (one object), Prototype (multiple objects) ❓ Bean Lifecycle? 👉 Create → Inject → Init → Use → Destroy ❓ Difference: Spring vs Spring Boot? 👉 Boot reduces configuration, adds embedded server ❓ @Component vs @Service vs @Repository? 👉 Same working, different purpose (layer-wise clarity) ❓ What is @Autowired? 👉 Automatically inject dependency ❓ What is ApplicationContext? 👉 IoC container that manages beans 💡 FINAL UNDERSTANDING 👉 Spring = Manage objects + reduce complexity 👉 IoC + DI = Core of Spring 💬 Did you revise before jumping to Spring Boot? Day 9 done ✅ #Spring #Java #BackendDevelopment #LearningInPublic #30DaysOfCode #SpringBoot #Developers

Day 7: Mastering Dependency Injection Architectures in Spring 🚀 I’m officially one week into my Spring Framework journey! Today was a deep dive into the core of how Spring manages object dependencies. Understanding the "How" and "When" of Dependency Injection (DI) is a game-changer for writing clean, maintainable code. Here are my key takeaways from today’s session on Setter vs. Constructor Injection: 🔹 Setter Injection: Uses <property> tags in XML and requires setter methods in your bean class. Pro-tip: This is the preferred choice when your bean has a large number of properties (e.g., 10-12), as it avoids creating massive, unreadable constructors. 🔹 Constructor Injection: Uses <constructor-arg> tags and requires a parameterized constructor. Pro-tip: This is ideal for mandatory dependencies or when you have only a few properties (e.g., 2-3) to keep your code concise. ⚠️ Did you know? If you configure both Setter and Constructor injection for the same property, Setter Injection wins. This is because the IOC container first creates the object via the constructor and then calls the setter method, effectively overriding the initial value. 🛠️ Moving Toward Modern Configs: I also explored XML + Annotation-driven configurations. By using <context:component-scan> and the @Autowired annotation, we can let Spring handle the heavy lifting of injection automatically on fields, setters, or constructors. This significantly reduces the boilerplate XML code! Every day, the "magic" of Spring becomes a little more clear. Onward to Day 8! #SpringFramework #JavaDeveloper #BackendDevelopment #LearningJourney #SoftwareEngineering #DependencyInjection #CodingCommunity #TechLearning

🔥 Part 2 of the series is live: We just implemented @Autowired from scratch. Not just reading about it. Actually building it. Most Java developers use Spring every day — @Component, @Autowired, @Transactional — without ever understanding what's happening underneath. The answer to all of it is one API: Java Reflection. In this series, we use Reflection as the lens AND the tool. Every concept we cover, we immediately apply to build a real piece of the framework. Theory and implementation, side by side. By the end, you won't just know how Reflection works. You'll know how frameworks think. Second blog is live now 👇

HOW MANY CONSTRUCTORS CAN BE THERE IN A CLASS? You’ve probably heard of function overloading — using the same function name with different parameters. For example: int add(int a){ return a + a; } int add(int a, int b){ return a + b; } Simple, right? But here’s something many developers overlook 👇 👉 Constructor Overloading Just like functions, constructors in a class can also be overloaded based on the number or type of arguments passed while creating an object. Here’s a quick example: class A { public: A(){ cout << "Constructor called without value"; } A(int a){ cout << "Constructor called with value: " << a; } }; 💡 This means: • You can create objects in different ways • You can control how an object is initialized • You can make your code more flexible and readable 📌 Why it matters: Constructor overloading helps you design better classes by giving multiple ways to initialize objects depending on the situation. ⸻ 🔁 In short: • Function Overloading → Same function, different parameters • Constructor Overloading → Same class, multiple ways to initialize objects PS: Languages that support constructor overloading: C++, C#, Java

🔥 final vs finally vs finalize — Clear & Simple Explanation 🔹 final (keyword): • final variable → value cannot be changed once assigned • final method → cannot be overridden in a subclass • final class → cannot be inherited (no subclass can be created) • Example: `final int x = 10;` 🔹 finally (block): • Always executes after try-catch (whether exception occurs or not) • Used for cleanup tasks like closing DB connections, files, etc. • Executes even if a return statement is present in try or catch • Example: `finally { conn.close(); }` 🔹 finalize() (method): • A method of Object class, called by Garbage Collector before object is destroyed • Used earlier for cleanup, but NOT reliable for critical operations • Deprecated since Java 9 ⚠️ • Avoid using it — use try-with-resources or explicit cleanup instead ✅ #Java #JavaInterview #JavaDeveloper #BackendDeveloper