DEV Community

Anh Trần Tuấn
Anh Trần Tuấn

Posted on • Originally published at tuanh.net on

What is the Spring Bean Lifecycle?

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.

Image

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();
    }
}
Enter fullscreen mode Exit fullscreen mode

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);
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Bean created: MyBean@1a2b3c4d
Enter fullscreen mode Exit fullscreen mode

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);
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Bean initialized with name: Spring Bean
Enter fullscreen mode Exit fullscreen mode

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);
    }
}
Enter fullscreen mode Exit fullscreen mode

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();
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Using bean: MyBean@1a2b3c4d
Enter fullscreen mode Exit fullscreen mode

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");
    }
}
Enter fullscreen mode Exit fullscreen mode

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
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Bean is being destroyed
Enter fullscreen mode Exit fullscreen mode

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");
    }
}
Enter fullscreen mode Exit fullscreen mode

Configuration:

@Configuration
public class AppConfig {

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

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
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Custom initialization
Custom destruction
Enter fullscreen mode Exit fullscreen mode

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");
    }
}
Enter fullscreen mode Exit fullscreen mode

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
    }
}
Enter fullscreen mode Exit fullscreen mode

Demo Result:

Initialized using @PostConstruct
Destroyed using @PreDestroy
Enter fullscreen mode Exit fullscreen mode

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?

Top comments (0)