Spring如何解決循環依賴，你真的懂了？

導讀

  • 這個就是典型的構造器依賴，詳情請看上面兩篇文章，這裡不再詳細贅述了。本篇文章將會從源碼深入解析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屬性依賴）分以下步驟執行：
  1. A依次執行「doGetBean」、查詢快取、「createBean」創建實例，實例化完成放入三級快取singletonFactories中，接著執行「populateBean」方法裝配屬性，但是發現有一個屬性是B的對象。
  2. 因此再次調用doGetBean方法創建B的實例，依次執行doGetBean、查詢快取、createBean創建實例，實例化完成之後放入三級快取singletonFactories中，執行populateBean裝配屬性，但是此時發現有一個屬性是A對象。
  3. 因此再次調用doGetBean創建A的實例，但是執行到getSingleton查詢快取的時候，從三級快取中查詢到了A的實例(早期引用，未完成屬性裝配)，此時直接返回A，不用執行後續的流程創建A了，那麼B就完成了屬性裝配，此時是一個完整的對象放入到一級快取singletonObjects中。
  4. B創建完成了，則A自然完成了屬性裝配，也創建完成放入了一級快取singletonObjects中。
  • Spring三級快取的應用完美的解決了循環依賴的問題，下面是循環依賴的解決流程圖。

Tags:

VirMach 便宜 VPS