在關(guān)于Spring的面試中，我們經(jīng)常會(huì)被問到一個(gè)問題，就是Spring是如何解決循環(huán)依賴的問題的。這個(gè)問題算是關(guān)于Spring的一個(gè)高頻面試題，因?yàn)槿绻豢桃庋凶x，相信即使讀過源碼，面試者也不一定能夠一下子思考出個(gè)中奧秘。本文主要針對這個(gè)問題，從源碼的角度對其實(shí)現(xiàn)原理進(jìn)行講解。

1. 過程演示

關(guān)于Spring bean的創(chuàng)建，其本質(zhì)上還是一個(gè)對象的創(chuàng)建，既然是對象，讀者朋友一定要明白一點(diǎn)就是，一個(gè)完整的對象包含兩部分：當(dāng)前對象實(shí)例化和對象屬性的實(shí)例化。在Spring中，對象的實(shí)例化是通過反射實(shí)現(xiàn)的，而對象的屬性則是在對象實(shí)例化之后通過一定的方式設(shè)置的。這個(gè)過程可以按照如下方式進(jìn)行理解：

理解這一個(gè)點(diǎn)之后，對于循環(huán)依賴的理解就已經(jīng)幫助一大步了，我們這里以兩個(gè)類A和B為例進(jìn)行講解，如下是A和B的聲明： 

@Component  
public class A {  
  private B b;  
  public void setB(B b) {  
    this.b = b;  
  }  
}  

@Component  
public class B {  
  private A a;  
  public void setA(A a) {  
    this.a = a;  
  }  
} 

可以看到，這里A和B中各自都以對方為自己的全局屬性。這里首先需要說明的一點(diǎn)是，Spring實(shí)例化bean是通過ApplicationContext.getBean()方法來進(jìn)行的。如果要獲取的對象依賴了另一個(gè)對象，那么其首先會(huì)創(chuàng)建當(dāng)前對象，然后通過遞歸的調(diào)用ApplicationContext.getBean()方法來獲取所依賴的對象，最后將獲取到的對象注入到當(dāng)前對象中。這里我們以上面的首先初始化A對象實(shí)例為例進(jìn)行講解。首先Spring嘗試通過ApplicationContext.getBean()方法獲取A對象的實(shí)例，由于Spring容器中還沒有A對象實(shí)例，因而其會(huì)創(chuàng)建一個(gè)A對象，然后發(fā)現(xiàn)其依賴了B對象，因而會(huì)嘗試遞歸的通過ApplicationContext.getBean()方法獲取B對象的實(shí)例，但是Spring容器中此時(shí)也沒有B對象的實(shí)例，因而其還是會(huì)先創(chuàng)建一個(gè)B對象的實(shí)例。讀者需要注意這個(gè)時(shí)間點(diǎn)，此時(shí)A對象和B對象都已經(jīng)創(chuàng)建了，并且保存在Spring容器中了，只不過A對象的屬性b和B對象的屬性a都還沒有設(shè)置進(jìn)去。在前面Spring創(chuàng)建B對象之后，Spring發(fā)現(xiàn)B對象依賴了屬性A，因而此時(shí)還是會(huì)嘗試遞歸的調(diào)用ApplicationContext.getBean()方法獲取A對象的實(shí)例，因?yàn)镾pring中已經(jīng)有一個(gè)A對象的實(shí)例，雖然只是半成品（其屬性b還未初始化），但其也還是目標(biāo)bean，因而會(huì)將該A對象的實(shí)例返回。此時(shí)，B對象的屬性a就設(shè)置進(jìn)去了，然后還是ApplicationContext.getBean()方法遞歸的返回，也就是將B對象的實(shí)例返回，此時(shí)就會(huì)將該實(shí)例設(shè)置到A對象的屬性b中。這個(gè)時(shí)候，注意A對象的屬性b和B對象的屬性a都已經(jīng)設(shè)置了目標(biāo)對象的實(shí)例了。讀者朋友可能會(huì)比較疑惑的是，前面在為對象B設(shè)置屬性a的時(shí)候，這個(gè)A類型屬性還是個(gè)半成品。但是需要注意的是，這個(gè)A是一個(gè)引用，其本質(zhì)上還是最開始就實(shí)例化的A對象。而在上面這個(gè)遞歸過程的最后，Spring將獲取到的B對象實(shí)例設(shè)置到了A對象的屬性b中了，這里的A對象其實(shí)和前面設(shè)置到實(shí)例B中的半成品A對象是同一個(gè)對象，其引用地址是同一個(gè)，這里為A對象的b屬性設(shè)置了值，其實(shí)也就是為那個(gè)半成品的a屬性設(shè)置了值。下面我們通過一個(gè)流程圖來對這個(gè)過程進(jìn)行講解：

圖中g(shù)etBean()表示調(diào)用Spring的ApplicationContext.getBean()方法，而該方法中的參數(shù)，則表示我們要嘗試獲取的目標(biāo)對象。圖中的黑色箭頭表示一開始的方法調(diào)用走向，走到最后，返回了Spring中緩存的A對象之后，表示遞歸調(diào)用返回了，此時(shí)使用綠色的箭頭表示。從圖中我們可以很清楚的看到，B對象的a屬性是在第三步中注入的半成品A對象，而A對象的b屬性是在第二步中注入的成品B對象，此時(shí)半成品的A對象也就變成了成品的A對象，因?yàn)槠鋵傩砸呀?jīng)設(shè)置完成了。

2. 源碼講解

對于Spring處理循環(huán)依賴問題的方式，我們這里通過上面的流程圖其實(shí)很容易就可以理解，需要注意的一個(gè)點(diǎn)就是，Spring是如何標(biāo)記開始生成的A對象是一個(gè)半成品，并且是如何保存A對象的。這里的標(biāo)記工作Spring是使用ApplicationContext的屬性Set<String> singletonsCurrentlyInCreation來保存的，而半成品的A對象則是通過Map<String, ObjectFactory<?>> singletonFactories來保存的，這里的ObjectFactory是一個(gè)工廠對象，可通過調(diào)用其getObject()方法來獲取目標(biāo)對象。在AbstractBeanFactory.doGetBean()方法中獲取對象的方法如下： 

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,  
    @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {  
  // 嘗試通過bean名稱獲取目標(biāo)bean對象，比如這里的A對象  
  Object sharedInstance = getSingleton(beanName);   
  // 我們這里的目標(biāo)對象都是單例的  
  if (mbd.isSingleton()) {  
    // 這里就嘗試創(chuàng)建目標(biāo)對象，第二個(gè)參數(shù)傳的就是一個(gè)ObjectFactory類型的對象，這里是使用Java8的lamada  
    // 表達(dá)式書寫的，只要上面的getSingleton()方法返回值為空，則會(huì)調(diào)用這里的getSingleton()方法來創(chuàng)建  
    // 目標(biāo)對象 
     sharedInstance = getSingleton(beanName, () -> {  
      try {  
        // 嘗試創(chuàng)建目標(biāo)對象  
        return createBean(beanName, mbd, args);  
      } catch (BeansException ex) {  
        throw ex;  
      }  
    });  
  }  
  return (T) bean;  
} 

 這里的doGetBean()方法是非常關(guān)鍵的一個(gè)方法（中間省略了其他代碼），上面也主要有兩個(gè)步驟，第一個(gè)步驟的getSingleton()方法的作用是嘗試從緩存中獲取目標(biāo)對象，如果沒有獲取到，則嘗試獲取半成品的目標(biāo)對象；如果第一個(gè)步驟沒有獲取到目標(biāo)對象的實(shí)例，那么就進(jìn)入第二個(gè)步驟，第二個(gè)步驟的getSingleton()方法的作用是嘗試創(chuàng)建目標(biāo)對象，并且為該對象注入其所依賴的屬性。

這里其實(shí)就是主干邏輯，我們前面圖中已經(jīng)標(biāo)明，在整個(gè)過程中會(huì)調(diào)用三次doGetBean()方法，第一次調(diào)用的時(shí)候會(huì)嘗試獲取A對象實(shí)例，此時(shí)走的是第一個(gè)getSingleton()方法，由于沒有已經(jīng)創(chuàng)建的A對象的成品或半成品，因而這里得到的是null，然后就會(huì)調(diào)用第二個(gè)getSingleton()方法，創(chuàng)建A對象的實(shí)例，然后遞歸的調(diào)用doGetBean()方法，嘗試獲取B對象的實(shí)例以注入到A對象中，此時(shí)由于Spring容器中也沒有B對象的成品或半成品，因而還是會(huì)走到第二個(gè)getSingleton()方法，在該方法中創(chuàng)建B對象的實(shí)例，創(chuàng)建完成之后，嘗試獲取其所依賴的A的實(shí)例作為其屬性，因而還是會(huì)遞歸的調(diào)用doGetBean()方法，此時(shí)需要注意的是，在前面由于已經(jīng)有了一個(gè)半成品的A對象的實(shí)例，因而這個(gè)時(shí)候，再嘗試獲取A對象的實(shí)例的時(shí)候，會(huì)走第一個(gè)getSingleton()方法，在該方法中會(huì)得到一個(gè)半成品的A對象的實(shí)例。然后將該實(shí)例返回，并且將其注入到B對象的屬性a中，此時(shí)B對象實(shí)例化完成。然后將實(shí)例化完成的B對象遞歸的返回，此時(shí)就會(huì)將該實(shí)例注入到A對象中，這樣就得到了一個(gè)成品的A對象。我們這里可以閱讀上面的第一個(gè)getSingleton()方法： 

@Nullable  
protected Object getSingleton(String beanName, boolean allowEarlyReference) {  
  // 嘗試從緩存中獲取成品的目標(biāo)對象，如果存在，則直接返回  
  Object singletonObject = this.singletonObjects.get(beanName);  
  // 如果緩存中不存在目標(biāo)對象，則判斷當(dāng)前對象是否已經(jīng)處于創(chuàng)建過程中，在前面的講解中，第一次嘗試獲取A對象  
  // 的實(shí)例之后，就會(huì)將A對象標(biāo)記為正在創(chuàng)建中，因而最后再嘗試獲取A對象的時(shí)候，這里的if判斷就會(huì)為true  
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {  
    synchronized (this.singletonObjects) {  
      singletonObject = this.earlySingletonObjects.get(beanName);  
      if (singletonObject == null && allowEarlyReference) { 
         // 這里的singletonFactories是一個(gè)Map，其key是bean的名稱，而值是一個(gè)ObjectFactory類型的  
        // 對象，這里對于A和B而言，調(diào)用圖其getObject()方法返回的就是A和B對象的實(shí)例，無論是否是半成品  
        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);  
        if (singletonFactory != null) {  
          // 獲取目標(biāo)對象的實(shí)例  
          singletonObject = singletonFactory.getObject();  
          this.earlySingletonObjects.put(beanName, singletonObject);  
          this.singletonFactories.remove(beanName);  
        }  
      }  
    }  
  }  
  return singletonObject;  
} 

這里我們會(huì)存在一個(gè)問題就是A的半成品實(shí)例是如何實(shí)例化的，然后是如何將其封裝為一個(gè)ObjectFactory類型的對象，并且將其放到上面的singletonFactories屬性中的。這主要是在前面的第二個(gè)getSingleton()方法中，其最終會(huì)通過其傳入的第二個(gè)參數(shù)，從而調(diào)用createBean()方法，該方法的最終調(diào)用是委托給了另一個(gè)doCreateBean()方法進(jìn)行的，這里面有如下一段代碼： 

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)  
  throws BeanCreationException {  
  // 實(shí)例化當(dāng)前嘗試獲取的bean對象，比如A對象和B對象都是在這里實(shí)例化的  
  BeanWrapper instanceWrapper = null;  
  if (mbd.isSingleton()) {  
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  }  
  if (instanceWrapper == null) {  
    instanceWrapper = createBeanInstance(beanName, mbd, args);  
  }  
  // 判斷Spring是否配置了支持提前暴露目標(biāo)bean，也就是是否支持提前暴露半成品的bean  
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences   
    && isSingletonCurrentlyInCreation(beanName));  
  if (earlySingletonExposure) {  
    // 如果支持，這里就會(huì)將當(dāng)前生成的半成品的bean放到singletonFactories中，這個(gè)singletonFactories  
    // 就是前面第一個(gè)getSingleton()方法中所使用到的singletonFactories屬性，也就是說，這里就是  
    // 封裝半成品的bean的地方。而這里的getEarlyBeanReference()本質(zhì)上是直接將放入的第三個(gè)參數(shù)，也就是  
    // 目標(biāo)bean直接返回  
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));  
  }  
  try {  
    // 在初始化實(shí)例之后，這里就是判斷當(dāng)前bean是否依賴了其他的bean，如果依賴了，  
    // 就會(huì)遞歸的調(diào)用getBean()方法嘗試獲取目標(biāo)bean  
    populateBean(beanName, mbd, instanceWrapper);  
  } catch (Throwable ex) {  
    // 省略...  
  }  
  return exposedObject;  
} 

到這里，Spring整個(gè)解決循環(huán)依賴問題的實(shí)現(xiàn)思路已經(jīng)比較清楚了。對于整體過程，讀者朋友只要理解兩點(diǎn)：

•  Spring是通過遞歸的方式獲取目標(biāo)bean及其所依賴的bean的；
•  Spring實(shí)例化一個(gè)bean的時(shí)候，是分兩步進(jìn)行的，首先實(shí)例化目標(biāo)bean，然后為其注入屬性。

結(jié)合這兩點(diǎn)，也就是說，Spring在實(shí)例化一個(gè)bean的時(shí)候，是首先遞歸的實(shí)例化其所依賴的所有bean，直到某個(gè)bean沒有依賴其他bean，此時(shí)就會(huì)將該實(shí)例返回，然后反遞歸的將獲取到的bean設(shè)置為各個(gè)上層bean的屬性的。

3. 小結(jié)

本文首先通過圖文的方式對Spring是如何解決循環(huán)依賴的問題進(jìn)行了講解，然后從源碼的角度詳細(xì)講解了Spring是如何實(shí)現(xiàn)各個(gè)bean的裝配工作的。