【Spring】詳解Spring中Bean的加載

以前寫過bean的解析，這篇來說講bean的加載，加載要比bean的解析複雜些， 該文以前在小編原文中有發表過，要看原文的能夠直接點擊原文查看， 從以前的例子開始，Spring中加載一個bean的方式：

TestBean bean = factory.getBean("testBean");

來看看getBean(String name)方法源碼，

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

該getBean(String name)方法位於AbstractBeanFactory抽象類中，AbstractBeanFactory與XmlBeanFactory類關係能夠看下圖：

接下去跟進doGetBean()方法源碼：

protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
    // 提取beanName
    final String beanName = transformedBeanName(name);
    Object 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 + "'");
            }
        }
        // 返回實例，有時存在如BeanFactory這樣狀況時並非直接返回實例自己而是返回指定方法返回的實例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 若是在全部已經加載的類中沒有beanName則會嘗試從parentBeanFactory中檢測
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            // 到BeanFactory查找
            if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        // 若是不是隻作類型檢查則是建立bean
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // 將存儲XML配置文件的GernericBeanDefinition轉換成RootBeanDefinition，若是BeanName是子Bean的話會合並父類的相關屬性
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            // 若是存在依賴的話要遞歸實例化依賴的bean
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) {
                    if (isDependent(beanName, dependsOnBean)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                    }
                    registerDependentBean(dependsOnBean, beanName);
                    getBean(dependsOnBean);
                }
            }

            // Create bean instance.
            // 依賴的bean實例化完後就能夠實例化mbd了
            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);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                // 在對應的scope上實例化bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    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;
        }
    }

    // 檢查須要的類型是否符合實例bean的實際類型
    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;
}

整個bean加載的過程步驟相對繁瑣，主要步驟有如下幾點：

1. 轉換beanName
   要知道平時開發中傳入的參數name可能只是別名，也多是FactoryBean，因此須要進行解析轉換，通常會進行如下解析：
   （1）消除修飾符，好比name="&test"，會去除&使name="test"；
   （2）取alias表示的最後的beanName，好比別名test01指向名稱爲test02的bean則返回test02。

2. 從緩存中加載實例
   實例在Spring的同一個容器中只會被建立一次，後面再想獲取該bean時，就會嘗試從緩存中獲取；若是獲取不到的話再從singletonFactories中加載。

3. 實例化bean
   緩存中記錄的bean通常只是最原始的bean狀態，這時就須要對bean進行實例化。若是獲得的是bean的原始狀態，但又要對bean進行處理，這時真正須要的是工廠bean中定義的factory-method方法中返回的bean，上面源碼中的getObjectForBeanInstance就是來完成這個工做的。

4. 檢測parentBeanFacotory
   從源碼能夠看出若是緩存中沒有數據會轉到父類工廠去加載，源碼中的!containsBeanDefinition(beanName)就是檢測若是當前加載的xml配置文件中不包含beanName所對應的配置，就只能到parentBeanFacotory去嘗試加載bean。

5. 存儲XML配置文件的GernericBeanDefinition轉換成RootBeanDefinition以前的文章介紹過XML配置文件中讀取到的bean信息是存儲在GernericBeanDefinition中的，但Bean的後續處理是針對於RootBeanDefinition的，因此須要轉換後才能進行後續操做。

6. 初始化依賴的bean
   這裏應該比較好理解，就是bean中可能依賴了其餘bean屬性，在初始化bean以前會先初始化這個bean所依賴的bean屬性。

7. 建立bean
   Spring容器根據不一樣scope建立bean實例。
   整個流程就是如此，下面會講解一些重要步驟的源碼。

上面有提到，單例在Spring中的同一容器中只會被建立一次，後面再獲取bean的話會直接從緩存中獲取，這裏是嘗試加載，先從緩存中加載，再次就是從singletonFactories中加載；由於在bean中可能會在依賴注入，要避免循環依賴，Spring建立bean時會不等bean建立完成就會將建立該bean的ObjectFactory提早曝光加入到緩存中，但下一個bean建立時要依賴上個bean的話，就直接使用ObjectFacotry。

@Override
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);  // true表示容許早期依賴
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 嘗試從緩存獲取實例
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 若該bean正在加載則不處理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    // 存入到緩存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
/* 這兩個方法在DefaultSingletonBeanRegistry類中 */

從源碼能夠看出這個方法先嚐試從singletonObjects中獲取實例，若是獲取不到值就從earlySingletonObject中去獲取，若是再獲取不到的話則到singletonFactories裏獲取beanName對應的ObjectFactory，再調用這個ObjectFactory的getObject來建立bean，並放到earlySingletonObject中，而且從singletonFactories裏remove掉這個ObjectFactory。這裏有幾個存儲bean的不一樣map：
-singletonObjects：保存BeanName和建立bean實例之間的關係。
-singletonFactories：保存BeanName和建立bean實例的工廠之間的關係。
-earlySingletonObject：保存BeanName和建立bean實例之間的關係，與-singletonObjects不一樣的是當一個單例bean被放到裏面後，那當bean在建立過程當中，就能夠經過getBean方法獲取到，能夠用來檢測循環引用。
-registeredSingletons：保存當前全部已註冊的bean。

若是上面緩存中不存在已經加載的單例bean就要從新開始bean的加載過程了，Spring中使用getSingleton重載方法實現bean的加載過程。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        // 先檢查bean是否已經加載
        Object singletonObject = this.singletonObjects.get(beanName);
        // 若是空才進行singleton的bean的初始化
        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 {
                // 初始化bean
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                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;
                }
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 存入緩存
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

這段代碼使用了回調方法，使程序能夠在單例建立的先後作一些準備及處理操做，真正的獲取單例bean的方法其實並非在這個方法實現的，而是在ObjectFactory類型的實例singletonFactory中實現的。

下面準備建立bean

看看createBean()方法源碼（該方法在AbstractAutowireCapableBeanFactory類中）：

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
        throws BeanCreationException {

    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    // 鎖定class，根據設置的class屬性或根據className來解析Class
    resolveBeanClass(mbd, beanName);

    // 驗證和準備覆蓋的方法
    try {
        mbd.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 用BeanPostProcessors返回代理來替代真正的實例
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }

    Object beanInstance = doCreateBean(beanName, mbd, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

從createBean()方法源碼能夠看出主要作了如下操做：

1. 根據設置的class屬性或根據className來解析Class；
2. 對覆蓋進行標記並驗證，在Spring配置中是存在lookup-mothod和replace-method的，這兩個配置的加載其實就是將配置統一存放在BeanDefinition中的methodOverrides屬性裏，這個方法的操做也就是針對於這兩個配置的；
3. 應用初始化前的後處理器，最後建立bean。
   在createBean()方法裏執行完resolveBeforeInstantiation方法後，若是建立了代理且不爲空的話就直接返回，不然須要進行常規bean的建立，這個建立過程是在doCreateBean中完成的，跟進源碼：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // Instantiate the bean.
    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);

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }

    // 檢測循環依賴，是否須要提前曝光
    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初始化完成前將建立實例的ObjectFactory加入工廠
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                // 對bean再次依賴引用
                // AOP也是在這裏將advice動態織入bean中，若沒有則直接返回bean，不作處理
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 填充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) {
            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 {
        // 依據scopse註冊bean
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

上面源碼完成的操做能夠歸納爲如下幾點：

1. 開始是單例的話要先清除緩存；
2. 實例化bean，將BeanDefinition轉換爲BeanWrapper；
3. 使用MergedBeanDefinitionPostProcessor，Autowired註解就是經過此方法實現類型的預解析；
4. 解決循環依賴問題；
5. 填充屬性，將屬性填充到bean實例中；
6. 註冊DisposableBean；
7. 建立完成並返回

接下來建立bean實例，看createBeanInstance()方法：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 解析class
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    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)  {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // Shortcut when re-creating the same bean...
    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);
    }

    // No special handling: simply use no-arg constructor.
    return instantiateBean(beanName, mbd);
}

能夠看出若是在RootBeanDefinition中存在factoryMethodName屬性，或者說配置文件中配置了factory-method，那麼Spring會嘗試使用instantiateUsingFactoryMethod(beanName, mbd, args)方法根據RootBeanDefinition中的配置生成bean實例。
再解析構造方法並進行實例化，Spring會根據參數及類型判斷使用哪一個構造方法再進行實例化。判斷調用哪一個構造方法的過程會採用緩存機制，若是已經解析過則不須要重複解析而是從RootBeanDefinition中的屬性resolvedConstructorOrFactoryMethod緩存的值去取，否則則須要再次解析。

建立bean後接下來就進行屬性注入，屬性注入的操做在populateBean()方法中，跟進源碼：

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();

    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;

    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;
    }

    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);

    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);
        }
    }

    applyPropertyValues(beanName, mbd, bw, pvs);
}

在populateBean方法的中的主要處理流程：

1. InstantiationAwareBeanPostProcessor處理器的postProcessAfterInstantiation方法控制程序是否繼續填充屬性；
2. 根據注入類型提取依賴的bean，並存入PropertyValues中；
3. 應用InstantiationAwareBeanPostProcessor處理器的postProcessPropertyValues方法對屬性在填充前再次處理，主要仍是驗證屬性；
4. 將全部PropertyValues中的屬性填充到BeanWrapper中。

最後初始化bean

學過Spring的都知道bean配置時有一個init-method屬性，這個屬性的做用是在bean實例化前調用init-method指定的方法進行須要的實例化操做，如今就進入這個方法了；Spring中程序已經執行過bean的實例化，而且進行了屬性的填充，而就在這時將會調用用戶設定的初始化方法。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        // 特殊bean處理
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

最後加載完Bean並執行完初始化操做後，一個bean的加載基本就結束了。