Spring解決迴圈依賴，你真的懂了嗎？

導讀前幾天發表的文章 "SpringBoot多數據源動態切換" 和 "SpringBoot整合多數據源的巨坑" 中，提到了一個坑就是動態數據源添加@Primary介面就會造成迴圈依賴異常，如下圖：這個就是典型的構造器依賴，詳情請看上面兩篇文章，這裡不再詳細贅述了。本篇文章將會從源碼深入解析Spr ...

導讀

前幾天發表的文章SpringBoot多數據源動態切換和SpringBoot整合多數據源的巨坑中，提到了一個坑就是動態數據源添加@Primary介面就會造成迴圈依賴異常，如下圖：

微信所有碼猿技術專欄

這個就是典型的構造器依賴，詳情請看上面兩篇文章，這裡不再詳細贅述了。本篇文章將會從源碼深入解析Spring是如何解決迴圈依賴的？為什麼不能解決構造器的迴圈依賴？

什麼是迴圈依賴

簡單的說就是A依賴B，B依賴C，C依賴A這樣就構成了迴圈依賴。

微信搜索碼猿技術專欄

迴圈依賴分為構造器依賴和屬性依賴，眾所周知的是Spring能夠解決屬性的迴圈依賴（set註入）。下文將從源碼角度分析Spring是如何解決屬性的迴圈依賴。

思路

如何解決迴圈依賴，Spring主要的思路就是依據三級緩存，在實例化A時調用doGetBean，發現A依賴的B的實例，此時調用doGetBean去實例B，實例化的B的時候發現又依賴A，如果不解決這個迴圈依賴的話此時的doGetBean將會無限迴圈下去，導致記憶體溢出，程式奔潰。spring引用了一個早期對象，並且把這個"早期引用"並將其註入到容器中，讓B先完成實例化，此時A就獲取B的引用，完成實例化。

三級緩存

Spring能夠輕鬆的解決屬性的迴圈依賴正式用到了三級緩存，在AbstractBeanFactory中有詳細的註釋。

    /**一級緩存，用於存放完全初始化好的 bean，從該緩存中取出的 bean 可以直接使用*/
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /**三級緩存 存放 bean 工廠對象，用於解決迴圈依賴*/
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /**二級緩存 存放原始的 bean 對象（尚未填充屬性），用於解決迴圈依賴*/
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

一級緩存：singletonObjects，存放完全實例化屬性賦值完成的Bean，直接可以使用。
二級緩存：earlySingletonObjects，存放早期Bean的引用，尚未屬性裝配的Bean
三級緩存：singletonFactories，三級緩存，存放實例化完成的Bean工廠。

開擼

先上一張流程圖看看Spring是如何解決迴圈依賴的

微信搜索碼猿技術專欄

上圖標記藍色的部分都是涉及到三級緩存的操作，下麵我們一個一個方法解析

【1】 getSingleton(beanName)：源碼如下：

        //查詢緩存
        Object sharedInstance = getSingleton(beanName);
        //緩存中存在並且args是null
        if (sharedInstance != null && args == null) {
            //.......省略部分代碼
            
            //直接獲取Bean實例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        
    //getSingleton源碼，DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //先從一級緩存中獲取已經實例化屬性賦值完成的Bean
        Object singletonObject = this.singletonObjects.get(beanName);
        //一級緩存不存在，並且Bean正處於創建的過程中
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                //從二級緩存中查詢，獲取Bean的早期引用，實例化完成但是未賦值完成的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;
    }

從源碼可以得知，doGetBean最初是查詢緩存，一二三級緩存全部查詢，如果三級緩存存在則將Bean早期引用存放在二級緩存中並移除三級緩存。（升級為二級緩存）

【2】addSingletonFactory：源碼如下


        //中間省略部分代碼。。。。。
        //創建Bean的源碼，在AbstractAutowireCapableBeanFactory#doCreateBean方法中
        if (instanceWrapper == null) {
            //實例化Bean
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        //允許提前暴露
        if (earlySingletonExposure) {
            //添加到三級緩存中
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        try {
            //屬性裝配，屬性賦值的時候，如果有發現屬性引用了另外一個Bean，則調用getBean方法
            populateBean(beanName, mbd, instanceWrapper);
            //初始化Bean，調用init-method，afterproperties方法等操作
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        }

//添加到三級緩存的源碼，在DefaultSingletonBeanRegistry#addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {
            //一級緩存中不存在
            if (!this.singletonObjects.containsKey(beanName)) {
                //放入三級緩存
                this.singletonFactories.put(beanName, singletonFactory);
                //從二級緩存中移除，
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

從源碼得知，Bean在實例化完成之後會直接將未裝配的Bean工廠存放在三級緩存中，並且移除二級緩存

【3】addSingleton：源碼如下：

//獲取單例對象的方法，DefaultSingletonBeanRegistry#getSingleton
//調用createBean實例化Bean
singletonObject = singletonFactory.getObject();

//。。。。中間省略部分代碼  

//doCreateBean之後才調用，實例化，屬性賦值完成的Bean裝入一級緩存，可以直接使用的Bean
addSingleton(beanName, singletonObject);

//addSingleton源碼，在DefaultSingletonBeanRegistry#addSingleton方法中
protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            //一級緩存中添加
            this.singletonObjects.put(beanName, singletonObject);
            //移除三級緩存
            this.singletonFactories.remove(beanName);
            //移除二級緩存
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

總之一句話，Bean添加到一級緩存，移除二三級緩存。

擴展

【1】為什麼Spring不能解決構造器的迴圈依賴？

從流程圖應該不難看出來，在Bean調用構造器實例化之前，一二三級緩存並沒有Bean的任何相關信息，在實例化之後才放入三級緩存中，因此當getBean的時候緩存並沒有命中，這樣就拋出了迴圈依賴的異常了。

【2】為什麼多實例Bean不能解決迴圈依賴？

多實例Bean是每次創建都會調用doGetBean方法，根本沒有使用一二三級緩存，肯定不能解決迴圈依賴。

總結

根據以上的分析，大概清楚了Spring是如何解決迴圈依賴的。假設A依賴B，B依賴A（註意：這裡是set屬性依賴）分以下步驟執行：

A依次執行doGetBean、查詢緩存、createBean創建實例，實例化完成放入三級緩存singletonFactories中，接著執行populateBean方法裝配屬性，但是發現有一個屬性是B的對象。
因此再次調用doGetBean方法創建B的實例，依次執行doGetBean、查詢緩存、createBean創建實例，實例化完成之後放入三級緩存singletonFactories中，執行populateBean裝配屬性，但是此時發現有一個屬性是A對象。
因此再次調用doGetBean創建A的實例，但是執行到getSingleton查詢緩存的時候，從三級緩存中查詢到了A的實例(早期引用，未完成屬性裝配)，此時直接返回A，不用執行後續的流程創建A了，那麼B就完成了屬性裝配，此時是一個完整的對象放入到一級緩存singletonObjects中。
B創建完成了，則A自然完成了屬性裝配，也創建完成放入了一級緩存singletonObjects中。