概述

Bean 的生命周期（加载、使用、销毁）包括：

  • 获取 Bean 定义（AbstractBeanFactory.getMergedLocalBeanDefinition）
  • 实例化 Bean（AbstractAutowireCapableBeanFactory.createBeanInstance）
  • Bean 属性填充（AbstractAutowireCapableBeanFactory.populateBean）

  • Bean 初始化（AbstractAutowireCapableBeanFactory.initializeBean）

    • Aware 相关接口实现（BeanNameAware，BeanClassLoaderAware，BeanFactoryAware）
    • 若实现了 BeanPostProcessor 接口，执行 ProcessBeforeInitialization 实现
    • 执行标注了 @PostConstruct 注解的方法
    • 若实现了 InitializingBean 接口，执行 afterPropertiesSet 方法
    • 执行自定义的 init-method 方法（invokeInitMethods）
    • 若实现了 BeanPostProcessor 接口，执行 postProcessAfterInitialization 实现
  • 容器正常启动运行
  • 程序运行结束，调用 DisposableBean 以及自定义的 destroyMethod

可以发现 Spring 在 Bean 初始化期间，留了较多的拓展点，我们能够实现拓展点从而对 Bean 进行增强，这也是 Spring 作为 IOC 容器带来的一个优势！

下图主要是 Bean 生命周期的流程展示：
Spring Bean 加载过程生命周期源码分析 - 图1

样例程序

包含 3 个类：启动类 BeanInitApplication、样例类 A、以及对 A 进行前后增强的类 BeanPostProcessorConfig。

  1. @SpringBootApplication
  2. public class BeanInitApplication {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(BeanInitApplication.class, args);
  6.     }
  7.     // 定义 bean 的名称，自定义初始化方法，销魂方法
  8.     @Bean(name = "a", initMethod = "CustomInitMethod",destroyMethod = "CustomDestoryMethod")
  9.     public A getA(){
  10.         A a = new A();
  11.         return a;
  12.     }
  13. }
  15. public class A implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
  17.     @Override
  18.     public void setBeanClassLoader(ClassLoader classLoader) {
  19.         System.out.println("A BeanClassLoaderAware setBeanClassLoader");
  20.     }
  22.     @Override
  23.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  24.         System.out.println("A BeanFactoryAware setBeanFactory");
  25.     }
  27.     @Override
  28.     public void setBeanName(String s) {
  29.         System.out.println("A BeanNameAware setBeanName");
  30.     }
  32.     @Override
  33.     public void destroy() throws Exception {
  34.         System.out.println("A DisposableBean destroy");
  35.     }
  37.     @Override
  38.     public void afterPropertiesSet() throws Exception {
  39.         System.out.println("A InitializingBean afterPropertiesSet");
  40.     }
  42.     @PostConstruct
  43.     public void postContruct(){
  44.         System.out.println("A PostConstruct");
  45.     }
  47.     public void CustomInitMethod(){
  48.         System.out.println("A CustomInitMethod");
  49.     }
  52.     public void CustomDestoryMethod(){
  53.         System.out.println("A CustomDestoryMethod");
  54.     }
  56.     @PreDestroy
  57.     public void PreDestroyMethod(){
  58.         System.out.println("A PreDestroy");
  59.     }
  61. }
  63. @Component
  64. public class BeanPostProcessorConfig implements BeanPostProcessor {
  66.     @Override
  67.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  68.         if (bean.getClass() == A.class){
  69.             System.out.println("A BeanPostProcessor postProcessBeforeInitialization " + beanName);
  70.         }
  71.         return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
  72.     }
  74.     @Override
  75.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  76.         if (bean.getClass() ==  A.class){
  77.             System.out.println("A BeanPostProcessor postProcessAfterInitialization " + beanName);
  78.         }
  79.         return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
  80.     }
  81. }

执行结果，与上面图中的一样：

  1. A BeanNameAware setBeanName
  2. A BeanClassLoaderAware setBeanClassLoader
  3. A BeanFactoryAware setBeanFactory
  4. A BeanPostProcessor postProcessBeforeInitialization a
  5. A PostConstruct
  6. A InitializingBean afterPropertiesSet
  7. A CustomInitMethod
  8. A BeanPostProcessor postProcessAfterInitialization a
  9. 2021-07-15 17:28:22.981  INFO 111300 --- [           main] c.example.beaninit.BeanInitApplication   : Started BeanInitApplication in 0.984 seconds (JVM running for 1.998)
  10. A PreDestroy
  11. A DisposableBean destroy
  12. A CustomDestoryMethod

源码分析(省略部分代码)

再次说明，Bean 生命周期主要流程：

  1. 获取 Bean 定义
  2. 实例化
  3. 属性填充
  4. 初始化
  5. 结束

其中实例化、属性填充、初始化操作都在 AbstractAutowireCapableBeanFactory 类里面定义，下面具体分析。

1. AbstractBeanFactory

从 AbstractBeanFactory getBean 获取 Bean 开始分析：

  1. public abstract class AbstractBeanFactory {
  2.     public Object getBean(String name) throws BeansException {
  3.         return this.doGetBean(name, (Class)null, (Object[])null, false);
  4.     }
  6.     protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
  7.         // 从缓存中获取 Bean，调用 DefaultSingletonBeanRegistry.getSingleton(String name) 方法
  8.         Object sharedInstance = this.getSingleton(beanName); // 从缓存中获取 Bean
  9.         // 获取 Bean 定义
  10.         RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
  11.         // 作用域是单例情况
  12.         if (mbd.isSingleton()) {
  13.             // 调用 DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法返回 Bean，这里有个匿名函数，讲在使用的时候再去调用具体的逻辑
  14.             sharedInstance = this.getSingleton(beanName, () -> {
  15.                 try {
  16.                     return this.createBean(beanName, mbd, args);
  17.                 } catch (BeansException var5) {
  18.                     this.destroySingleton(beanName);
  19.                     throw var5;
  20.                 }
  21.             });
  22.             // 返回 Bean 实例
  23.             beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  24.         }
  25. }

流程：

  1. 从缓存中获取 Bean；第一次请求返回 null
  2. 获取 Bean 的定义，主要是 getMergedLocalBeanDefinition 方法
  3. 调用 DefaultSingletonBeanRegistry 的 getSingleton 重载方法去获取 Bean 并返回（特别注意匿名函数的使用，执行到具体逻辑的时候才会去调用对应的方法）

可以发现最终是调用 DefaultSingletonBeanRegistry.getSingleton 获取 Bean。

2. DefaultSingletonBeanRegistry.getSingleton

  1. public class DefaultSingletonBeanRegistry{
  2.     // 1
  3.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256); // 一级缓存，存放初始化完成的对象
  4.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16); // 三级缓存，存放为初始化对象的 beanFactory
  5.     private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16); // 二级缓存，用于从三级缓存中获取增强的对象
  6.     private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));  // 标记对象是否在创建中，创建中的对象会添加到里面
  8.     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  9.         synchronized(this.singletonObjects) {
  10.             // 2
  11.             Object singletonObject = this.singletonObjects.get(beanName); // 从一级缓存中再次获取
  12.             if (singletonObject == null) {
  13.                 // 3
  14.                 this.beforeSingletonCreation(beanName);  // 标志为创建中，beanName 加入到 singletonsCurrentlyInCreation 
  15.                 try {
  16.                     // 4
  17.                     singletonObject = singletonFactory.getObject();  // 匿名函数起作用，讲调用 AbstractAutowireCapableBeanFactory.createBean 方法并返回 ObjectFactory
  18.                     newSingleton = true;
  19.                 } catch (IllegalStateException var16) {
  20.                     singletonObject = this.singletonObjects.get(beanName);
  21.                     if (singletonObject == null) {
  22.                         throw var16;
  23.                     }
  24.                 } finally {
  25.                     // 5
  26.                      this.afterSingletonCreation(beanName);  // 创建完成，从 singletonsCurrentlyInCreation 标记中移除
  27.                 }
  28.                 // 6
  29.                 if (newSingleton) {
  30.                     this.addSingleton(beanName, singletonObject); // 将 Bean 加入到一级缓存，删除二级、三级缓存
  31.                 }
  32.             }
  33.             return singletonObject;
  34.         }
  35.     }
  36. }

流程：

  1. 成员属性：定义三级缓存和 Bean 正在创建中标识（这里只用记一下即可，后面系列文章会分析它们的作用）
  2. 加锁，再次从一级缓存中获取，显然第一次没有获取到
  3. 标记正在创建中， beforeSingletonCreation
  4. 执行 AbstractAutowireCapableBeanFactory.createBean 方法，返回初始化完成的 Bean
  5. 移除正在创建标记
  6. 将对象放到一级缓存，并删除二级、三级缓存，返回 Bean

可以发现最终是调用 AbstractAutowireCapableBeanFactory.createBean 获取 Bean

3. AbstractAutowireCapableBeanFactory.createBean

  1. public abstract class AbstractAutowireCapableBeanFactory{
  2.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
  3.         try {
  4.             // 1. 覆盖重写方法
  5.             mbdToUse.prepareMethodOverrides();
  6.         } catch (BeanDefinitionValidationException var9) {
  7.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
  8.         }
  9.         Object beanInstance;
  10.         try {
  11.             // 2
  12.             beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
  13.             if (beanInstance != null) {
  14.                 return beanInstance;
  15.             }
  16.         } catch (Throwable var10) {
  17.         }
  19.         try {
  20.             // 3 具体创建 Bean
  21.             beanInstance = this.doCreateBean(beanName, mbdToUse, args);
  22.             return beanInstance;
  23.         } 
  24.     }
  25. }

流程：

  1. 重写 Bean 中的方法
  2. 执行 InstantiationAwareBeanPostProcessor 拓展点的方法
  3. 执行 doCreateBean

doCreateBean 实现：

  1. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
  2.     if (instanceWrapper == null) {
  3.         // 实例化 Bean
  4.         instanceWrapper = this.createBeanInstance(beanName, mbd, args);
  5.     }
  6.     // 是否单例 && 运行循环引用 && 创建中
  7.     boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
  8.     if (earlySingletonExposure) {
  9.            // 实例化的 Bean 加入到 三级缓存
  10.         this.addSingletonFactory(beanName, () -> {
  11.             return this.getEarlyBeanReference(beanName, mbd, bean);
  12.         });
  13.     }
  14.     try {
  15.         // 属性填充
  16.         this.populateBean(beanName, mbd, instanceWrapper);
  17.         // 初始化
  18.         exposedObject = this.initializeBean(beanName, exposedObject, mbd);
  19.     }
  20.     if (earlySingletonExposure) {
  21.         // 在从缓存中获取 Bean，涉及到将 Bean 从三级缓存移到二级缓存的过程，后面文章再分析
  22.         Object earlySingletonReference = this.getSingleton(beanName, false);
  23.         if (earlySingletonReference != null) {
  24.             if (exposedObject == bean) {
  25.                 exposedObject = earlySingletonReference;
  26.             } 
  27.         }
  28.     }    
  29. }
  1. 实例化 Bean，createBeanInstance
  2. 实例化的 Bean 放到 三级缓存
  3. 属性填充
  4. 初始化

初始化实现：

  1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged(() -> {
  4.             // 执行 aware 方法
  5.             this.invokeAwareMethods(beanName, bean);
  6.             return null;
  7.         }, this.getAccessControlContext());
  8.     } else {
  9.         this.invokeAwareMethods(beanName, bean);
  10.     }
  12.     Object wrappedBean = bean;
  13.     if (mbd == null || !mbd.isSynthetic()) {
  14.         // 执行 BeanPostProcessor 的前置实现
  15.         wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
  16.     }
  18.     try {
  19.         // 实现 afterPropertiesSet、自定义的 init 方法
  20.         this.invokeInitMethods(beanName, wrappedBean, mbd);
  21.     } catch (Throwable var6) {
  22.         throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
  23.     }
  25.     if (mbd == null || !mbd.isSynthetic()) {
  26.         // 执行 BeanPostProcessor 的后置实现
  27.         wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  28.     }
  30.     return wrappedBean;
  31. }

总结

Bean 的生命周期，主要包含获取 Bean 定义、实例化、属性填充、初始化。

其中 AbstractAutowireCapableBeanFactory 定义了实例化、属性填充、初始化的具体实现，值得好好复习。

Bean 实例化首先加入到三级缓存，然后加入到二级缓存，初始化完成之后，将 Bean 放到了一级缓存中，之所以这样实现，是为了解决循环依赖的问题，后面文章进行详细分析。

初始化过程中，Spring 预留了较多拓展点，依次调用 Aware 接口、BeanPostProcessor、init-method 方法的具体实现，方便在生成 Bean 的过程中，做一些初始化赋值的操作。