閱讀須知

• 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) {
                // 嘗