【死磕 Spring】—– IOC 之從單例快取中獲取單例 bean

該方法主要是進行檢測工作的，主要如下：

• 若 name 為工廠相關的（以 & 開頭），且 beanInstance 為 NullBean 型別則直接傳回，如果 beanInstance 不為 FactoryBean 型別則丟擲 BeanIsNotAFactoryException 異常。這裡主要是校驗 beanInstance 的正確性。

• 如果 beanInstance 不為 FactoryBean 型別或者 name 也不是與工廠相關的，則直接傳回。這裡主要是對非 FactoryBean 型別處理。

• 如果 BeanDefinition 為空，則從 factoryBeanObjectCache 中載入，如果還是空，則可以斷定 beanInstance 一定是 FactoryBean 型別，則委託 getObjectFromFactoryBean() 方法處理

從上面可以看出 getObjectForBeanInstance() 主要是傳回給定的 bean 實體物件，當然該實體物件為非 FactoryBean 型別，對於 FactoryBean 型別的 bean，則是委託 getObjectFromFactoryBean() 從 FactoryBean 獲取 bean 實體物件。

   protected Object getObjectFromFactoryBean(FactoryBean> factory, String beanName, boolean shouldPostProcess) {
        // 為單例樣式且快取中存在
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
                // 從快取中獲取指定的 factoryBean
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    // 為空，則從 FactoryBean 中獲取物件
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    // 從快取中獲取
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    // **我實在是不明白這裡這麼做的原因，這裡是幹嘛？？？**
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        // 需要後續處理
                        if (shouldPostProcess) {
                            // 若該 bean 處於建立中，則傳回非處理物件，而不是儲存它
                            if (isSingletonCurrentlyInCreation(beanName)) {
                                return object;
                            }
                            // 前置處理
                            beforeSingletonCreation(beanName);
                            try {
                                // 對從 FactoryBean 獲取的物件進行後處理
                                // 生成的物件將暴露給bean取用
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                            finally {
                                // 後置處理
                                afterSingletonCreation(beanName);
                            }
                        }
                        // 快取
                        if (containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        else {
            // 非單例
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

主要流程如下：

• 若為單例且單例 bean 快取中存在 beanName，則進行後續處理（跳轉到下一步），否則則從 FactoryBean 中獲取 bean 實體物件，如果接受後置處理，則呼叫 postProcessObjectFromFactoryBean() 進行後置處理。

• 首先獲取鎖（其實我們在前面篇幅中發現了大量的同步鎖，鎖住的物件都是 this.singletonObjects， 主要是因為在單例樣式中必須要保證全域性唯一），然後從 factoryBeanObjectCache 快取中獲取實體物件 object，若 object 為空，則呼叫 doGetObjectFromFactoryBean() 方法從 FactoryBean 獲取物件，其實內部就是呼叫 FactoryBean.getObject()。

• 如果需要後續處理，則進行進一步處理，步驟如下：

• 若該 bean 處於建立中（isSingletonCurrentlyInCreation），則傳回非處理物件，而不是儲存它

• 呼叫 beforeSingletonCreation() 進行建立之前的處理。預設實現將該 bean 標誌為當前建立的。

• 呼叫 postProcessObjectFromFactoryBean() 對從 FactoryBean 獲取的 bean 實體物件進行後置處理，預設實現是按照原樣直接傳回，具體實現是在 AbstractAutowireCapableBeanFactory 中實現的，當然子類也可以重寫它，比如應用後置處理

• 呼叫 afterSingletonCreation() 進行建立 bean 之後的處理，預設實現是將該 bean 標記為不再在建立中。

• 最後加入到 FactoryBeans 快取中。

該方法應該就是建立 bean 實體物件中的核心方法之一了。這裡我們關註三個方法： beforeSingletonCreation() 、 afterSingletonCreation() 、 postProcessObjectFromFactoryBean()。可能有小夥伴覺得前面兩個方法不是很重要，LZ 可以肯定告訴你，這兩方法是非常重要的操作，因為他們記錄著 bean 的載入狀態，是檢測當前 bean 是否處於建立中的關鍵之處，對解決 bean 迴圈依賴起著關鍵作用。before 方法用於標誌當前 bean 處於建立中，after 則是移除。其實在這篇部落格剛剛開始就已經提到了 isSingletonCurrentlyInCreation() 是用於檢測當前 bean 是否處於建立之中，如下：

    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.contains(beanName);
    }

是根據 singletonsCurrentlyInCreation 集合中是否包含了 beanName，集合的元素則一定是在 beforeSingletonCreation() 中新增的，如下：

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

afterSingletonCreation() 為移除，則一定就是對 singletonsCurrentlyInCreation 集合 remove 了，如下：

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

postProcessObjectFromFactoryBean() 是對從 FactoryBean 處獲取的 bean 實體物件進行後置處理，其預設實現是直接傳回 object 物件，不做任何處理，子類可以重寫，例如應用後處理器。AbstractAutowireCapableBeanFactory 對其提供了實現，如下：

    protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
        return applyBeanPostProcessorsAfterInitialization(object, beanName);
    }

該方法的定義為：對所有的 {@code postProcessAfterInitialization} 進行回呼註冊 BeanPostProcessors，讓他們能夠後期處理從 FactoryBean 中獲取的物件。下麵是具體實現：

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

對於後置處理器，這裡我們不做過多闡述，後面會專門的博文進行詳細介紹，這裡我們只需要記住一點：盡可能保證所有 bean 初始化後都會呼叫註冊的 BeanPostProcessor.postProcessAfterInitialization() 方法進行處理，在實際開發過程中大可以針對此特性設計自己的業務邏輯。

至此，從快取中獲取 bean 物件過程已經分析完畢了。

下麵兩篇部落格分析，如果從單例快取中沒有獲取到單例 bean，則 Spring 是如何處理的？

往

期

精

彩

【死磕 Spring】----- IOC 之 IOC 初始化總結

【死磕 Spring】----- IOC 之解析 bean 標簽：解析自定義標簽

【死磕 Spring】----- IOC 之解析 bean 標簽：constructor-arg、property 子元素

【死磕 Spring】—– IOC 之解析 bean 標簽：meta、lookup-method、replace-method）

【死磕 Spring】----- IOC 之解析 bean 標簽：開啟解析行程

【死磕 Spring】----- IOC 之 獲取 Document 物件

【死磕 Spring】----- IOC 之 註冊 BeanDefinition

【死磕 Spring】----- IOC 之 獲取驗證模型

【死磕 Spring】----- IOC 之 Spring 統一資源載入策略

【死磕 Spring】----- IOC 之深入理解 Spring IoC

END

我是 Java 技術驛站，感謝有你

>>>>>> 加群交流技術 <<<<<<

長按二維碼向我轉賬

受蘋果公司新規定影響，微信 iOS 版的贊賞功能被關閉，可透過二維碼轉賬支援公眾號。

閱讀原文


微信掃一掃
使用小程式
即將開啟""小程式
取消
開啟