一文详解Spring Bean生命周期

╰+攻爆jí腚メ 2024-03-22 09:27 68阅读 0赞

### 1.概述 ###

之前我们谈到了`Spring` Bean的生命周期和其对Spring框架原理理解的重要性，所以接下来我们就来分析一下Bean生命周期的整体流程。首先Bean就是一些Java对象，只不过这些Bean不是我们主动`new`出来的，而是交个Spring IOC容器创建并管理的，因此Bean的生命周期受Spring IOC容器控制，Bean生命周期大致分为以下几个阶段：

![format_png][]

*  **Bean的实例化(Instantiation)** ：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化
 *  **Bean的属性赋值(Populate)** ：Bean实例化之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充，Bean的属性赋值就是指 Spring 容器根据BeanDefinition中属性配置的属性值注入到 Bean 对象中的过程。
 *  **Bean的初始化(Initialization)** ：对Bean实例的属性进行填充完之后还需要执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，并且Spring高频面试题Bean的循环引用问题也是在这个阶段体现的；

*  **Bean的使用阶段**：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期，接下来Bean就可以被随心所欲地使用了。

*  **Bean的销毁(Destruction)** ：Bean 的销毁是指 Spring 容器在关闭时，执行一些清理操作的过程。在 Spring 容器中， Bean 的销毁方式有两种：销毁方法destroy-method和 **DisposableBean** 接口。

### 2.Bean生命周期详解和使用案例 ###

之前说`BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor,BeanPostProcessor`这三个后置处理器的调用时机都在Spring Bean生命周期中是不严谨的，按照上面我们对Bean生命周期的阶段划分，只有`BeanPostProcessor`作用于Bean的生命周期中，而`BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor`是针对BeanDefinition的，所以不属于Bean的生命周期中。

`BeanPostProcessor`在Bean生命周期的体现如下图所示：

![format_png 1][]

Bean的生命周期和人的一生一样都会经历从出生到死亡，中间是一个漫长且复杂的过程，接下来我们就来整体分析一下Bean生命周期的核心流程和相关接口回调方法的调用时机，同时这里想强调一下Bean的生命周期也是面试的高频考点，对核心流程务必要掌握清楚，这里用一张流程图进行详述展示，是**重点、重点、重点**。

![format_png 2][]

根据上面的Bean生命周期核心流程做如下代码演示示例：

**Bean定义：**

@Data
    @AllArgsConstructor
    public class Boo implements InitializingBean, DisposableBean, BeanNameAware {
        private Long id;
        private String name;
    
        public Boo() {
            System.out.println("boo实例化构造方法执行了...");
        }
    
        @PostConstruct
        public void initMethod() {
            System.out.println("boo执行初始化init()方法了...");
        }
    
        @PreDestroy
        public void destroyMethod() {
            System.out.println("boo执行初始化destroy()方法了...");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("boo执行InitializingBean的afterPropertiesSet()方法了...");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("boo执行DisposableBean的destroy()方法了...");
        }
    
        @Override
        public void setBeanName(String name) {
            System.out.println("boo执行BeanNameAware的setBeanName()方法了...");
        }
    }
    复制代码

**实现InstantiationAwareBeanPostProcessor:**

@Component
    public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
        @Override
        public Object postProcessBeforeInstantiation(Class<?> BeanClass, String BeanName) throws BeansException {
            System.out.println("InstantiationAwareBeanPostProcessor的before()执行了...." + BeanName);
            return null;
        }
    
        @Override
        public boolean postProcessAfterInstantiation(Object Bean, String BeanName) throws BeansException {
            System.out.println("InstantiationAwareBeanPostProcessor的after()执行了...." + BeanName);
            return false;
        }
    }
    复制代码

**实现BeanPostProcessor：**

@Component
    public class MyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object Bean, String BeanName) throws BeansException {
            System.out.println("BeanPostProcessor的before()执行了...." + BeanName);
            return Bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object Bean, String BeanName) throws BeansException {
            System.out.println("BeanPostProcessor的after()执行了...."+ BeanName);
            return Bean;
        }
    }
    复制代码

执行下面的配置类测试方法：

@ComponentScan(basePackages = {"com.shepherd.common.config"})
    @Configuration
    public class MyConfig {
    
        @Bean
        public Boo boo() {
            return new Boo();
        }
    
        public static void main(String[] args) {
    
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
            String[] BeanDefinitionNames = applicationContext.getBeanDefinitionNames();
            // 遍历Spring容器中的BeanName
            for (String BeanDefinitionName : BeanDefinitionNames) {
                System.out.println(BeanDefinitionName);
            }
            // 这里调用的applicationContext的close()触发Bean的销毁回调方法
            applicationContext.close();
        }
    }
    复制代码

名为boo的Bean相关运行结果如下：

InstantiationAwareBeanPostProcessor的before()执行了....boo
    boo实例化构造方法执行了...
    InstantiationAwareBeanPostProcessor的after()执行了....boo
    boo执行BeanNameAware的setBeanName()方法了...
    BeanPostProcessor的before()执行了....boo
    boo执行初始化init()方法了...
    boo执行InitializingBean的afterPropertiesSet()方法了...
    BeanPostProcessor的after()执行了....boo
    ......
    boo执行初始化destroy()方法了...
    boo执行DisposableBean的destroy()方法了...
    复制代码

根据控制台打印结果可以boo的相关方法执行顺序严格遵从上面流程图，同时当我们执行容器`applicationContext`的关闭方法`close()`会触发调用bean的销毁回调方法。

### 3.浅析Bean生命周期源码实现 ###

`DefaultListableBeanFactory`是Spring IOC的Bean工厂的一个默认实现，IOC大部分核心逻辑实现都在这里，可关注。Bean生命周期就是创建Bean的过程，这里我们就不在拐弯抹角兜圈子，直接来到`DefaultListableBeanFactory`继承的`AbstractAutowireCapableBeanFactory`的`#doCreateBean()`方法，之前说过在Spring框架中以do开头的方法都是核心逻辑实现所在

protected Object doCreateBean(String BeanName, RootBeanDefinition mbd, @Nullable Object[] args)
          throws BeanCreationException {
    
        // Instantiate the Bean.
        // BeanWrapper 是对 Bean 的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装 Bean 的属性描述器
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
          // <1> 单例模型，则从未完成的 FactoryBean 缓存中删除
          instanceWrapper = this.factoryBeanInstanceCache.remove(BeanName);
        }
        if (instanceWrapper == null) {
          // <2> 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
          instanceWrapper = createBeanInstance(BeanName, mbd, args);
        }
        // 包装的实例对象
        Object Bean = instanceWrapper.getWrappedInstance();
        // 包装的实例class类型
        Class<?> BeanType = instanceWrapper.getWrappedClass();
        if (BeanType != NullBean.class) {
          mbd.resolvedTargetType = BeanType;
        }
    
        // Allow post-processors to modify the merged Bean definition.
        // <3> 判断是否有后置处理
        // 如果有后置处理，则允许后置处理修改 BeanDefinition
        synchronized (mbd.postProcessingLock) {
          if (!mbd.postProcessed) {
            try {
              applyMergedBeanDefinitionPostProcessors(mbd, BeanType, BeanName);
            }
            catch (Throwable ex) {
              throw new BeanCreationException(mbd.getResourceDescription(), BeanName,
                  "Post-processing of merged Bean definition failed", ex);
            }
            mbd.postProcessed = true;
          }
        }
    
        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        // <4> 解决单例模式的循环依赖
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(BeanName));
        if (earlySingletonExposure) {
          if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching Bean '" + BeanName +
                "' to allow for resolving potential circular references");
          }
          // 提前将创建的 Bean 实例加入到 singletonFactories 中
          // 这里是为了后期避免循环依赖
          addSingletonFactory(BeanName, () -> getEarlyBeanReference(BeanName, mbd, Bean));
        }
    
        // Initialize the Bean instance.
        // 开始初始化 Bean 实例对象
        Object exposedObject = Bean;
        try {
          // <5> 对 Bean 进行填充，将各个属性值注入，其中，可能存在依赖于其他 Bean 的属性
          // 则会递归初始依赖 Bean
          populateBean(BeanName, mbd, instanceWrapper);
          // <6> 调用初始化方法
          exposedObject = initializeBean(BeanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
          if (ex instanceof BeanCreationException && BeanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
          }
          else {
            throw new BeanCreationException(
                mbd.getResourceDescription(), BeanName, "Initialization of Bean failed", ex);
          }
        }
    
        // <7> 循环依赖处理
        if (earlySingletonExposure) {
          // 获取 earlySingletonReference
          Object earlySingletonReference = getSingleton(BeanName, false);
          // 只有在存在循环依赖的情况下，earlySingletonReference 才不会为空
          if (earlySingletonReference != null) {
            // 如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强
            if (exposedObject == Bean) {
              exposedObject = earlySingletonReference;
            }
            // 处理依赖
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(BeanName)) {
              String[] dependentBeans = getDependentBeans(BeanName);
              Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
              for (String dependentBean : dependentBeans) {
                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                  actualDependentBeans.add(dependentBean);
                }
              }
              if (!actualDependentBeans.isEmpty()) {
                throw new BeanCurrentlyInCreationException(BeanName,
                    "Bean with name '" + BeanName + "' has been injected into other Beans [" +
                    StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                    "] in its raw version as part of a circular reference, but has eventually been " +
                    "wrapped. This means that said other Beans do not use the final version of the " +
                    "Bean. This is often the result of over-eager type matching - consider using " +
                    "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
              }
            }
          }
        }
    
        // Register Bean as disposable.
        try {
          // <8> 注册 Bean的销毁逻辑
          registerDisposableBeanIfNecessary(BeanName, Bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
          throw new BeanCreationException(
              mbd.getResourceDescription(), BeanName, "Invalid destruction signature", ex);
        }
    
        return exposedObject;
      }
    复制代码

由上面代码可知，Bean的创建过程核心步骤如下：

*  **createBeanInstance(BeanName, mbd, args) 进行Bean的实例化**
 *  **populateBean(BeanName, mbd, instanceWrapper)进行Bean的属性填充赋值**
 *  **initializeBean(BeanName, exposedObject, mbd)处理Bean初始化之后的各种回调事件**
 *  **registerDisposableBeanIfNecessary(BeanName, Bean, mbd)注册Bean的销毁接口**
 *  **解决创建Bean过程中的循环依赖，Spring使用三级缓存解决循环依赖，这也是一个重要的知识点，这里不详细阐述，后面会安排**

接下来我们就来看看和Bean初始化阶段相关各种回调事件执行方法`#initializeBean()`，分析一下上面流程图的执行顺序是怎么实现的。

protected Object initializeBean(final String BeanName, final Object Bean, RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        invokeAwareMethods(BeanName, Bean);
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
                // 涉及到的回调接口点进去一目了然，代码都是自解释的
                // BeanNameAware、BeanClassLoaderAware或BeanFactoryAware
                invokeAwareMethods(BeanName, Bean);
            }
    
            Object wrappedBean = Bean;
            if (mbd == null || !mbd.isSynthetic()) {
                // BeanPostProcessor 的 postProcessBeforeInitialization 回调
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, BeanName);
            }
    
            try {
                // init-methods
                // 或者是实现了InitializingBean接口，会调用afterPropertiesSet() 方法
                invokeInitMethods(BeanName, wrappedBean, mbd);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        BeanName, "Invocation of init method failed", ex);
            }
            if (mbd == null || !mbd.isSynthetic()) {
                // BeanPostProcessor 的 postProcessAfterInitialization 回调
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, BeanName);
            }
            return wrappedBean;
        }
    复制代码

至于Bean的销毁流程与Bean初始化类似，从上面的使用示例中看可以得出当容器关闭时，才会对Bean销毁方法进行调用。销毁过程是这样的。顺着`close()-> doClose() -> destroyBeans() -> destroySingletons() -> destroySingleton() -> destroyBean() -> Bean.destroy()`，会看到最终调用Bean的销毁方法。这里就不在展示源码细节啦，有兴趣的话自行去调试查看了解

### 4.总结 ###

以上全部就是对Spring Bean生命周期的全面总结， Spring 的 Bean 容器机制是非常强大的，它可以帮助我们轻松地管理 Bean 对象，并且提供了丰富的生命周期回调方法，允许我们在 Bean 的生命周期中执行自己的特定操作，这对于我们平时工作使用中进行增强扩展至关重要，因此掌握Bean的生命周期是必须的。

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bcef42d5414e4f1e8ad32117acdbcdf4.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ac019c0658ce44e5a364a92394b4b1f9.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/63add475164d4017af8bdbc55186405c.png