1. 程式人生 > >Spring原始碼解析之bean的建立

Spring原始碼解析之bean的建立

閱讀須知

  • Spring原始碼版本:4.3.8
  • 文章中使用/* */註釋的方法會做深入分析

正文

之前我們都是在圍繞

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");

這句程式碼來分析Spring在初始化過程中都做了哪些工作,其中bean建立的部分我們並沒有做深入分析,這篇文章我們就來分析一下Spring在建立bean的過程中都做了哪些工作,圍繞這句程式碼來分析:

A a = applicationContext .getBean(A.class);

getBean這個方法有多種過載的形式,但最終都會呼叫doGetBean方法來建立bean,我們就以這個方法作為入口來分析:
AbstractBeanFactory:

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;
    /* 嘗試從快取中獲取單例bean */
Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isDebugEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"
); } else { logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); } } /* 如果是工廠型別的bean,要呼叫相關工廠方法獲取bean */ bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 原型模式的迴圈依賴無法解決,丟擲異常 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } BeanFactory parentBeanFactory = getParentBeanFactory(); // 檢查當前BeanFactory中是否包含當前待建立的bean的BeanDefinition,如果不存在,則遞迴嘗試從父級的BeanFactory載入 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { String nameToLookup = originalBeanName(name); if (args != null) { return (T) parentBeanFactory.getBean(nameToLookup, args); } else { return parentBeanFactory.getBean(nameToLookup, requiredType); } } if (!typeCheckOnly) { /* 如果建立bean不是為了型別檢查,則要標記當前bean已經被建立或者即將被建立以便於BeanFactory可以優化重複建立的bean的快取 */ markBeanAsCreated(beanName); } try { /* 合併父BeanDefinition */ final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); String[] dependsOn = mbd.getDependsOn(); // 依賴的bean if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { // 迴圈依賴檢查 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 將依賴的關係放入快取,以便於當前bean銷燬時先銷燬依賴的bean registerDependentBean(dep, beanName); getBean(dep); // 建立依賴的bean } } if (mbd.isSingleton()) { /* 嘗試從快取中載入單例bean */ sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { try { /* 建立bean */ return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } } }); /* 同樣的工廠型別的bean的處理 */ bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { Object prototypeInstance = null; try { // 原型模式bean建立前置處理,預設情況下記錄當前bean正在建立 beforePrototypeCreation(beanName); /* 建立bean */ prototypeInstance = createBean(beanName, mbd, args); } finally { // 原型模式bean建立後置處理,預設情況下移除當前bean正在建立的記錄,也就是當前bean已經建立完成 afterPrototypeCreation(beanName); } /* 同樣的工廠型別的bean的處理 */ bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { // 其他scope型別的處理 String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { beforePrototypeCreation(beanName); // 前置處理 try { return createBean(beanName, mbd, args); /* 建立bean */ } finally { afterPrototypeCreation(beanName); // 後置處理 } } }); /* 同樣的工廠型別的bean的處理 */ bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) { try { // 如果需要,使用型別轉換器裝換型別 return getTypeConverter().convertIfNecessary(bean, requiredType); } catch (TypeMismatchException ex) { if (logger.isDebugEnabled()) { logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }

DefaultSingletonBeanRegistry:

public Object getSingleton(String beanName) {
    /* 嘗試從快取中獲取,true為允許提前依賴 */
    return getSingleton(beanName, true);
}

DefaultSingletonBeanRegistry:

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName); // 首先嚐試從快取中獲取單例bean
    // 如果快取中為空並且bean正在建立中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            /* 從提前載入的bean的快取集合中獲取 */
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果為空並且允許提前依賴
            if (singletonObject == null && allowEarlyReference) {
                // 從快取中獲取bean的工廠
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 如果工廠不為空則呼叫工廠方法載入bean
                    singletonObject = singletonFactory.getObject();
                    // 記錄到提前載入的bean的快取中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 已經呼叫工廠載入bean,將工廠從快取中移除,無需再次載入
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

AbstractBeanFactory:

protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
    // 如果beanName以&符開頭(代表要獲取FactoryBean本身)但型別不是FactoryBean丟擲異常
    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
    }
    // 如果bean不是FactoryBean或者要獲取FactoryBean本身而不是要獲取工廠方法返回的例項則直接返回bean例項
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }
    // 過了上兩步的判斷到這裡可以確定當前bean一定是FactoryBean
    Object object = null;
    if (mbd == null) {
        // 嘗試從快取中獲取FactoryBean
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        if (mbd == null && containsBeanDefinition(beanName)) {
            /* 合併父BeanDefinition */
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 是否是使用者自定義的而不是應用程式本身定義的
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        /* 從FactoryBean中載入bean */
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

AbstractBeanFactory:

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    // 如果已經合併過,直接返回
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null) {
        return mbd;
    }
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

AbstractBeanFactory:

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
        throws BeanDefinitionStoreException {
    return getMergedBeanDefinition(beanName, bd, null);
}

AbstractBeanFactory:

protected RootBeanDefinition getMergedBeanDefinition(
        String beanName, BeanDefinition bd, BeanDefinition containingBd)
        throws BeanDefinitionStoreException {
    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;
        if (containingBd == null) {
            // 鎖定全域性快取後雙重檢查是否已經合併過,避免重複合併
            mbd = this.mergedBeanDefinitions.get(beanName);
        }
        if (mbd == null) {
            if (bd.getParentName() == null) {
                // 如果沒有父BeanDefinition,直接轉換成RootBeanDefinition返回
                if (bd instanceof RootBeanDefinition) {
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
                    mbd = new RootBeanDefinition(bd);
                }
            }
            else {
                BeanDefinition pbd;
                try {
                    // 轉換父beanName,主要處理FactoryBean的&符合alias別名
                    String parentBeanName = transformedBeanName(bd.getParentName());
                    if (!beanName.equals(parentBeanName)) {
                        /* 遞迴合併父BeanDefinition */
                        pbd = getMergedBeanDefinition(parentBeanName);
                    }
                    else {
                        // 如果當前bean和父bean的name相同,則嘗試用父BeanFactory遞迴合併
                        BeanFactory parent = getParentBeanFactory();
                        if (parent instanceof ConfigurableBeanFactory) {
                            pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                    "': cannot be resolved without an AbstractBeanFactory parent");
                        }
                    }
                }
                catch (NoSuchBeanDefinitionException ex) {
                    throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                            "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                }
                mbd = new RootBeanDefinition(pbd);
                mbd.overrideFrom(bd); // 深複製父BeanDefinition,將屬性copy一遍
            }
            if (!StringUtils.hasLength(mbd.getScope())) {
                mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON); // 設定預設scope
            }
            // 如果當前bean是內部bean並且scope為預設的單例,則要將scope設定為外部bean相同
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                mbd.setScope(containingBd.getScope());
            }
            if (containingBd == null && isCacheBeanMetadata()) {
                // 放入快取代表已經合併過
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }
        return mbd;
    }
}

AbstractBeanFactory:

public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
    String beanName = transformedBeanName(name); // 轉換beanName
    // 如果當前BeanFactory中不包含當前BeanDefinition,則嘗試從父BeanFactory中遞迴合併
    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
        return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
    } 
    // 遞迴合併父BeanDefinition
    return getMergedLocalBeanDefinition(beanName);
}

FactoryBeanRegistrySupport:

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    if (factory.isSingleton() && containsSingleton(beanName)) { // 單例
        synchronized (getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName); // 嘗試從快取中獲取FactoryBean
            if (object == null) {
                /* 從FactoryBean中載入bean */
                object = doGetObjectFromFactoryBean(factory, beanName);
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                // 這裡再次嘗試從快取中獲取是因為自定義的bean呼叫處理迴圈依賴時可能已經放入快取
                if (alreadyThere != null) {
                    object = alreadyThere;
                }
                else {
                    if (object != null && shouldPostProcess) {
                        try {
                            /* BeanPostProcessor的呼叫 */
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                    }
                    this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT)); // 將FactoryBean放入快取
                }
            }
            return (object != NULL_OBJECT ? object : null);
        }
    }
    else { // 非單例
        /* 從FactoryBean中載入bean */
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        if (object != null && shouldPostProcess) {
            try {
                /* BeanPostProcessor的呼叫 */
                object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        return object;
    }
}

FactoryBeanRegistrySupport:

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
        throws BeanCreationException {
    Object object;
    try {
        if (System.getSecurityManager() != null) {
            AccessControlContext acc = getAccessControlContext();
            try {
                object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    @Override
                    public Object run() throws Exception {
                            // 呼叫getObject方法獲取bean
                            return factory.getObject();
                        }
                    }, acc);
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            object = factory.getObject(); // 呼叫getObject方法獲取bean
        }
    }
    catch (FactoryBeanNotInitializedException ex) {
        throw new BeanCurrentlyInCreationException(beanName, ex.toString());
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
    }
    if (object == null && isSingletonCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(
                beanName, "FactoryBean which is currently in creation returned null from getObject");
    }
    return object;
}

方法的內容很明確,就是呼叫getObject方法來獲取bean。下面就是BeanPostProcessor的呼叫,關於BeanPostProcessor,我們在之前的文章說描述過它的作用,筆者也會在後續的文章中介紹它的典型應用,AOP和事務等。
AbstractAutowireCapableBeanFactory:

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    /* 呼叫BeanPostProcessor */
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

AbstractAutowireCapableBeanFactory:

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

我們在之前的文章中講述過BeanPostProcessor的註冊,而這裡就會將這些註冊的BeanPostProcessor取出遍歷呼叫它們的postProcessAfterInitialization方法。現在我們回到載入bean的主流程中去:
AbstractBeanFactory:

protected void markBeanAsCreated(String beanName) {
    if (!this.alreadyCreated.contains(beanName)) {
        synchronized (this.mergedBeanDefinitions) {
            if (!this.alreadyCreated.contains(beanName)) {
                // 在建立bean期間有可能有一些元資料的變化,這裡清除合併快取讓BeanDefinition可以重新合併
                clearMergedBeanDefinition(beanName);
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

我們在標籤解析的文章中分析BeanDefinition的註冊時,曾經看到過Spring用hasBeanCreationStarted方法來判斷bean的建立是否已經開始,而判斷的依據alreadyCreated集合就是在這裡放置元素的。下面是單例bean的載入:
DefaultSingletonBeanRegistry:

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName); // 嘗試從快取中獲取
        if (singletonObject == null) {
            // 如果bean正在銷燬丟擲異常
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while 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 + "'");
            }
            /* 單例bean建立前置處理 */
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                /* 呼叫getObject方法獲取bean */
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                /* 單例bean建立後置處理 */
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                /* 新增到快取中 */
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

DefaultSingletonBeanRegistry:

protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

預設的前置處理就是將beanName放入了singletonsCurrentlyInCreation集合中,代表bean正在建立中,而這個集合就是Spring解決迴圈依賴的關鍵,後面我們會說到。預設的後置處理就是將beanName從這個集合中移除掉,代表bean已經建立完成:

DefaultSingletonBeanRegistry:

protected void afterSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

DefaultSingletonBeanRegistry:

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 寫入單例bean快取
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        this.singletonFactories.remove(beanName); // 工廠快取移除掉,bean建立完成工廠就沒用了
        this.earlySingletonObjects.remove(beanName); // 提前建立的bean的標記移除掉
        this.registeredSingletons.add(beanName); // 將beanName放入已經註冊的單例bean的快取
    }
}

新增快取就是對各個相關的快取的處理。下面我們來分析getObject方法獲取bean的過程,這裡的ObjectFactory引數是在呼叫時new的一個匿名內部類,而它的getObject方法中呼叫了createBean方法,我們來分析這個方法:
AbstractAutowireCapableBeanFactory:

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;
    // 鎖定class,根據設定的class屬性或者className來解析class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd); // 克隆BeanDefinition
        mbdToUse.setBeanClass(resolvedClass);
    }
    try {
        /* 驗證以及準備覆蓋的方法 */
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }
    try {
        /* 給BeanPostProcessors一個機會返回一個代理來替代目標bean例項 */
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }
    /* 建立bean */
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

AbstractBeanDefinition:

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    MethodOverrides methodOverrides = getMethodOverrides();
    if (!methodOverrides.isEmpty()) {
        Set<MethodOverride> overrides = methodOverrides.getOverrides();
        synchronized (overrides) {
            for (MethodOverride mo : overrides) {
                /* 準備方法覆蓋 */
                prepareMethodOverride(mo);
            }
        }
    }
}

AbstractBeanDefinition:

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName()); // 根據方法名獲取方法的數量
    if (count == 0) { // 如果方法不存在則丟擲異常
        throw new BeanDefinitionValidationException(
                "Invalid method override: no method with name '" + mo.getMethodName() +
                "' on class [" + getBeanClassName() + "]");
    }
    else if (count == 1) {
        // 如果方法數量為1說明不存在過載方法,將方法過載設定false來避免型別檢查的開銷
        mo.setOverloaded(false);
    }
}

關於MethodOverride,我們在Spring標籤解析的文章中分析lookup-method和replace-method兩個配置的解析時,發現這兩個配置的載入其實就是將配置統一存放在BeanDefinition的methodOverrides屬性中,關於MethodOverride的應用我們後面會詳細介紹,這裡提前判斷的方法是否存在和方法的數量,確定是否有過載方法,如果沒有過載方法後面就不需要做引數的匹配了。
AbstractAutowireCapableBeanFactory:

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            // 解析class,包括從工廠中獲取目標bean的class的處理
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                /* bean例項化前BeanPostProcessor的呼叫,在這裡當前bean可能會被代理替代 */
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    /* 如果在上一步處理過後bean不為null,則在這裡應用BeanPostProcessor的後置處理 */
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

AbstractAutowireCapableBeanFactory:

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法的呼叫
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

BeanPostProcessor的後置處理我們在上文中分析FactoryBean的處理時已經提到過,這裡不再重複。
AbstractAutowireCapableBeanFactory:

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
        throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        /* 建立bean例項 */
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    mbd.resolvedTargetType = beanType;
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // 允許MergedBeanDefinitionPostProcessor修改合併的BeanDefinition
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }
    // 解決迴圈依賴,是否提前曝光,單例並且允許迴圈依賴並且bean正在建立中
    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");
        }
        /* 解決迴圈依賴,在bean初始化完成之前將建立bean的工廠加入到快取中 */
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                // 應用SmartInstantiationAwareBeanPostProcessor,獲取被提前訪問的bean的引用,通常用於處理迴圈依賴
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }
    Object exposedObject = bean;
    try {
        /* 對bean進行填充,將各個屬性值注入,屬性值的注入可能依賴其他bean,則會遞迴初始化依賴的bean */
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            /* 呼叫初始化方法 */
            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);
        }
    }
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        // 如果earlySingletonReference不為空,說明檢測到迴圈依賴
        if (earlySingletonReference != null) {
            // 相等說明bean沒有被改變過,也就是沒有被代理
            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) {
                    // 判斷依賴的bean是否建立完成
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // 不為空表示當前bean建立後依賴的bean並沒有全部建立完成,丟擲異常
                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.");
                }
            }
        }
    }
    try {
        /* 註冊DisposableBean */
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    return exposedObject;
}

這裡提到了Spring的迴圈依賴,簡單說明一下,首先Spring只能解決單例bean的迴圈依賴,非單例的迴圈依賴會丟擲異常。對於單例bean的迴圈依賴,只能解決setter方式的注入依賴,解決的方式上面提到過,就是通過提前暴露一個單例工廠從而使其他bean能引用到該bean。構造方法方式的迴圈依賴無法解決同樣會丟擲異常。
AbstractAutowireCapableBeanFactory:

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 解析class
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    // bean的class訪問修飾符和非public方法訪問許可權的判斷
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }
    if (mbd.getFactoryMethodName() != null)  {
        // 如果工廠方法不為空則使用工廠方法來初始化bean,下文會講解構造方法例項化bean的方式,使用工廠方法例項化bean的方式和構造方法例項化bean的方式非常類似,不再單獨闡述
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            // 如果引數為空則判斷是否解析過構造方法或者工廠方法,並設定解析標記
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    // 如果已經解析過則使用解析過的構造方法進行初始化
    if (resolved) {
        if (autowireNecessary) {
            /* 建構函式自動注入 */
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            /* 使用預設無參構造方法進行初始化 */
            return instantiateBean(beanName, mbd);
        }
    }
    /* 根據引數匹配構造方法 */
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
        /* 建構函式自動注入 */
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    /* 使用預設無參構造方法進行初始化 */
    return instantiateBean(beanName, mbd);
}

AbstractAutowireCapableBeanFactory:

protected BeanWrapper autowireConstructor(
        String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
    /* 構造方法自動注入 */
    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

ConstructorResolver:

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
        Constructor<?>[] chosenCtors, final Object[] explicitArgs) {
    BeanWrapperImpl bw = new BeanWrapperImpl();
    // 初始化BeanWrapper,主要為其織入PropertyEditor屬性編輯器
    this.beanFactory.initBeanWrapper(bw);
    Constructor<?> constructorToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
    if (explicitArgs != null) {
        // 如果傳入了引數列表,則使用傳入的引數進行匹配
        argsToUse = explicitArgs;
    }
    else {
        Object[] argsToResolve = null;
        synchronized (mbd.constructorArgumentLock) {
            constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                // 嘗