Spring Bean 的生命周期总结

除了使用阶段外，Spring 将 bean 的生命周期定义为实例化、属性填充、初始化和销毁四个阶段，并为每个阶段提供了多个拓展点用于自定义 bean 的创建过程。这篇文章介绍了 bean 的生命周期和其各个拓展点，通过图示生动的展示、并结合一个实例来演示全过程。

Spring 生命周期

flowchart LR ClassLoad[类加载] --> Instantiation[实例化] --> Populate[属性填充] --> Initialization[初始化] --> Using[使用] --> Destruction[销毁]

拓展点的类型

Spring 提供的拓展点可以分为：

用于单个 bean 的专用拓展点：编写 bean 类时通过实现这些接口、重写其中的函数来实现拓展点。Spring 容器会在适当的时候调用这些接口中定义的函数。
- 诸多 Aware 接口的子接口
- InitializingBean 接口和 DisposableBean 接口
用于所有普通 bean 初始化的通用拓展点：这些接口中定义了多个拓展点，使用时需要定义一个专门的类实现接口、重写必要的函数。Spring 容器初始化时会将这些类优先注册为 bean，待它们初始化完成之后再初始化普通的 bean。在其他每个普通 bean 注册时，Spring 容器都会尝试调用所有已注册的通用拓展点。
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
- DestructionAwareBeanPostProcessor

下方出现的图示中，菱形表示通用拓展点，而圆形表示专用拓展点，矩形就是 bean 的生命周期中的某一步骤。

实例化

创建 bean 对象实例的过程，包括使用工厂模式创建和调用构造函数。Spring 通过 InstantiationAwareBeanPostProcessor 接口在实例化前和后各提供了两个通用拓展点，加上对象实例化的过程，执行顺序如下：

postProcessBeforeInstantiation：在普通 bean 对象实例化开始之前调用
对象实例化
postProcessAfterInstantiation：在普通 bean 对象实例化完成之后调用

flowchart LR ClassLoad[类加载] --> postProcessBeforeInstantiation{实例化前拓展点} postProcessBeforeInstantiation --> Instantiation[对象实例化] Instantiation --> postProcessAfterInstantiation{实例化后拓展点} postProcessAfterInstantiation --> Populate[属性填充]

属性填充

如果对象中有 setter 函数，并通过配置元数据指定了注入的属性，Spring 容器会在这一步为其注入配置的值。完成属性填充后，Spring 通过 Aware（意为感知）接口提供了十个专用拓展点，这些拓展点用于在 bean 自身内部、感知信息和属性校验使用，执行顺序如下（注意下方列表是第零条是 Bean 属性填充，所以此处一共有十个拓展点）：

Bean 属性填充
BeanNameAware#setBeanName
BeanClassLoaderAware#setBeanClassLoader
BeanFactoryAware#setBeanFactory
EnvironmentAware#setEnvironment
EmbeddedValueResolverAware#setEmbeddedValueResolver
ResourceLoaderAware#setResourceLoader（仅在 ApplicationContext 中有效）
ApplicationEventPublisherAware#setApplicationEventPublisher（仅在 ApplicationContext 中有效）
MessageSourceAware#setMessageSource（仅在 ApplicationContext 中有效）
ApplicationContextAware#setApplicationContext（仅在 ApplicationContext 中有效）
ServletContextAware#setServletContext（仅在 WebApplicationContext 中有效）

flowchart LR Populate[属性填充] --> setBeanXXX((Bean 信息拓展点)) setBeanXXX --> setInformation((外部信息拓展点)) setInformation --> setContext((Context 拓展点)) --> Initialization[初始化]

上方图示中，笔者对拓展点进行了简单的分类以简化图示，第一至第三个拓展点用于感知与 Bean 自身相关的信息、称之为 Bean 信息拓展点，第四至第八个拓展点统称为外部信息拓展点，随后第九第十两个拓展点与 ApplicationContext 有关。

初始化

初始化是指通过 bean 在将要工作前进行的最后准备工作，通常是 @Bean 的initMethod 属性定义的函数执行的过程。Spring 通过 BeanPostProcessor 接口在初始化之前和之后提供了两个通用拓展点，加上 InitializingBean#afterPropertiesSet 和初始化函数执行顺序为：

postProcessBeforeInitialization
InitializingBean#afterPropertiesSet
自定义的初始化函数
postProcessAfterInitialization

flowchart LR Populate[属性填充] --> postProcessBeforeInitialization{初始化前拓展点} --> afterPropertiesSet((InitializingBean#afterPropertiesSet)) afterPropertiesSet --> Initialization[初始化] Initialization --> postProcessAfterInitialization{初始化后拓展点} postProcessAfterInitialization --> Using[使用中]

销毁

销毁是指 bean 释放其占用的一些外部资源的过程，通常是 @Bean 注解的 destroyMethod 属性定义的销毁函数执行的过程。Spring 通过 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction 接口提供了通用拓展点，再加上 DisposableBean#destroy 提供的专用拓展点，三者执行顺序为：

DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
DisposableBean#destroy
自定义的销毁函数。

flowchart LR postProcessBeforeDestruction{销毁前拓展点} --> destroy((DisposableBean#destroy)) --> customDestroy[自定义的销毁函数]

总结

Spring 提供的拓展点令人眼花缭乱，但仔细思考就会发现这些内容设计的很好。以下是笔者的一些总结：

通用拓展点可以对任意其他的类进行处理，且各个通用拓展点实际都来自于 BeanPostProcessor，本文中提到的三个拓展点类图如下（也就是说 InstantiationAwareBeanPostProcessor 接口的实现类如果实现了 postProcessBeforeInitialization 函数，其实也具备初始化前置拓展点的能力）。此外，实例化 Instantiation 和初始化 Initialization 这两个单词的拼写需要区分以下。
classDiagram BeanPostProcessor <|-- InstantiationAwareBeanPostProcessor BeanPostProcessor <|-- DestructionAwareBeanPostProcessor BeanPostProcessor: +postProcessBeforeInitialization() BeanPostProcessor: +postProcessAfterInitialization() InstantiationAwareBeanPostProcessor: +postProcessBeforeInstantiation() InstantiationAwareBeanPostProcessor: +postProcessAfterInstantiation() DestructionAwareBeanPostProcessor: +postProcessBeforeDestruction()
属性填充阶段的多个拓展点可以根据其用途进行分类便于记忆
自定义的初始化方法和自定义的销毁方法可以认为是一对，InitializingBean 接口和 DisposableBean 接口可以认为是一对，它们之间不应该交叉出现（例如通过自定义的初始化方法定义了初始化过程，却通过 DispoableBean#destory 执行销毁过程）。

实例演示

一个简单的演示，实现了上文提到的 bean 生命周期全部的拓展点，通过日志打印的方式观察执行顺序来直观的感受。是一个普通的 SpringBoot Hello World 程序，将 Logback 换成了 log4j2 以更方便的定义日志内容，降低解析结果的难度。

在一个 bean 中实现全部的专用拓展点

SimpleBean 类


/**
 * 一个简单的 bean 实例，实现了 Spring 提供的 bean 生命周期全拓展点，内部函数实现顺序即为 bean 生命周期中各个函数的调用顺序
 */
@Log4j2(topic = "SimpleBean")
public class SimpleBean
        implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
        EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware,
        ApplicationEventPublisherAware, MessageSourceAware, ApplicationContextAware, InitializingBean, DisposableBean {

    private EmptyBean emptyBean;

    public SimpleBean() {
        log.info("构造函数执行，创建实例");
    }

    @Autowired
    public void setEmptyBean(EmptyBean emptyBean) {
        this.emptyBean = emptyBean;
        log.info("setter 函数执行，装配了 {}", this.emptyBean);
    }

    /** 用于通知 bean 感知自身名称 */
    @Override
    public void setBeanName(String name) {
        log.info("bean 名称为 {}", name);
    }

    /** 用于通知 bean 感知加载自身的类加载器 */
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        log.info("类加载器是 {}", classLoader);
    }

    /** 用于通知 bean 感知创建自身的 bean 工厂 */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        //BeanFactory 可能会重写 toString()，造成日志输出过多不便于查阅
        log.info("由 {}@{} 创建", beanFactory.getClass(), beanFactory.hashCode());
    }

    /** 设置该 bean 的运行环境信息 */
    @Override
    public void setEnvironment(Environment environment) {
        //environment.toString() 会将所有环境信息输出，造成日志输出过多不便于查阅
        log.info("运行的 JVM 型号是 {}", environment.getProperty("java.vm.name"));
    }

    /** 设置嵌入式配置解析器，可用于解析嵌入在应用程序包内的配置文件中的文本值 */
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        //在 application.properties 中定义了 editor.name 信息
        log.info("作者是 {}", resolver.resolveStringValue("${editor.name}"));
    }

    /** 设置用于资源解析的解析器，可用于解析任意格式的资源 */
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        log.info("资源解析器对象：{}", resourceLoader);
    }

    /** 设置事件发布器，与 Spring 提供的事件发布订阅机制有关 */
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        log.info("事件发布器对象：{}", applicationEventPublisher);
    }

    /** 设置消息原，可用于实现国际化 */
    @Override
    public void setMessageSource(MessageSource messageSource) {
        log.info("消息源对象：{}", messageSource);
    }

    /** 为当前 bean 传入 ApplicationContext 引用，可使用该容器引用获取其他 bean 的引用 */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("应用程序上下文对象：{}", applicationContext.getDisplayName());
    }

    /** 在初始化前拓展点执行完成后执行 */
    @Override
    public void afterPropertiesSet() {
        log.info("属性装配全部完成，校验无误，开始初始化");
    }

    /** 自定义的初始化方法 */
    public void initMethod() {
        log.info("自定义的初始化方法");
    }

    /** 容器销毁时调用 */
    @Override
    public void destroy() {
        log.info("容器即将关闭，销毁其中的 bean");
    }

    /** 自定义的销毁方法 */
    public void destroyMethod() {
        log.info("自定义的销毁方法");
    }

}

EmptyBean 类

/** 一个空的 bean，用于在 SimpleBean 中进行 setter 注入 */
@Component
public class EmptyBean {
}

自定义三种类型的通用拓展点

实例化处理器

@Log4j2(topic = "CustomInstantiationProcessor")
@Component
public class CustomInstantiationProcessor implements InstantiationAwareBeanPostProcessor {

    public CustomInstantiationProcessor() {
        log.info("InstantiationAwareBeanPostProcessor 优先初始化");
    }

    /** 其他 bean 实例化之前调用 */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanClass.equals(SimpleBean.class)) {
            log.info("{} 即将实例化", beanName);
        }
        return null;
    }

    /** 其他 bean 实例化之后调用 */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (bean instanceof SimpleBean) {
            log.info("{} 实例化完成", beanName);
        }
        return true;
    }

}

初始化处理器

@Log4j2(topic = "CustomInitializationProcessor")
@Component
public class CustomInitializationProcessor implements BeanPostProcessor {

    public CustomInitializationProcessor() {
        log.info("BeanPostProcessor 优先初始化");
    }

    /** 其他 bean 初始化之前调用 */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof SimpleBean) {
            log.info("{} 即将初始化", beanName);
        }
        return bean;
    }

    /** 其他 bean 初始化完成之后调用 */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof SimpleBean) {
            log.info("{} 初始化完成", beanName);
        }
        return bean;
    }
}

销毁处理器

@Log4j2(topic = "CustomDestructionProcessor")
@Component
public class CustomDestructionProcessor implements DestructionAwareBeanPostProcessor {

    public CustomDestructionProcessor() {
        log.info("DestructionAwareBeanPostProcessor 优先初始化");
    }

    /** 其他 bean 销毁之前调用 */
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if (bean instanceof SimpleBean) {
            log.info("{} 即将销毁", beanName);
        }
    }

}

入口类

@Log4j2(topic = "DemoApplication")
@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    private SimpleBean bean;

    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public SimpleBean simpleBean() {
        return new SimpleBean();
    }

    @Autowired
    public void setBean(SimpleBean bean) {
        this.bean = bean;
    }

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) {
        log.info("{} 使用", bean);
    }

}

结果解析

日志格式定义：logging.pattern.console=[%t] %c %M : %m %n，下方是逐阶段的分析。

SpringBoot 启动，初始化容器

优先加载 BeanPostProcessor 的实现类

[main] CustomInstantiationProcessor  : InstantiationAwareBeanPostProcessor 优先初始化 
[main] CustomInitializationProcessor  : BeanPostProcessor 优先初始化 
[main] CustomDestructionProcessor  : DestructionAwareBeanPostProcessor 优先初始化

实例化阶段的日志

[main] CustomInstantiationProcessor postProcessBeforeInstantiation : simpleBean 即将实例化 
[main] SimpleBean  : 构造函数执行，创建实例 
[main] CustomInstantiationProcessor postProcessAfterInstantiation : simpleBean 实例化完成

属性填充阶段的日志

[main] SimpleBean setEmptyBean : setter 函数执行，装配了 cncsl.learn.blc.EmptyBean@2f67a4d3 
[main] SimpleBean setBeanName : bean 名称为 simpleBean 
[main] SimpleBean setBeanClassLoader : 类加载器是 org.springframework.boot.loader.LaunchedURLClassLoader@51565ec2 
[main] SimpleBean setBeanFactory : 由 class org.springframework.beans.factory.support.DefaultListableBeanFactory@797814020 创建 
[main] SimpleBean setEnvironment : 运行的 JVM 型号是 Java HotSpot(TM) 64-Bit Server VM 
[main] SimpleBean setEmbeddedValueResolver : 作者是 cncsl 
[main] SimpleBean setResourceLoader : 资源解析器对象：org.springframework.context.annotation.AnnotationConfigApplicationContext@ba2f4ec
[main] SimpleBean setApplicationEventPublisher : 事件发布器对象：org.springframework.context.annotation.AnnotationConfigApplicationContext@ba2f4ec
[main] SimpleBean setMessageSource : 消息源对象：org.springframework.context.annotation.AnnotationConfigApplicationContext@ba2f4ec
[main] SimpleBean setApplicationContext : 应用程序上下文对象：org.springframework.context.annotation.AnnotationConfigApplicationContext@ba2f4ec

初始化阶段

[main] CustomInitializationProcessor postProcessBeforeInitialization : simpleBean 即将初始化 
[main] SimpleBean initMethod : 自定义的初始化方法 
[main] SimpleBean afterPropertiesSet : 属性装配全部完成，校验无误，开始初始化 
[main] CustomInitializationProcessor postProcessAfterInitialization : simpleBean 初始化完成 
[main] cncsl.learn.blc.DemoApplication logStarted : Started DemoApplication in 0.817 seconds (JVM running for 1.219) 
[main] DemoApplication run : cncsl.learn.blc.SimpleBean@295cf707 使用

使用阶段

[main] cncsl.learn.blc.DemoApplication logStarted : Started DemoApplication in 1.135 seconds (JVM running for 2.028) 
[main] DemoApplication run : cncsl.learn.blc.SimpleBean@4a335fa8 使用

销毁阶段

[SpringContextShutdownHook] CustomDestructionProcessor postProcessBeforeDestruction : simpleBean 即将销毁 
[SpringContextShutdownHook] SimpleBean destroyMethod : 自定义的销毁方法 
[SpringContextShutdownHook] SimpleBean destroy : 容器即将关闭，销毁其中的 bean

SpringFramework