前言
看過Spring解析前兩篇文章的讀者知道领迈，之前分析的思路一直都源自ClassPathXmlApplicationContext的初始化，但該類的初始化還未分析完畢為什么突然切成bean的加載呢暇昂？實際上在ClassPathXmlApplicationContext初始化剩下的部分中多次進行了bean的加載和獲取，當(dāng)然該流程是可以放在初始化過程中一并分析的，但bean加載的流程比較復(fù)雜，如果將該流程和初始化過程放在一起無疑加重了原本就難于理解的邏輯，此外惰匙，從容器中獲取對象是Spring最常用的功能技掏，單獨的剝離分析更加有利于整體脈絡(luò)的構(gòu)建，因此另開一文單獨講解项鬼。bean的加載由兩到三篇文章構(gòu)成哑梳，第一篇也就是本文，以顯式調(diào)用getBean為切入點

在首篇開始的例子中可知绘盟，通常我們手動獲取bean使用getBean方法鸠真，該方法有幾種重載形式悯仙，最普遍的為Obejct getBean(String)，根據(jù)beanName得到實際類型為beanName對應(yīng)bean實例的Object對象吠卷；另一種是我喜歡用的T getBean(Class<T>)赏寇，這種方式省去了強轉(zhuǎn)過程营搅。不管任何一種獲取bean的方式都殊途同歸，我們先以Obejct getBean(String)為模板進行分析

圖1. AbstractApplicationContext中獲取bean方法

圖2. AbstractBeanFactory中獲取bean的一系列方法

protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        //      (1)
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        //      (2)
        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 + "'");
                }
            }
            //      (3)
            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();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                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);
                }
            }

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        getBean(dependsOnBean);
                        registerDependentBean(dependsOnBean, beanName);
                    }
                }

                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        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 {
                    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>() {
                            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;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        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;
    }

從整體看上面的代碼可根據(jù)最頂層的if/else分為上下兩部分搞坝，上半部分在調(diào)用getBean(String)時進入搔谴，下半部分在new ClassPathXmlApplicationContext(String[])時就會隱式執(zhí)行，下半部分進行首次初始化桩撮，上半部分從緩存中獲取敦第，通常情況隱式執(zhí)行早于顯示調(diào)用，雖然真實情況下存在誰先誰后等“時序”因素距境，但為了分析方便申尼，清楚表述，我在文章中都盡可能不考慮”時序“的影響垫桂，只關(guān)注邏輯流程师幕，由于執(zhí)行邏輯比較復(fù)雜，我們一點點分析诬滩。標(biāo)注1將name進行了規(guī)范化處理霹粥，這里的name存在多種可能：1.普通的id/name；2.bean的昵稱疼鸟；3.FactoryBean對應(yīng)的id/name后控，三種情況對應(yīng)三種不同的規(guī)范化方式，第一種不做處理直接返回空镜；第二種根據(jù)昵稱從SimpleAliasRegistry中的成員變量Map<String, String> aliasMap中獲得昵稱對應(yīng)的真實id/name返回浩淘，至于昵稱是什么時候放入aliasMap的，在Spring解析之IoC：<bean>解析及Bean的注冊的最后進行了bean的注冊吴攒，該方法的是由BeanDefinitionReaderUtils調(diào)用的

圖3. alias的注冊

下劃線處就是bean注冊的流程张抄，而紅框內(nèi)就是保存所有bean對應(yīng)昵稱的過程，根據(jù)我們之前給過的DefaultListableBeanFactory類圖可知洼怔，這里的registry就是DefaultListableBeanFactory署惯，但registerAlias(String, String)定義在父類SimpleAliasRegistry中，所有的alias就放在了該類的成員變量aliasMap中镣隶。至于第三種情況我們需要先知道FactoryBean的用法和用途极谊，FactoryBean可以看成一個實現(xiàn)了FactoryBean<T>接口的特殊bean诡右，它既可以是一個普通的bean，也可以成為生產(chǎn)另一個bean的工廠轻猖，當(dāng)創(chuàng)建一個FactoryBean后帆吻，我們可以通過getBean("FactoryBean的id/name")得到該FactoryBean生產(chǎn)的普通bean對象，如果就想得到該FactoryBean實例行不行呢蜕依？答案當(dāng)然是可以的桅锄，我們需要這么寫getBean("&FactoryBean的id/name")，下面我們舉個例子說明样眠，首先寫一個實現(xiàn)FactoryBean<T>的工廠Bean

圖4. 生產(chǎn)Student的FactoryBean

接下來在配置文件上加上對該類的配置友瘤，注意我沒有對Student類進行XML配置

圖5. 工廠Bean的配置

最后我們獲得Student實例以及對應(yīng)的生產(chǎn)工廠實例

圖6. 獲得Student實例和StudentFactoryBean實例

代碼清單1 標(biāo)注2根據(jù)beanName獲得單例對象，但這里的單例對象不一定就是我們在配置文件中定義的bean的實例檐束，為什么這么說我們進入方法看看

圖7. DefaultSingletonBeanRegistry的Object getSingleton(String, boolean)

圖中標(biāo)記出了三個不同的“緩存”辫秧，所謂的緩存就是定義在DefaultSingletonBeanRegistry的三個成員變量，該類和DefaultListableBeanFactory是父子關(guān)系被丧，借用其他文章對這三個對象的稱謂盟戏，singletonObjects為一級緩存，保存beanName和bean實例的對應(yīng)關(guān)系甥桂；earlySingletonObjects是二級緩存柿究，也保存了beanName和bean的對應(yīng)關(guān)系。我們都知道假設(shè)A對象在初始化時依賴B對象黄选，Spring會在A對象初始化前先將B對象初始化蝇摸，本文將這種實例化完成并形成依賴關(guān)系的整個過程稱為完全初始化；將沒有建立依賴關(guān)系办陷，僅僅實例化完成的過程稱為不完全初始化貌夕，那這時解釋singletonObjects和earlySingletonObjects的區(qū)別就很簡單了，前者保存了完全初始化的實例映射民镜，后者保存未完全初始化的實例映射啡专；最后一個變量singletonFactories是三級緩存，保存了beanName和接口ObjectFactory實現(xiàn)類的映射制圈，現(xiàn)在問題又來了ObjectFactory是什么東東们童？我們可以將其理解為生產(chǎn)對象的工廠，和上面剛說到的FactoryBean有幾分相似鲸鹦，之后我們會看到該類的具體實現(xiàn)和具體用法
和平時的認(rèn)知一樣慧库，三級緩存的調(diào)用依次深入，且相互排斥亥鬓，即一個beanName只會存在于一個緩存中完沪，設(shè)置如此復(fù)雜的邏輯目的是盡可能的解決循環(huán)依賴問題域庇。解釋完后再看代碼就很清楚了嵌戈，先根據(jù)beanName從一級緩存中獲取bean覆积，如果沒有取到并且該對象正在創(chuàng)建isSingletonCurrentlyInCreation(String)，就去二級緩存中查找熟呛。什么叫該對象正在創(chuàng)建呢宽档？該對象正在創(chuàng)建又和循環(huán)依賴什么關(guān)系呢？舉個例子：A對象依賴B對象庵朝，B對象依賴A對象吗冤，在創(chuàng)建A對象時要先創(chuàng)建B對象，在創(chuàng)建B對象時依賴A對象九府，A創(chuàng)建了一半等待B對象椎瘟，此時A對象的狀態(tài)就是正在創(chuàng)建，對于B對象也是一樣的侄旬。如果二級緩存中依然沒有肺蔚，且允許早期引用標(biāo)識allowEarlyReference = true，就會從三級緩存中得到ObjectFactory進而創(chuàng)建出最終的對象儡羔，創(chuàng)建完成后會將該對象存放在二級緩存中
代碼清單1 標(biāo)注3才是獲得真正bean的方法

圖8. AbstractBeanFactory的getObjectForBeanInstance(Object, String, String, RootBeanDefinition)

圖9. AbstractBeanFactory的getMergedLocalBeanDefinition(String)

繁瑣的Spring又出現(xiàn)一個緩存mergedBeanDefinition，key為標(biāo)簽id/name嵌纲，value保存對應(yīng)RootBeanDefinition俘枫，存在RootBeanDefinition直接返回，但要注意點逮走，經(jīng)過上兩篇文章的分析崩哩，此時在DefaultListableBeanFactory中的緩存beanDefinitionMap中已經(jīng)存在beanName和BeanDefinition的映射了，所以圖中的getBeanDefinition(String)實際上會返回beanName對應(yīng)的GenericBeanDefinition對象言沐，最后調(diào)用RootBeanDefinition getMergedBeanDefinition(String, BeanDefinition, BeanDefinition)邓嘹，上面說過<bean>可能存在父子關(guān)系，在該方法中如果當(dāng)前BeanDefinition為子對象险胰，會根據(jù)parentName得到對應(yīng)的父BeanDefinition汹押，并通過遞歸調(diào)用的方式將父BeanDefinition融合進子BeanDefinition，最后包裝成RootBeanDefinition返回起便，該方法中又是一坨惡心的邏輯棚贾，這里就不挨個細(xì)聊，有興趣的讀者可以繼續(xù)深入榆综。圖8標(biāo)注5是根據(jù)FactoryBean名稱獲取bean的入口

圖10. 從FactoryBean獲得對應(yīng)的bean

圖11. FactoryBeanRegistrySupport的Object doGetObjectFromFactoryBean(FactoryBean<?>, String, boolean)

圖12. 自定義BeanPostProcessorImpl

圖13. Student對象

圖14. bean后處理例子順序問題

圖14. BeanPostProcessor接口注解

圖15. AbstractAutowireCapableBean的Object applyBeanPostProcessorsAfterInitialization(Object, String)