1. Overview of the Spring Bean Lifecycle

The Spring Bean Lifecycle consists of several phases, each representing a different stage in the lifecycle of a bean managed by the Spring container. Understanding this lifecycle helps you customize bean behavior and ensure proper resource management.

1.1 Bean Creation

When a Spring application context is initialized, the container starts by creating instances of beans as defined in the configuration. This phase involves the instantiation of bean objects based on the metadata provided in configuration files or annotations.

Code Example:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

Demo Code:

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyBean myBean = context.getBean(MyBean.class);
        System.out.println("Bean created: " + myBean);
    }
}

Demo Result:

Bean created: MyBean@1a2b3c4d

1.2 Bean Initialization

After a bean is created, Spring initializes it. This phase involves setting the bean properties and performing any initialization tasks specified by the developer.

Code Example:

public class MyBean {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @PostConstruct
    public void init() {
        System.out.println("Bean initialized with name: " + name);
    }
}

Demo Code:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        MyBean myBean = new MyBean();
        myBean.setName("Spring Bean");
        return myBean;
    }
}

Demo Result:

Bean initialized with name: Spring Bean

1.3 Bean Usage

Once initialized, the bean is ready for use. The Spring container provides the bean to the application, which can then interact with it as needed.

Code Example:

public class BeanConsumer {

    private final MyBean myBean;

    @Autowired
    public BeanConsumer(MyBean myBean) {
        this.myBean = myBean;
    }

    public void useBean() {
        System.out.println("Using bean: " + myBean);
    }
}

Demo Code:

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        BeanConsumer consumer = context.getBean(BeanConsumer.class);
        consumer.useBean();
    }
}

Demo Result:

Using bean: MyBean@1a2b3c4d

1.4 Bean Destruction

When the application context is closed or the bean is no longer needed, the Spring container destroys the bean. This phase involves releasing resources and performing any cleanup tasks.

Code Example:

public class MyBean {

    @PreDestroy
    public void cleanup() {
        System.out.println("Bean is being destroyed");
    }
}

Demo Code:

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.close(); // Triggers bean destruction
    }
}

Demo Result:

Bean is being destroyed

2. Customizing Bean Lifecycle

Spring allows you to customize the bean lifecycle to fit your application's needs. This customization can be achieved using various techniques, including lifecycle callbacks and custom initialization and destruction methods.

2.1 Custom Initialization and Destruction Methods

You can define custom methods to be invoked during the initialization and destruction phases of a bean's lifecycle.

Code Example:

public class MyBean {

    public void customInit() {
        System.out.println("Custom initialization");
    }

    public void customDestroy() {
        System.out.println("Custom destruction");
    }
}

Configuration:

@Configuration
public class AppConfig {

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public MyBean myBean() {
        return new MyBean();
    }
}

Demo Code:

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.close(); // Triggers custom destruction
    }
}

Demo Result:

Custom initialization
Custom destruction

2.2 Using @PostConstruct and @PreDestroy Annotations

Spring provides @PostConstruct and @PreDestroy annotations for defining initialization and destruction methods in a more declarative way.

Code Example:

public class MyBean {

    @PostConstruct
    public void init() {
        System.out.println("Initialized using @PostConstruct");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Destroyed using @PreDestroy");
    }
}

Demo Code:

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.close(); // Triggers @PreDestroy method
    }
}

Demo Result:

Initialized using @PostConstruct
Destroyed using @PreDestroy

3. Conclusion

In summary, understanding the Spring Bean Lifecycle is essential for effective resource management and customization of your Spring applications. By leveraging lifecycle callbacks, custom initialization and destruction methods, and annotations, you can ensure that your beans are managed efficiently throughout their lifecycle.

If you have any questions or need further clarification, please feel free to comment below!

Read posts more at : What is the Spring Bean Lifecycle?