Spring Bean 的生命周期

2021 年 3 月 3 日
筆記

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

Spring 生命周期

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

上图中，每个箭头上都有 Spring 提供的拓展点。类加载不是 bean 生命周期的一部分，保留在图上纯粹是因为要提供第一个右向的箭头，而使用阶段也不在讨论范围内，故这两个采用圆角矩形。

拓展点的类型

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

用于单个 bean 感知自身过程的专用拓展点：下方出现的、以 Aware 结尾为名的接口，org.springframework.beans.factory.InitializingBean 接口和 org.springframework.beans.factory.DisposableBean 接口，这些接口都只定义了一个函数。bean 通过实现这些接口、重写其中的函数来实现拓展点。Spring 容器会在适当的时候调用这些函数。
用于所有普通 bean 初始化的通用拓展点：位于 org.springframework.beans.factory.config 包的 BeanPostProcessor 、InstantiationAwareBeanPostProcessor 和 DestructionAwareBeanPostProcessor 接口，这些接口中定义了多个拓展点，使用时需要定义一个专门的类实现接口、重写必要的函数。Spring 容器会将这些实现类优先注册为 bean，待它们初始化完成后再初始化普通的 bean，在每个普通 bean 注册时，Spring 容器都会尝试调用所有已注册的通用拓展点。

classDiagram
BeanPostProcessor <|– InstantiationAwareBeanPostProcessor
BeanPostProcessor <|– DestructionAwareBeanPostProcessor
BeanPostProcessor: +postProcessBeforeInitialization()
BeanPostProcessor: +postProcessAfterInitialization()

InstantiationAwareBeanPostProcessor: +postProcessBeforeInstantiation()
InstantiationAwareBeanPostProcessor: +postProcessAfterInstantiation()

DestructionAwareBeanPostProcessor: +postProcessBeforeDestruction()

1. 实例化

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

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

2. 属性填充

如果对象中有 setter 函数，并通过配置元数据指定了注入的属性，Spring 容器会在这一步为其注入配置的值。完成属性填充后，Spring 通过 Aware（意为感知）接口提供了十个专用拓展点，这些拓展点用于在 bean 自身内部、感知一些外部信息使用。调用顺序如下（下面提到的多个 Aware 接口中，前三个在 org.springframework.beans.factory 包中，4 ~ 9 在 org.springframework.context 包中，最后一个在 org.springframework.web.context 包中）：

BeanNameAware#setBeanName
BeanClassLoaderAware#setBeanClassLoader
BeanFactoryAware#setBeanFactory
EnvironmentAware#setEnvironment
EmbeddedValueResolverAware#setEmbeddedValueResolver
ResourceLoaderAware#setResourceLoader（仅在 ApplicationContext 中有效）
ApplicationEventPublisherAware#setApplicationEventPublisher（仅在 ApplicationContext 中有效）
MessageSourceAware#setMessageSource（仅在 ApplicationContext 中有效）
ApplicationContextAware#setApplicationContext（仅在 ApplicationContext 中有效）
如果是 Web 应用程序，还有 ServletContextAware#setServletContext（仅在 WebApplicationContext 中有效）

Aware 拓展点结束之后，还有一个用于在初始化之前、进行属性校验的 InitializingBean#afterPropertiesSet 专用拓展点。

3. 初始化

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

postProcessBeforeInitialization
自定义的初始化函数
postProcessAfterInitialization

4. 销毁

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

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

实例演示

一个简单的演示，实现了上文提到的 bean 生命周期全部的拓展点，通过日志打印的方式观察执行顺序来直观的感受。

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

SimpleBean 类

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

    private EmptyBean emptyBean;

    static {
        //类加载期间 logger 还没有初始化，使用标准输出
        System.out.printf("[%s] 简单Bean : SimpleBean 类加载 loaded%n", Thread.currentThread().getName());
    }

    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());
    }

    /** 在所有属性设置和 Aware 接口定义的行为都执行完成后，由 BeanFactory 调用，bean 可在此校验自身配置并最终初始化 */
    @Override
    public void afterPropertiesSet() {
        log.info("属性装配全部完成，校验无误，开始初始化");
    }

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

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

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

}

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

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

实例化处理器

@Slf4j(topic = "自定义实例化处理器")
@Component
public class CustomInstantiationProcessor implements InstantiationAwareBeanPostProcessor {

    public CustomInstantiationProcessor() {
        log.info("InstantiationAwareBeanPostProcessor 在其他 bean 创建前就创建完成");
    }

    /** 其他 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;
    }

}

初始化处理器

@Slf4j(topic = "自定义初始化处理器")
@Component
public class CustomInitializationProcessor implements BeanPostProcessor {

    public CustomInitializationProcessor() {
        log.info("BeanPostProcessor 在其他 bean 创建前就创建完成");
    }

    /** 其他 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;
    }
}

销毁处理器

@Slf4j(topic = "自定义销毁处理器")
@Component
public class CustomDestructionProcessor implements DestructionAwareBeanPostProcessor {

    public CustomDestructionProcessor() {
        log.info("DestructionAwareBeanPostProcessor 在其他 bean 创建前就创建完成");
    }

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

}

入口类

@Slf4j
@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.toString());
    }

}

结果解析

JSR 250 定义的 @PostConstruct、 @PreDestory 和 @Component 共同使用定义 bean 时，自定义的初始化函数会在 InitializingBean#afterPropertiesSet，拓展点之前执行，后续查阅源码研究。

Spring Bean 的生命周期

Spring 生命周期

拓展点的类型

1. 实例化

2. 属性填充

3. 初始化

4. 销毁

实例演示

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

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

实例化处理器

初始化处理器

销毁处理器

入口类

结果解析

VirMach 便宜 VPS

QNews

Spring Bean 的生命周期

Spring 生命周期

拓展点的类型

1. 实例化

2. 属性填充

3. 初始化

4. 销毁

实例演示

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

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

实例化处理器

初始化处理器

销毁处理器

入口类

结果解析

分享此文：

Related Posts

【API进阶之路】帮公司省下20万调研费！如何巧用情感分析API实现用户偏好调研

腾讯云Elasticsearch集群规划及性能优化实践

Spring-05 使用注解开发

人类历史上最贵的火星车 毅力号为什么要27亿美元？

VirMach 便宜 VPS

QNews

熱門搜尋

人类历史上最贵的火星车毅力号为什么要27亿美元？