Spring源码初探-IOC(3)-Bean的初始化-bean的加载

淡淡的烟草味﹌ 2021-06-11 15:14 468阅读 0赞

[https://www.jianshu.com/p/ecc60703d315][https_www.jianshu.com_p_ecc60703d315]

## 前言 ##

前面两篇文章主要介绍的是xml到BeanDefinition的过程，我们知道在使用Spring的过程中通常直接使用getBean(beanName)的方式，getBean返回的是实例化并且已经完成初始化后的对象。对于我们平时使用来说，创建一个对象通常会使用new,或者使用反射。我们使用反射instantiation对象，使用反射填充field，使用反射调用init方法，最终得到对象使用。Spring也是采用的同样的过程，只不过过程更为复杂，考虑的异常情况更多。

抽丝剥茧出主干也就是：

*  根据BeanDefinition的信息找到对象构造器，实例化对象
 *  根据BeanDefinition的信息找到属性值，填充之
 *  如果有初始化方法，调用初始化方法
    
    当然上述主干主要讲的是非单例对象，如果是单例对象创建一次之后需要保证其唯一性，而以上三步每一步在Spring中都很复杂，本文只是分析一个大体过程，而每个小点将放在以后的博文中进行详细讲解，目前规划好的小点有：
 *  Spring对于循环依赖问题的解决
 *  Spring属性填充过程
 *  Spring在Bean创建过程中提供的扩展点及事件监听
 *  Spring的initiation过程及一种并行初始化的实现。

## getBean的主干 ##

抽出BeanFactory.getBean的主干如下：

![format_png][]

getBean主干

在本文中只讨论单例对象(默认scope，非factoryBean类)的创建过程  
贴一段doGetBean的主干代码

protected <T> T doGetBean(      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)      throws BeansException {   
     final String beanName = transformedBeanName(name);  
     Object bean;   
    // Eagerly check singleton cache for manually registered singletons.   
     Object sharedInstance = getSingleton(beanName);
    ...
    if (mbd.isSingleton()) {  
     sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {      @Override      
    public Object getObject() throws BeansException {         
    try {
                return createBean(beanName, mbd, args);  
           } catch (BeansException ex) { 
               // Explicitly remove instance from singleton cache: It might have been put there
                // eagerly by the creation process, to allow for circular reference resolution.
                // Also remove any beans that received a temporary reference to the bean.  
              destroySingleton(beanName);
                throw ex; 
            }      }   });  
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }

这段代码描述的过程很简单，首先进行transformedBeanName(name)转换beanName，然后试着调用getSingleton(beanName)， getSingleton(beanName）是从一个缓存的singletonObjects Map中查询(如果没有拿到其实还会去earlySingletonObjects中拿，这个是为了解决循环依赖，在后面的博文中详细叙述)，这个Map保存着已经创建好的单例对象。在如果没有拿到缓存对象的情况下，会继续getSingleton(beanName, singletonFactory)方法。  
getSingleton(beanName, singletonFactory)这个方法是一个比较让人疑惑的地方，Spring传进去了一个ObjectFactory匿名内部类，该类override了getObject()方法，getObject实际上是createBean。在getSingleton(beanName, singletonFactory)方法中会调用getObject(),实际上也就是调用了createBean，bean的创建实际上是从这个地方开始的。

> 这种实现方式让人很费解，很可能仅仅是为了抽出ObjectFactory接口，这个接口有个getObject方法，顾名思义是为了获取Object，当然获取Object的形式有很多，可以返回同一个创建好的对象，可以每次都新建一个对象。在解决循环依赖问题的时候Spring也用了一个ObjectFactory匿名内部类，后面的博文会讲到

让我们看一看getSingleton(beanName, singletonFactory)这个方法究竟干了什么

synchronized (this.singletonObjects) {
          Object singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null) {
             if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,                  "Singleton bean creation not allowed while the singletons of this factory are in destruction " +                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); 
            }
             if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); 
            }
             beforeSingletonCreation(beanName); 
            boolean newSingleton = false;
             boolean recordSuppressedExceptions = (this.suppressedExceptions == null); 
            if (recordSuppressedExceptions) { 
              this.suppressedExceptions = new LinkedHashSet<Exception>(); 
            } 
            try { 
               singletonObject = singletonFactory.getObject(); 
               newSingleton = true;
             }
         ...删掉了异常处理
             finally { 
               if (recordSuppressedExceptions) {
                   this.suppressedExceptions = null; 
               } 
               afterSingletonCreation(beanName);
             }
             if (newSingleton) { 
               addSingleton(beanName, singletonObject); 
            } 
         }
          return (singletonObject != NULL_OBJECT ? singletonObject : null);   }}

在去掉异常处理后，这段代码非常的简单，首先从singletonObjects map里试着拿bean，如果拿不到的话调用singletonFactory.getObject()，在这里表现为createBean()，最后如果是新创建的singleton，调用addSingleton(beanName, singletonObject)将新创建的对象保存到singletonObjects Map中便于下次使用。

## createBean ##

createBean主要负责创建对象，它将责任委派给了doCreateBean，其主干代码如下：

BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
       instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
       instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
       if (!mbd.postProcessed) {      applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);      mbd.postProcessed = true;
       }
    }
    try {
       populateBean(beanName, mbd, instanceWrapper);
       if (exposedObject != null) {
          exposedObject = initializeBean(beanName, exposedObject, mbd);
       }
    }
    if (earlySingletonExposure) {
       Object earlySingletonReference = getSingleton(beanName, false);
    }
    try {
       registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }

抽去一些不太重要的代码只有，整个逻辑非常清楚，首先createBeanInstance创建对象，然后填充对象populateBean，最后调用初始化方法initializeBean，和我们使用反射创建对象的常用流程差不多，只不过这三个函数都异常的复杂，在后面的博文中会分别介绍

## 总结 ##

这篇文章只是大体介绍了getBean的主干部分，各个细节的部分后面的博文会详细讲解！

[https_www.jianshu.com_p_ecc60703d315]: https://www.jianshu.com/p/ecc60703d315
[format_png]: /images/20210527/5005094b12c043cea54608f698973fd6.png