拜託，別再問我Spring是如何解決循環依賴了！

前言

• 文章首發於微信公衆號 Spring如何解決循環依賴？
• 前幾天發表的文章 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 屬性依賴）分如下步驟執行：

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 三級緩存的應用完美的解決了循環依賴的問題，下面是循環依賴的解決流程圖。