Spring中Bean的生命周期

Spring Bean生命周期流程

1. 实例化
2. 依赖注入
3. Aware接口回调
4. BeanPostProcessor的前置处理
5. 初始化方法调用（Initialization）
   • 实现InitializingBean接口的afterPropertiesSet方法
   • 使用@PostConstruct注解的方法
   • 在XML配置文件中指定init-method
6. BeanPostProcessor的后置处理
7. Bean就绪使用
8. 容器关闭时销毁Bean
   • 调用@PreDestroy注解的方法
   • 调用实现了DisposableBean接口的destroy方法
   • 调用在XML配置文件中指定的destroy-method

详细解释

1. 实例化

   • Spring容器使用构造函数或工厂方法创建Bean实例。

2. 依赖注入

   • Spring容器根据配置（XML、注解等）进行依赖注入，设置Bean的属性。

3. Aware接口回调

   • 如果Bean实现了Aware接口，Spring容器会调用相应的回调方法：
     • BeanNameAware：设置Bean的名称。
     • BeanFactoryAware：注入当前的BeanFactory。
     • ApplicationContextAware：注入当前的ApplicationContext。

4. BeanPostProcessor的前置处理

   • Spring容器调用所有注册的BeanPostProcessor的postProcessBeforeInitialization方法，对Bean进行前置处理。

5. 初始化方法调用（Initialization）

   • Spring容器调用Bean的初始化方法，可以通过以下几种方式定义：
     • 实现InitializingBean接口的afterPropertiesSet方法。
     • 使用@PostConstruct注解的方法。
     • 在XML配置文件中指定init-method。

6. BeanPostProcessor的后置处理

   • Spring容器调用所有注册的BeanPostProcessor的postProcessAfterInitialization方法，对Bean进行后置处理。这一步骤通常用于AOP代理。

7. Bean就绪使用

   • 此时，Bean已经完全初始化并且可以被应用程序使用。Spring容器将Bean交给应用程序，应用程序可以通过依赖注入、上下文查找等方式获取并使用Bean。

8. 容器关闭时销毁Bean

   • 当Spring容器关闭时，会销毁所有的单例Bean。销毁过程包括以下步骤：
     • 调用@PreDestroy注解的方法：在Bean定义中使用@PreDestroy注解标注的方法。
     • 调用实现了DisposableBean接口的destroy方法：如果Bean实现了DisposableBean接口，Spring容器会调用其destroy方法。
     • 调用自定义销毁方法：在XML配置文件中指定的destroy-method。

示例代码

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class LifecycleExample {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ExampleBean exampleBean = context.getBean(ExampleBean.class);
        context.close();
    }
}

@Configuration
class AppConfig {

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

class ExampleBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {

    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("BeanNameAware: " + name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactoryAware: " + beanFactory);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("ApplicationContextAware: " + applicationContext);
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean afterPropertiesSet");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("@PostConstruct method");
    }

    public void customInit() {
        System.out.println("Custom init-method");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("@PreDestroy method");
    }

    @Override
    public void destroy() {
        System.out.println("DisposableBean destroy");
    }

    public void customDestroy() {
        System.out.println("Custom destroy-method");
    }
}

在这个示例中：

• @PostConstruct方法、afterPropertiesSet方法和**init-method**在Bean初始化阶段被调用。
• @PreDestroy方法、destroy方法和**destroy-method**在容器关闭时，Bean销毁阶段被调用。

确保Bean在其生命周期的不同阶段，Spring容器会按顺序调用相应的初始化和销毁方法。