Spring官网阅读（十）Spring中Bean的生命周期（下）

超、凢脫俗 2023-07-13 05:57 122阅读 0赞

文章目录

      • 生命周期概念补充
      • 实例化
        • createBean流程分析
        • doCreateBean流程分析
          • 第一步：factoryBeanInstanceCache什么时候不为空？
          • 第二步：创建对象（createBeanInstance）
          • 第三步：applyMergedBeanDefinitionPostProcessors
          • 第四步：getEarlyBeanReference
      • 属性注入
          • 第五步：属性注入（populateBean）
      • 总结

在上篇文章中，我们已经对Bean的生命周期做了简单的介绍，主要介绍了整个生命周期中的初始化阶段以及基于容器启动停止时LifeCycleBean的回调机制，另外对Bean的销毁过程也做了简单介绍。但是对于整个Bean的生命周期，这还只是一小部分，在这篇文章中，我们将学习完成剩下部分的学习，同时对之前的内容做一次复习。整个Bean的生命周期，按照我们之前的介绍，可以分为四部分

  • 实例化
  • 属性注入
  • 初始化
  • 销毁

本文主要介绍实例化及属性注入阶段

生命周期概念补充

虽然我们一直说整个Bean的生命周期分为四个部分，但是相信很多同学一直对Bean的生命周期到底从哪里开始，到哪里结束没有一个清晰的概念。可能你会说，不就是从实例化开始，到销毁结束吗？当然，这并没有错，但是具体什么时候算开始实例化呢？什么时候又算销毁呢？这个问题你是否能清楚的回答呢？如果不能，请继续往下看。

笔者认为，整个Spring中Bean的生命周期，从第一次调用后置处理器中的applyBeanPostProcessorsBeforeInstantiation方法开始的，这个方法见名知意，翻译过来就是在实例化之前调用后置处理器。而applyBeanPostProcessorsAfterInitialization方法的调用，意味着Bean的生命周期中创建阶段的结束。对于销毁没有什么歧义，就是在调用对应Bean的销毁方法就以为着这个Bean走到了生命的尽头，标志着Bean生命周期的结束。那么结合上篇文章中的结论，我现在把Bean的生命周期的范围界定如下：

在这里插入图片描述

需要注意的是，对于BeanDefinion的扫描，解析，验证并不属于Bean的生命周期的一部分。这样清晰的界定Bean的生命周期的概念是很有必要的，也许刚刚开始对于我们而言，Bean的生命周期就是一团乱麻，但是至少现在我们已经抓住了线头。而整个Bean的生命周期，我将其分为了两部分

  • 创建
  • 销毁

对于销毁阶段，我们不需要过多关注，对于创建阶段，开始的标志行为为：applyBeanPostProcessorsBeforeInstantiation方法执行，结束的标志行为为：applyBeanPostProcessorsAfterInitialization方法执行。

基于上面的结论，我们开始进行接下来的分析对于本文中代码的分析，我们还是参照下面这个图

在这里插入图片描述

实例化

整个实例化的过程主要对于上图中的3-11-6-4（createBean）以及3-11-6-4-1（doCreateBean）步骤

createBean流程分析

代码如下：

  1. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2.             throws BeanCreationException { 
  4.         RootBeanDefinition mbdToUse = mbd;
  6.     // 第一步：解析BeanDefinition中的beanClass属性
  7.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  8.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
  9.             mbdToUse = new RootBeanDefinition(mbd);
  10.             mbdToUse.setBeanClass(resolvedClass);
  11.         }
  13.         try { 
  14.             // 第二步：处理lookup-method跟replace-method，判断是否存在方法的重载
  15.             mbdToUse.prepareMethodOverrides();
  16.         }
  17.         catch (BeanDefinitionValidationException ex) { 
  18.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  19.                     beanName, "Validation of method overrides failed", ex);
  20.         }
  22.         try { 
  23.             // 第三步：判断这个类在之后是否需要进行AOP代理
  24.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  25.             if (bean != null) { 
  26.                 return bean;
  27.             }
  28.         }
  29.         catch (Throwable ex) { 
  30.             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  31.                     "BeanPostProcessor before instantiation of bean failed", ex);
  32.         }
  34.         try { 
  35.             // 开始创建Bean
  36.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  37.             return beanInstance;
  38.         }
  39.         catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { 
  40.             throw ex;
  41.         }
  42.         catch (Throwable ex) { 
  43.             throw new BeanCreationException(
  44.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  45.         }
  46.     }

可以看到，第一步跟第二步还是在对BeanDefinition中的一些属性做处理，它并不属于我们Bean的生命周期的一部分，我们直接跳过，接下来看第三步的代码：

  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { 
  2.     Object bean = null;
  3.     if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { 
  4.         // 不是合成类，并且有实例化后置处理器。这个判断基本上恒成立
  5.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
  6.             // 获取这个BeanDefinition的类型
  7.             Class<?> targetType = determineTargetType(beanName, mbd);
  8.             if (targetType != null) { 
  9.                 // 这里执行的主要是AbstractAutoProxyCreator这个类中的方法，决定是否要进行AOP代理
  10.                 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  11.                 // 这里执行了一个短路操作，如果在这个后置处理中直接返回了一个Bean,那么后面相关的操作就不会执行了，只会执行一个AOP的代理操作
  12.                 if (bean != null) { 
  13.                     // 虽然这个Bean被短路了，意味着不需要经过后面的初始化阶段，但是如果需要代理的话，还是要进行AOP代理，这个地方的短路操作只是意味着我们直接在后置处理器中提供了一个准备充分的的Bean，这个Bean不需要进行初始化，但需不需要进行代理，任然由AbstractAutoProxyCreator的applyBeanPostProcessorsBeforeInstantiation方法决定。在这个地方还是要调用一次Bean的初始化后置处理器保证Bean被完全的处理完
  14.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  15.                 }
  16.             }
  17.         }
  18.         // bean != null基本会一直返回false,所以beforeInstantiationResolved这个变量也会一直为false
  19.         mbd.beforeInstantiationResolved = (bean != null);
  20.     }
  21.     return bean;
  22. }

对于AbstractAutoProxyCreator中applyBeanPostProcessorsBeforeInstantiation这个方法的分析我们暂且不管，等到AOP学习阶段在进行详细分析。我们暂且只需要知道这个方法会决定在后续中要不要为这个Bean产生代理对象。

doCreateBean流程分析

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  2.             throws BeanCreationException { 
  4.         BeanWrapper instanceWrapper = null;
  5.         if (mbd.isSingleton()) { 
  6.             // 第一步：单例情况下，看factoryBeanInstanceCache这个缓存中是否有
  7.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8.         }
  9.         if (instanceWrapper == null) { 
  10.             // 第二步：这里创建对象
  11.             instanceWrapper = createBeanInstance(beanName, mbd, args);
  12.         }
  13.         final Object bean = instanceWrapper.getWrappedInstance();
  14.         Class<?> beanType = instanceWrapper.getWrappedClass();
  15.         if (beanType != NullBean.class) { 
  16.             mbd.resolvedTargetType = beanType;
  17.         }
  19.         synchronized (mbd.postProcessingLock) { 
  20.             if (!mbd.postProcessed) { 
  21.                 try { 
  22.                     // 第三步：后置处理器处理
  23.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  24.                 }
  25.                 catch (Throwable ex) { 
  26.                     // 省略异常处理
  27.                 }
  28.                 mbd.postProcessed = true;
  29.             }
  30.         }
  32.         // 循环引用相关，源码阅读阶段再来解读这段代码，暂且就关注以下后置处理器的调用时机
  33.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  34.                 isSingletonCurrentlyInCreation(beanName));
  35.         if (earlySingletonExposure) { 
  36.             // 第四步：调用后置处理器，早期曝光一个工厂对象
  37.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  38.         }
  40.         Object exposedObject = bean;
  41.         try { 
  42.             // 第五步：属性注入
  43.             populateBean(beanName, mbd, instanceWrapper);
  44.             // 第六步：初始化
  45.             exposedObject = initializeBean(beanName, exposedObject, mbd);
  46.         }
  47.         catch (Throwable ex) { 
  48.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
  49.                 throw (BeanCreationException) ex;
  50.             }
  51.             else { 
  52.                 // 省略异常处理
  53.             }
  54.         }
  56.         if (earlySingletonExposure) { 
  57.             Object earlySingletonReference = getSingleton(beanName, false);
  58.             if (earlySingletonReference != null) { 
  59.                 if (exposedObject == bean) { 
  60.                     exposedObject = earlySingletonReference;
  61.                 }
  62.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
  63.                     String[] dependentBeans = getDependentBeans(beanName);
  64.                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  65.                     for (String dependentBean : dependentBeans) { 
  66.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
  67.                             actualDependentBeans.add(dependentBean);
  68.                         }
  69.                     }
  70.                     if (!actualDependentBeans.isEmpty()) { 
  71.                         // 省略异常处理
  72.                     }
  73.                 }
  74.             }
  75.         }
  77.         try { 
  78.             // 第七步：注册需要销毁的Bean,放到一个需要销毁的Map中（disposableBeans）
  79.             registerDisposableBeanIfNecessary(beanName, bean, mbd);
  80.         }
  81.         catch (BeanDefinitionValidationException ex) { 
  82.             // 省略异常处理
  83.         }
  85.         return exposedObject;
  86.     }
第一步：factoryBeanInstanceCache什么时候不为空？
  1. if (mbd.isSingleton()) { 
  2.     // 第一步：单例情况下，看factoryBeanInstanceCache这个缓存中是否有
  3.     instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  4. }

这段代码深究起来很复杂，我这里就单纯用理论解释下：

假设我们现在有一个IndexService，它有一个属性A，代码如下：

  1. @Component
  2. public class IndexService { 
  3.     @Autowired
  4.     A a;
  6.     public A getA() { 
  7.         return a;
  8.     }
  9. }

而这个A又是采用FactroyBean的形式配置的，如下：

  1. @Component
  2. public class MyFactoryBean implements SmartFactoryBean { 
  3.     @Override
  4.     public A getObject() throws Exception { 
  5.         return new A();
  6.     }
  7.     @Override
  8.     public Class<?> getObjectType() { 
  9.         return A.class;
  10.     }
  11.     // 这个地方并不一定要配置成懒加载，这里只是为了让MyFactoryBean这个Bean在IndexService之后实例化
  12.     @Override
  13.     public boolean isEagerInit() { 
  14.         return false;
  15.     }
  16. }

我们思考一个问题，在上面这种场景下，当IndexService要完成属性注入时，Spring会怎么做呢？

Spring现在知道IndexService要注入一个类型为A的属性，所以它会遍历所有的解析出来的BeanDefinition，然后每一个BeanDefinition中的类型是不是A类型，类似下面这样：

  1. for (String beanName : this.beanDefinitionNames) { 
  2.     // 1.获取BeanDefinition
  3.     // 2.根据BeanDefinition中的定义判断是否是一个A
  4. }

上面这种判断大部分情况下是成立的，但是对于一种特殊的Bean是不行的，就是我们之前介绍过的FactoryBean，因为我们配置FactoacryBean的目的并不是直接使用FactoryBean这个Bean自身，而是想要通过它的getObject方法将一个对象放到Spring容器中，所以当我们遍历到一个BeanDefinition，并且这个BeanDefinition是一个FactoacryBean时就需要做特殊处理，我们知道FactoacryBean中有一个getObjectType方法，通过这个方法我们可以得到要被这个FactoacryBean创建的对象的类型，如果我们能调用这个方法的话，那么我们就可以来判断这个类型是不是一个A了。

但是，在我们上面的例子中，这个时候MyFactoryBean还没有被创建出来。所以Spring在这个时候会去实例化这个MyFactoryBean，然后调用其getObjectType方法，再做类型判断，最后进行属性注入，伪代码如下：

  1. for (String beanName : this.beanDefinitionNames) { 
  2.     // 1.获取BeanDefinition
  3.     // 2.如果不是一个FactoacryBean，直接根据BeanDefinition中的属性判断
  4.     if(不是一个FactoacryBean){ 
  5.         //直接根据BeanDefinition中的属性判断是不是A
  6.     }
  7.     // 3.如果是一个FactoacryBean
  8.     if(是一个FactoacryBean){ 
  9.         // 先创建这个FactoacryBean，然后再调用getObjectType方法了
  10.     }
  11. }

大家可以根据我们上面的代码自己调试，我这里就不放debug的截图了。

第二步：创建对象（createBeanInstance）
  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
  2.         // 获取到解析后的beanClass
  3.         Class<?> beanClass = resolveBeanClass(mbd, beanName);
  5.         // 忽略异常处理
  6.         Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  7.         if (instanceSupplier != null) { 
  8.             return obtainFromSupplier(instanceSupplier, beanName);
  9.         }
  11.         // 获取工厂方法，用于之后创建对象 
  12.         if (mbd.getFactoryMethodName() != null) { 
  13.             return instantiateUsingFactoryMethod(beanName, mbd, args);
  14.         }
  16.         // 原型情况下避免多次解析
  17.         boolean resolved = false;
  18.         boolean autowireNecessary = false;
  19.         if (args == null) { 
  20.             synchronized (mbd.constructorArgumentLock) { 
  21.                 if (mbd.resolvedConstructorOrFactoryMethod != null) { 
  22.                     resolved = true;
  23.                     autowireNecessary = mbd.constructorArgumentsResolved;
  24.                 }
  25.             }
  26.         }
  27.         if (resolved) { 
  28.             if (autowireNecessary) { 
  29.                 return autowireConstructor(beanName, mbd, null, null);
  30.             }
  31.             else { 
  32.                 return instantiateBean(beanName, mbd);
  33.             }
  34.         }
  36.         // 跟后置处理器相关，我们主要关注这行代码
  37.         Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  38.         if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  39.                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
  40.             return autowireConstructor(beanName, mbd, ctors, args);
  41.         }
  43.         // Preferred constructors for default construction?
  44.         ctors = mbd.getPreferredConstructors();
  45.         if (ctors != null) { 
  46.             return autowireConstructor(beanName, mbd, ctors, null);
  47.         }
  49.         // 默认使用无参构造函数创建对象
  50.         return instantiateBean(beanName, mbd);
  51.     }

在创建对象的时候，其余的代码我们暂时不做过多关注。我们暂且知道在创建对象的过程中，Spring会调用一个后置处理器来推断构造函数。

第三步：applyMergedBeanDefinitionPostProcessors

应用合并后的BeanDefinition，Spring自身利用这点做了一些注解元数据的缓存。

我们就以AutowiredAnnotationBeanPostProcessor这个类的对应方法看一下其大概作用

  1. public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { 
  2.     // 这个方法就是找到这个正在创建的Bean中需要注入的字段，并放入缓存中
  3.     InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
  4.     metadata.checkConfigMembers(beanDefinition);
  5. }
第四步：getEarlyBeanReference
  1. protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { 
  2.     Object exposedObject = bean;
  3.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
  4.         for (BeanPostProcessor bp : getBeanPostProcessors()) { 
  5.             if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { 
  6.                 SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
  7.                 // 在这里保证注入的对象是一个代理的对象（如果需要代理的话），主要用于循环依赖
  8.                 exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
  9.             }
  10.         }
  11.     }
  12.     return exposedObject;
  13. }

属性注入

第五步：属性注入（populateBean）
  1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { 
  2.         if (bw == null) { 
  3.             if (mbd.hasPropertyValues()) { 
  4.                 // 省略异常
  5.             }
  6.             else { 
  7.                 return;
  8.             }
  9.         }
  11.         boolean continueWithPropertyPopulation = true;
  13.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
  14.             for (BeanPostProcessor bp : getBeanPostProcessors()) { 
  15.                 if (bp instanceof InstantiationAwareBeanPostProcessor) { 
  16.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  17.                     if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {             // 主要判断之后是否需要进行属性注入
  18.                         continueWithPropertyPopulation = false;
  19.                         break;
  20.                     }
  21.                 }
  22.             }
  23.         }
  25.         if (!continueWithPropertyPopulation) { 
  26.             return;
  27.         }
  29.         PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  31.         // 自动注入模型下，找到合适的属性，在后续方法中再进行注入
  32.         if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { 
  33.             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  34.             // Add property values based on autowire by name if applicable.
  35.             if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) { 
  36.                 autowireByName(beanName, mbd, bw, newPvs);
  37.             }
  38.             // Add property values based on autowire by type if applicable.
  39.             if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { 
  40.                 autowireByType(beanName, mbd, bw, newPvs);
  41.             }
  42.             pvs = newPvs;
  43.         }
  45.         boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  46.         boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
  48.         PropertyDescriptor[] filteredPds = null;
  49.         if (hasInstAwareBpps) { 
  50.             if (pvs == null) { 
  51.                 pvs = mbd.getPropertyValues();
  52.             }
  53.             for (BeanPostProcessor bp : getBeanPostProcessors()) { 
  54.                 if (bp instanceof InstantiationAwareBeanPostProcessor) { 
  55.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  56.                     // 精确注入下，在这里完成属性注入
  57.                     PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
  58.                     // 一般不会进行这个方法
  59.                     if (pvsToUse == null) { 
  60.                         if (filteredPds == null) { 
  61.                             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  62.                         }
  63.                         pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  64.                         if (pvsToUse == null) { 
  65.                             return;
  66.                         }
  67.                     }
  68.                     pvs = pvsToUse;
  69.                 }
  70.             }
  71.         }
  72.         if (needsDepCheck) { 
  73.             if (filteredPds == null) { 
  74.                 filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  75.             }
  76.             checkDependencies(beanName, mbd, filteredPds, pvs);
  77.         }
  79.         if (pvs != null) { 
  80.             // XML配置，或者自动注入，会将之前找到的属性在这里进行注入
  81.             applyPropertyValues(beanName, mbd, bw, pvs);
  82.         }
  83.     }

在上面整个流程中，我们主要关注一个方法，postProcessProperties，这个方法会将之前通过postProcessMergedBeanDefinition方法找到的注入点，在这一步进行注入。完成属性注入后，就开始初始化了，初始化的流程在上篇文章中已经介绍过了，这里就不再赘述了。

总结

在这两篇文章中，我们已经对Bean的全部的生命周期做了详细分析，当然，对于一些复杂的代码，暂时还没有去深究，因为之后打算写一系列专门的源码分析文章。大家可以关注我后续的文章。对于整个Bean的生命周期可以总结画图如下

在这里插入图片描述

首先，整个Bean的生命周期我们将其划分为两个部分

  1. 创建
  2. 销毁

对于创建阶段，我们又将其分为三步

  • 实例化
  • 属性注入
  • 初始化

我们可以看到，在整个过程中BeanPostPorcessor穿插执行，辅助Spring完成了整个Bean的生命周期。

扫描下方二维码，关注我的公众号，更多精彩文章在等您！~~

公众号

发表评论

表情：
评论列表 （有 0 条评论，122人围观）

还没有评论，来说两句吧...

相关阅读