🔹 What is the Spring Bean Lifecycle?

💡 Spring Beans go through multiple phases: creation, initialization, usage, and destruction.

💡 Spring provides hooks to customize these phases (e.g., @PostConstruct, @PreDestroy).

📌 Phases of the Spring Bean Lifecycle

🔥 Step by Step Breakdown:

1️⃣ Bean Instantiation → Spring creates the bean instance.

2️⃣ Populate Properties (Dependency Injection) → Spring injects dependencies.

3️⃣ Bean Name is Set (BeanNameAware#setBeanName())

4️⃣ Bean Factory is Set (BeanFactoryAware#setBeanFactory())

5️⃣ ApplicationContext is Set (ApplicationContextAware#setApplicationContext())

6️⃣ Before Initialization Processing (BeanPostProcessor#postProcessBeforeInitialization())

7️⃣ Custom Initialization Methods:

• InitializingBean#afterPropertiesSet()
• @PostConstruct
• init-method (if specified in XML or @Bean)

8️⃣ After Initialization Processing (BeanPostProcessor#postProcessAfterInitialization())

9️⃣ Bean is Ready for Use! 🚀

🔟 Before Destruction Processing (DestructionAwareBeanPostProcessor#postProcessBeforeDestruction())

1️⃣1️⃣ Custom Destruction Methods:

• DisposableBean#destroy()
• @PreDestroy
• destroy-method (if specified in XML or @Bean)

1️⃣2️⃣ Bean is Removed (Garbage Collected).

🔥 This entire process is controlled by Spring’s ApplicationContext!

📌 Hands-On Project: Bean Lifecycle in Action

💡 Let’s create a small Spring Boot app to observe and control the Bean Lifecycle.

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

• Spring Boot Version: Latest stable
• Dependencies: Spring Web
• Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Define a Bean with Lifecycle Hooks

📌 Create a Pirate Bean with Lifecycle Annotations:

package com.example.lifecycle; import jakarta.annotation.PostConstruct; import jakarta.annotation.PreDestroy; import org.springframework.stereotype.Component; @Component public class Pirate { public Pirate() { System.out.println("⚓ Pirate Bean Instantiated!"); } @PostConstruct public void prepareForSailing() { System.out.println("🏴‍☠️ @PostConstruct: Pirate is ready for adventure!"); } @PreDestroy public void retireFromSailing() { System.out.println("☠️ @PreDestroy: Pirate is retiring..."); } } 

💡 What happens here?
✅ Pirate() → Constructor is called (bean instantiation).

✅ @PostConstruct → Called after dependencies are injected but before the bean is used.

✅ @PreDestroy → Called before the bean is destroyed (removed from context).

Step 3: Add BeanPostProcessor to Track Lifecycle Events

📌 Create a PirateLifecycleLogger to observe Spring’s lifecycle hooks:

package com.example.lifecycle; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.stereotype.Component; @Component public class PirateLifecycleLogger implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) { System.out.println("⏳ Before Initialization: " + beanName); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) { System.out.println("✅ After Initialization: " + beanName); return bean; } } 

💡 What happens here?
✅ postProcessBeforeInitialization() runs before @PostConstruct and afterPropertiesSet().

✅ postProcessAfterInitialization() runs after initialization but before usage.

Step 4: Create the Main Application Class

📌 Modify SpringBootApplication to trigger the lifecycle:

package com.example.lifecycle; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class LifecycleApplication { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(LifecycleApplication.class, args); System.out.println("🛳️ Application is Running..."); // Close context to trigger @PreDestroy context.close(); } } 

💡 Why context.close()?

✅ It manually shuts down the Spring application, triggering @PreDestroy!

Step 5: Run the Application

💡 Run the app using:

mvn spring-boot:run 

or

./mvnw spring-boot:run 

👀 Expected Output:

⚓ Pirate Bean Instantiated! ⏳ Before Initialization: pirate 🏴‍☠️ @PostConstruct: Pirate is ready for adventure! ✅ After Initialization: pirate 🛳️ Application is Running... ☠️ @PreDestroy: Pirate is retiring... 

🔥 Boom! You just witnessed the Spring Bean Lifecycle in action!

📌 Summary of Step 3

✅ Spring Beans have a lifecycle controlled by ApplicationContext.

✅ Spring calls lifecycle methods like @PostConstruct and @PreDestroy.

✅ BeanPostProcessor allows custom pre/post-initialization logic.

✅ context.close() manually triggers destruction lifecycle.

📌 Topics Covered in This Section
📜 Spring Bean Lifecycle (✔️ Covered)

• How Beans are created & destroyed (Instantiation → Initialization → Destruction).

• Lifecycle methods:

  • @PostConstruct (Runs after properties are set).
  • @PreDestroy (Runs before bean destruction).

• BeanPostProcessor Hooks:

  • postProcessBeforeInitialization()
  • postProcessAfterInitialization()

• Manually closing the ApplicationContext (context.close()).

🔥 Key Takeaways to Remember:
✅ Spring manages bean lifecycles automatically using ApplicationContext.
✅ @PostConstruct and @PreDestroy are commonly used for lifecycle management.
✅ BeanPostProcessor allows customization before/after initialization.
✅ Manually closing the ApplicationContext triggers @PreDestroy.