前言
計劃趕不上變化，原本年前準備將這個主題告一段落，但各種工作之外的事接踵而至，且剩下的工作量依然超過我的預期，只能拖到現在，前段時間接了商業化廣告的活，源碼看得多了自己寫時總不自覺的按更高的標準要求自己，一遍遍的修改重構，這可能就是所謂的潛移默化吧
bean加載三部曲中的第一部按照doGetBean(String, Class<T>, Object[], boolean)自上而下的代碼結構將加載分為if-else兩段，前段在getBean顯式調用時返回單例對象以及自定義FactoryBean生成bean時調用，其中的重點為部分解決循環依賴的“三層緩存”和getObjectForBeanInstance(Object, String, String, RootBeanDefinition)，后段由初始化過程中隱式調用以及獲得多例對象時調用，在第二部中介紹了隱式調用的整個流程，最后剩下createBean(String, RootBeanDefinition, Object[])核心創建bean尚未分析，本篇文章就與這部分內容相關

由于只剩下createBean這個核心方法了，那么我們還是像前面將核心方法分成幾塊講解

圖1. AbstractAutowireCapableBeanFactory的createBean(String, RootBeanDefinition, Object[])

圖2. 解析出可實例化的Class

圖3. 使用ClassUtils創建出Class

<bean id="myInt" class="java.lang.Integer">

我定義的對象就是“原始”數據類型，這種類型的Class處理就由第一部分負責，具體是怎么做的呢，實際上是兩個Map，一個是resolvePrimitiveClassName(String)中隱含的primitiveTypeNameMap，另一個就是commonClassCache，對應的代碼給大家看一下

圖4. 原始Class元素的塞入

圖5. SingletonService

圖6. Prototype接口

圖7. Prototype接口的實現類MyPrototype

圖8. 相關XML配置

圖9. AbstractBeanDefinition的prepareMethodOverrides()

圖10. InstantiationAwareBeanPostProcessorImpl

<bean id="student" class="com.xiaomi.bean.Student">
    <property name="name" value="zhangsan"></property>
</bean>
<bean id="instantiationAwareBeanPostProcessor" class="com.xiaomi.bean.InstantiationAwareBeanPostProcessorImpl"></bean>

運行并兩次獲得Student實例打印，結果如下

圖11. InstantiationAwareBeanPostProcessor例子運行結果

圖12. 去除postProcessBeforeInstantiation注釋部分去除運行結果

圖13. AbstractAutowireCapableBeanFactory的resolveBeforeInstantiation(String, RootBeanDefinition)

圖14. AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsBeforeInstantiation(Class<?>, String)

圖15. AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsAfterInitialization(Object, String)

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
  // Instantiate the bean.
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
    //    (1)
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
    //    （2）
    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) {
      //    (3)
      applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      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.isDebugEnabled()) {
      logger.debug("Eagerly caching bean '" + beanName +
          "' to allow for resolving potential circular references");
    }
    //    （5）
    addSingletonFactory(beanName, new ObjectFactory<Object>() {
      public Object getObject() throws BeansException {
        return getEarlyBeanReference(beanName, mbd, bean);
      }
    });
  }

  // Initialize the bean instance.
  Object exposedObject = bean;
  try {
    //    （6）
    populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
      //    （7）
      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);
    }
  }
  //    （8）
  if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
      if (exposedObject == bean) {
        exposedObject = earlySingletonReference;
      }
      else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
        String[] dependentBeans = getDependentBeans(beanName);
        Set<String> actualDependentBeans = new LinkedHashSet<String>(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 " +
              "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
        }
      }
    }
  }

  // Register bean as disposable.
  try {
    //    （9）
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
}

Spring首先創建了一個bean的包裝類，按照官方文檔上的說法提供該類的好處有：1.提供了設置單個和成塊屬性值的功能，可以獲得屬性的descriptors，查詢屬性是否可讀可寫；2.支持屬性的無限嵌套；2.具有不改變目標類代碼情況下，添加PropertyChangeListeners和VetoableChangeListeners功能等。還想深入了解該類的讀者可以看Bean manipulation and the BeanWrapper。如果緩存中已經存在我們后續要操作的BeanWrapper，直接移除取出做后續處理如標注1，如果暫時不存在該對象標注2處代碼進行創建，此處是getBean核心邏輯之一，Spring根據創建對象方式的不同又在該方法內部分為三部分：1.根據factory-method工廠方法進行創建；2.匹配一個或多個參數的有參構造器創建；3.默認無參進行實例化。后續會用專門的文章對這三種方式的創建流程進行分析。
到目前為止我們已經遇過兩個后處理器相關的接口，一個是BeanPostProcessor，另一個是它的子接口InstantiationAwareBeanPostProcessor，標注3又會引出一個BeanPostProcessor的子接口MergedBeanDefinitionPostProcessor，除了父接口的兩個方法外還需實現該接口的類給出postProcessMergedBeanDefinition(RootBeanDefinition, Class<?>, String)，前面我們說過如果<bean>存在父子關系，Spring在解析之后會將父子關系的<bean>映射成為RootBeanDefinition，那么該后處理器及待實現方法就是在做RootBeanDefinition的后處理工作
標注4根據：1.是否單例；2.是否允許循環引用標志；3.beanName對應的bean是否正在創建中三個條件決定是否允許“早期單例暴露”。同樣的，我們說過Spring中部分解決循環依賴的第三級緩存正是標注5的代碼，如果判斷允許“早期單例暴露”就將創建該單例對象的ObjectFactory存入三級緩存singletonFactories。當要獲得單例對象時Spring會調用自定義ObjectFactory的getObject()，其實就是這里的getEarlyBeanReference(String, RootBeanDefinition, Object)

圖16. 獲得早期單例對象引用getEarlyBeanReference(String, RootBeanDefinition, Object)

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        PropertyValues pvs = mbd.getPropertyValues();
                //    (1)
        if (bw == null) {
            if (!pvs.isEmpty()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                // Skip property population phase for null instance.
                return;
            }
        }

        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
        // state of the bean before properties are set. This can be used, for example,
        // to support styles of field injection.
        boolean continueWithPropertyPopulation = true;
                //      (2)
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        if (!continueWithPropertyPopulation) {
            return;
        }
                //      (3)
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            // Add property values based on autowire by name if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            // Add property values based on autowire by type if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
                //      (4)
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }
                //      (5)
        applyPropertyValues(beanName, mbd, bw, pvs);
    }

Spring初始化解析XML配置文件時，所有的<property>會放入PropertyValue的集合中，集合又被封裝入MutablePropertyValues對象中。標注1的判斷邏輯是，如果不存在是<bean>對應實體BeanWrapper但還存在解析出的屬性，肯定出現問題了，拋出異常；如果不存在實體也不存在屬性，那也沒有繼續往下解析的必要了，直接返回。標注2又一次用到了上面講過的InstantiationAwareBeanPostProcessor，如果存在實現該接口后處理器，則調用boolean postProcessAfterInstantiation(Object, String)，進行對象實例創建后的處理，這里依然存在一個短路操作，如果方法返回false，continueWithPropertyPopulation為假，如果該值非真，也無需進行后處理器對于屬性處理等后續操作了。標注3很明顯涉及按名稱、按類型兩種屬性注入方式，后續會有專門文章分析注入原理，這里不做闡述。標注4根據是否有InstantiationAwareBeanPostProcessor或依賴檢查標識判斷是否進行屬性的“調包”處理，處理的過程就是InstantiationAwareBeanPostProcessor自有方法的最后一個PropertyValues postProcessPropertyValues(PropertyValues, PropertyDescriptor[], Object, String)。到這里Spring得到了所有需要填充的屬性（兩種方式注入的、后處理器調包的），最后調用標注5處代碼真正將屬性設置進BeanWrapper對象中，代碼清單4

    protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        if (pvs == null || pvs.isEmpty()) {
            return;
        }

        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;

        if (System.getSecurityManager() != null) {
            if (bw instanceof BeanWrapperImpl) {
                ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
            }
        }
                //    (1)
        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                // Shortcut: use the pre-converted values as-is.
                try {
                    bw.setPropertyValues(mpvs);
                    return;
                }
                catch (BeansException ex) {
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
                }
            }
            original = mpvs.getPropertyValueList();
        }
        else {
            original = Arrays.asList(pvs.getPropertyValues());
        }
                //      (2)
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
                //      (3)
        // Create a deep copy, resolving any references for values.
        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            }
            else {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                                //    (4)
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                                        //    (5)
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                //     (6)
                if (resolvedValue == originalValue) {
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                //    (7)
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
        //    (8)
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }

        // Set our (possibly massaged) deep copy.
        try {
            //    (9)
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }

標注1首先判斷所有屬性整體是否都被轉換，如果是就不需要下面的步驟，直接賦值返回；如果并不是所有屬性已經轉換過，就會首先按標注2獲取用戶自定義的類型轉換器。標注3創建了新集合用于存放轉換后的結果，之后遍歷每一個屬性并依次判斷轉換與否，沒有轉換則標注4根據上面創建的解析器valueResolver對該值進行解析，我們知道除了最普通的String外Spring支持多種形式的屬性配置，該方法中就包含了幾乎所有類型屬性的解析流程，這里給出一張表格涉及所有解析的類型已經該類型在讀取XML時對應的封裝類型

如果判斷該屬性是可轉換的convertible = true，就會開始標注5的自定義轉換器的轉換，如果原始值originalValue與經過Spring內置解析器解析后的值resolvedValue相同，且可轉換標識convertible為真說明必定經過了自定義轉換的步驟（不管是否真的轉換過），此時用最新的convertedValue替換老值，如果標識6所示。實際上我覺得標注6和7具有相同的目的，只要convertible為真就說明最新的值必然為convertedValue，那也必然要更新屬性封裝對象對應字段了。標注8將屬性對象設為整體已轉化，與方法一開始根據此判斷直接返回還是開始轉換相呼應。標注9終于將解析后數組封裝入MutablePropertyValues，再塞入BeanWrapper中，至此創建對象中的屬性填充流程分析完畢
接著代碼清單2分析看標注7，“初始化”Bean

圖17. AbstractAutowireCapableBeanFactory的initializeBean(String, Object, RootBeanDefinition)

圖18. AbstractAutowireCapableBeanFactory的invokeInitMethods(String, Object, RootBeanDefinition)

圖19. Spring中Bean的生命周期

1. Instantiate對應代碼清單2標注2instanceWrapper = createBean(beanName, mbd, args);第一次創建bean
2. Popluate properties對應代碼清單3整個屬性填充過程
3. BeanNameAware's setBeanName()對應圖17invokeAwareMethods(String, Object)處理第一個BeanNameAware流程
4. BeanFactoryAware's setBeanFactory()對應圖17invokeAwareMethods(String, Object)處理第三個BeanFactoryAware流程
5. Pre-initializatioin beanPostProcessors對應圖17標注2代碼applyBeanPostProcessorsBeforeInitialization(Object, String)
6. InitializingBean's afterPropertiesSet()對應圖18紅線處邏輯
7. Call custom init-method對應圖18紅框內代碼
8. Post-initialization beanPostProcessors對應圖17標注4代碼applyBeanPostProcessorsAfterInitialization(Object, String)

生命周期中的最后兩個狀態雖然現在沒有遇到，但大家看名字就很明顯9與6InitializingBean接口對應，一個初始化一個銷毀；10destroy-method屬性和7init-method對應。記得剛學習Spring時，這個生命周期是永遠記不住的知識點，但整個源碼分析下來就清清爽爽了
回到主線代碼清單2，標注8處代碼看上去一大堆，實際這段被執行到的可能性很小，earlySingleton = true會調用我們曾今說的Object getSingleton(String, boolean)，我們將方法放在現在的“語境”中再分析一下

圖20. 特定場景下的Object getSingleton(String, boolean)執行流程圖

圖21. AbstractBeanFactory的registerDisposableBeanIfNecessary(String, Object, RootBeanDefinition)