前言
上一篇bean加載的文章分析了bean加載核心入口AbstractBeanFactory#doGetBean(String, Class, Object[], boolean)的上半部分舵变，該部分主要邏輯在顯式調(diào)用getBean時會被執(zhí)行，更具體的來說是獲得單例對象和通過自定義FactoryBean創(chuàng)建對象時會執(zhí)行上半部分兜蠕；而下半部分會在初始化和獲得prototype多例對象時被執(zhí)行挽懦，本文就是對這下半部分做深入分析

為了分析方便，我們再截取一次下半部分內(nèi)容的代碼舆声，代碼清單1

        //    (1)
    if (isPrototypeCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }

    //    (2)
    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);
        }
    }
        //    (3)
    if (!typeCheckOnly) {
        markBeanAsCreated(beanName);
    }

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

        //    (5)
        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
            for (String dependsOnBean : dependsOn) {
                getBean(dependsOnBean);
                registerDependentBean(dependsOnBean, beanName);
            }
        }
                //    (6)
        // 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);
        }
                //    (7)
        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);
        }
                //    (8)
        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;
    }

我們都知道對于scope = "prototype"的對象來說，Spring是不會在真正使用該對象前創(chuàng)建它的腋粥，這一特性意味著Spring不能解決prototype類型變量的循環(huán)依賴問題，道理很簡單展辞，當(dāng)我們真正使用prototype對象時肯定要求內(nèi)部的依賴關(guān)系都建立完畢罗珍，而循環(huán)依賴的存在使這種對象間關(guān)系無法建立覆旱，必定就會拋出BeanCurrentlyInCreationException
上一篇文中說過，Spring使用“三級緩存”的形式能部分解決循環(huán)依賴問題噪沙，我們在這里就可以總結(jié)下“部分”指哪些情況：Spring能夠解決singleton下使用setter方式形成的循環(huán)依賴問題，不能夠解決singleton下使用構(gòu)造器形成的循環(huán)依賴朋腋，以及prototype下的循環(huán)依賴。第一種能解決的原因是Spring解析之IoC：bean的加載（一）中分析過的緩存earlySingletonObjects穷绵，當(dāng)我們設(shè)置允許早期對象引用暴露allowEarlyReference后，Spring會將通過構(gòu)造器創(chuàng)建出來的目养，尚未調(diào)用setter建立依賴關(guān)系的單例對象放入earlySingletonObjects中，當(dāng)我們需要一組存在循環(huán)依賴的對象時直接從里面取出每個對象手動建立依賴關(guān)系即可努释。但是如果是構(gòu)造器形成的循環(huán)依賴伐蒂，連創(chuàng)建早期對象都不可能，自然就沒法解決循環(huán)依賴問題了
重溫了Spring解決循環(huán)依賴的手段后看標(biāo)注1缕减，如果獲取的是prototype類型的對象且該對象正在創(chuàng)建中烛卧，必然就發(fā)生了循環(huán)依賴，直接拋出異常局雄。標(biāo)注2是存在父子容器時加載bean的代碼邏輯蜈漓，如果大家用過SpringMVC相信對父子容器都不陌生融虽，大多數(shù)情況下Web層的SpringMVC都作為Service層和Dao層Spring容器的子容器存在，子容器可以訪問父容器中的bean巍佑，反過來則不行萤衰，當(dāng)子容器加載bean時首先判斷自身容器中是否存在同名的bean，存在直接獲得筹吐，不存在就去父容器中查找該名稱的bean
標(biāo)注2的邏輯就是這樣丘薛，判斷如果存在父容器，且當(dāng)前容器中不存在beanName對應(yīng)的bean就調(diào)用父容器parentBeanFactory的getBean(String, Object...)希坚，又來了一個大循環(huán)裁僧。標(biāo)注3中typeCheckOnly表示獲得bean的目的是否是為了類型檢查，而不是真正使用這個bean获洲，絕大部分情況我們當(dāng)時是要用bean啦贡珊，這時就要調(diào)用markBeanAsCreated(String)將創(chuàng)建bean的行為做記錄爱致，記錄實際上就是將beanName打上已經(jīng)創(chuàng)建的標(biāo)識放入Map<String, Boolean> alreadyCreated中
標(biāo)注4在Spring解析之IoC：bean的加載（一）中已經(jīng)說過蒜鸡，如果<bean>存在父子關(guān)系(注意不是容器的父子關(guān)系)叶沛，getMergedLocalBeanDefinition(String)會將父子關(guān)系的<bean>信息融合在RootBeanDefinition中

圖1. 檢查融合后的BeanDefinition

checkMergedBeanDefinition(RootBeanDefinition, String, Object[])排除了兩種情況下bean的創(chuàng)建：1. <bean>存在abstract屬性判帮；2. scope = singleton且參數(shù)args有值的情況。第一種情況很好理解晌畅，都抽象了還創(chuàng)建毛線啊抗楔，而要想通第二種情況我們需要追根溯源看看args來自哪里。顯式調(diào)用getBean獲得對象有一個重載方法Object getBean(String, Object...)入热，這里的args就是第二個參數(shù)勺良，該重載方法提供的目的是解決一個場景：初始化只存在有參構(gòu)造的類，且參數(shù)要在獲取時動態(tài)指定尾组。創(chuàng)建只存在有參構(gòu)造器的類很容易讳侨，直接<constrcut-arg>指定就好潮峦，但是要每次創(chuàng)建的參數(shù)值不同再用該方法很明顯就掛了啊忱嘹，還是Object getBean(String, Object...)好使。這也很好的解釋了為什么args不能和singleton共存础米，因為args說明可變性屁桑，singleton說明唯一性，相互沖突
標(biāo)注5涉及到一個之前沒有講過的<bean>屬性depends-on乌叶，該屬性的作用是讓depends-on內(nèi)的對象先于<bean>所代表的對象創(chuàng)建准浴，但這兩組對象并不要求有真正的依賴關(guān)系乐横，我們舉個例子，創(chuàng)建三個類Man催什、Woman和Family蒲凶，Family配置depends-on前兩個類

圖2. Man

圖3. Woman

圖4. Family

圖5. Man瓤球、Woman和Family相關(guān)配置

圖6. depends-on例子運行結(jié)果

圖7. 處理singleton對象邏輯

圖8. DefaultSingletonBeanRegistry的getSingleton(String, ObjectFactory<?>)

圖9. DefaultSingletonBeanRegistry的beforeSingletonCreation(String)

圖10. DefaultSingletonBeanRegistry的addSingleton(String, Object)

圖11. 處理prototype對象邏輯

圖12. AbstractBeanFactory的beforePrototypeCreation(String)

圖13. 處理其他scope對象邏輯

后記
本文將getBean中最后零碎的邏輯清理干凈就是為了將核心創(chuàng)建bean作為一個整體分析巍棱，即便如此由于Spring涉及的內(nèi)容太多拉盾，createBean依然比較龐大和雜亂捉偏，不管怎么說我們已經(jīng)吹響了最后的沖鋒號夭禽，年前必定攻下獲得bean這座山頭讹躯，加油！