我們都知道 Spring 是通過三級緩存來解決循環(huán)依賴的，但是解決循環(huán)依賴真的需要使用到三級緩沖嗎？只使用兩級緩存是否可以呢？本篇文章就 Spring 是如何使用三級緩存解決循環(huán)依賴作為引子，驗證兩級緩存是否可以解決循環(huán)依賴。

循環(huán)依賴

既然要解決循環(huán)依賴，那么就要知道循環(huán)依賴是什么。如下圖所示：

通過上圖，我們可以看出：

• A 依賴于 B
• B 依賴于 C
• C 依賴于 A

public class A {
  private B b;
}

public class B {
  private C c;
}

public class C {
  private A a;
}

這種依賴關(guān)系形成了一種閉環(huán)，從而造成了循環(huán)依賴的局面。

下面是未解決循環(huán)依賴的常規(guī)步驟：

• 實例化 A，此時 A 還未完成屬性填充和初始化方法（@PostConstruct）的執(zhí)行。
• A 對象發(fā)現(xiàn)需要注入 B 對象，但是容器中并沒有 B 對象（如果對象創(chuàng)建完成并且屬性注入完成和執(zhí)行完初始化方法就會放入容器中）。
• 實例化 B，此時 B 還未完成屬性填充和初始化方法（@PostConstruct）的執(zhí)行。
• B 對象發(fā)現(xiàn)需要注入 C 對象，但是容器中并沒有 C 對象。
• 實例化 C，此時 C 還未完成屬性填充和初始化方法（@PostConstruct）的執(zhí)行。
• C 對象發(fā)現(xiàn)需要注入 A 對象，但是容器中并沒有 A 對象。
• 重復(fù)步驟 1。

三級緩存

Spring 解決循環(huán)依賴的核心就是提前暴露對象，而提前暴露的對象就是放置于第二級緩存中。下表是三級緩存的說明：

所有被 Spring 管理的 Bean，最終都會存放在 singletonObjects 中，這里面存放的 Bean 是經(jīng)歷了所有生命周期的（除了銷毀的生命周期），完整的，可以給用戶使用的。

earlySingletonObjects 存放的是已經(jīng)被實例化，但是還沒有注入屬性和執(zhí)行 init 方法的 Bean。

singletonFactories 存放的是生產(chǎn) Bean 的工廠。

Bean 都已經(jīng)實例化了，為什么還需要一個生產(chǎn) Bean 的工廠呢？這里實際上是跟 AOP 有關(guān)，如果項目中不需要為 Bean 進行代理，那么這個 Bean 工廠就會直接返回一開始實例化的對象，如果需要使用 AOP 進行代理，那么這個工廠就會發(fā)揮重要的作用了，這也是本文需要重點關(guān)注的問題之一。

解決循環(huán)依賴

Spring 是如何通過上面介紹的三級緩存來解決循環(huán)依賴的呢？這里只用 A，B 形成的循環(huán)依賴來舉例：

• 實例化 A，此時 A 還未完成屬性填充和初始化方法（@PostConstruct）的執(zhí)行，A 只是一個半成品。
• 為 A 創(chuàng)建一個 Bean 工廠，并放入到 singletonFactories 中。
• 發(fā)現(xiàn) A 需要注入 B 對象，但是一級、二級、三級緩存均為發(fā)現(xiàn)對象 B。
• 實例化 B，此時 B 還未完成屬性填充和初始化方法（@PostConstruct）的執(zhí)行，B 只是一個半成品。
• 為 B 創(chuàng)建一個 Bean 工廠，并放入到 singletonFactories 中。
• 發(fā)現(xiàn) B 需要注入 A 對象，此時在一級、二級未發(fā)現(xiàn)對象 A，但是在三級緩存中發(fā)現(xiàn)了對象 A，從三級緩存中得到對象 A，并將對象 A 放入二級緩存中，同時刪除三級緩存中的對象 A。（注意，此時的 A 還是一個半成品，并沒有完成屬性填充和執(zhí)行初始化方法）
• 將對象 A 注入到對象 B 中。
• 對象 B 完成屬性填充，執(zhí)行初始化方法，并放入到一級緩存中，同時刪除二級緩存中的對象 B。（此時對象 B 已經(jīng)是一個成品）
• 對象 A 得到對象 B，將對象 B 注入到對象 A 中。（對象 A 得到的是一個完整的對象 B）
• 對象 A 完成屬性填充，執(zhí)行初始化方法，并放入到一級緩存中，同時刪除二級緩存中的對象 A。

我們從源碼中來分析整個過程：

創(chuàng)建 Bean 的方法在 AbstractAutowireCapableBeanFactory::doCreateBean()

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
  BeanWrapper instanceWrapper = null;
  
  if (instanceWrapper == null) {
    // ① 實例化對象
    instanceWrapper = this.createBeanInstance(beanName, mbd, args);
  }

  final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
  Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
  
  // ② 判斷是否允許提前暴露對象，如果允許，則直接添加一個 ObjectFactory 到三級緩存
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
    // 添加三級緩存的方法詳情在下方
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

  // ③ 填充屬性
  this.populateBean(beanName, mbd, instanceWrapper);
  // ④ 執(zhí)行初始化方法，并創(chuàng)建代理
  exposedObject = initializeBean(beanName, exposedObject, mbd);
  
  return exposedObject;
}

添加三級緩存的方法如下：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(singletonFactory, "Singleton factory must not be null");
  synchronized (this.singletonObjects) {
    if (!this.singletonObjects.containsKey(beanName)) { // 判斷一級緩存中不存在此對象
      this.singletonFactories.put(beanName, singletonFactory); // 添加至三級緩存
      this.earlySingletonObjects.remove(beanName); // 確保二級緩存沒有此對象
      this.registeredSingletons.add(beanName);
    }
  }
}

@FunctionalInterface
public interface ObjectFactory<T> {
  T getObject() throws BeansException;
}

通過這段代碼，我們可以知道 Spring 在實例化對象的之后，就會為其創(chuàng)建一個 Bean 工廠，并將此工廠加入到三級緩存中。

因此，Spring 一開始提前暴露的并不是實例化的 Bean，而是將 Bean 包裝起來的 ObjectFactory。為什么要這么做呢？

這實際上涉及到 AOP，如果創(chuàng)建的 Bean 是有代理的，那么注入的就應(yīng)該是代理 Bean，而不是原始的 Bean。但是 Spring 一開始并不知道 Bean 是否會有循環(huán)依賴，通常情況下（沒有循環(huán)依賴的情況下），Spring 都會在完成填充屬性，并且執(zhí)行完初始化方法之后再為其創(chuàng)建代理。但是，如果出現(xiàn)了循環(huán)依賴的話，Spring 就不得不為其提前創(chuàng)建代理對象，否則注入的就是一個原始對象，而不是代理對象。因此，這里就涉及到應(yīng)該在哪里提前創(chuàng)建代理對象？

Spring 的做法就是在 ObjectFactory 中去提前創(chuàng)建代理對象。它會執(zhí)行 getObject() 方法來獲取到 Bean。實際上，它真正執(zhí)行的方法如下：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  Object exposedObject = bean;
  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
        SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
        // 如果需要代理，這里會返回代理對象；否則返回原始對象
        exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
      }
    }
  }
  return exposedObject;
}

因為提前進行了代理，避免對后面重復(fù)創(chuàng)建代理對象，會在 earlyProxyReferences 中記錄已被代理的對象。

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
    implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  @Override
  public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    // 記錄已被代理的對象
    this.earlyProxyReferences.put(cacheKey, bean);
    return wrapIfNecessary(bean, beanName, cacheKey);
  }
}

通過上面的解析，我們可以知道 Spring 需要三級緩存的目的是為了在沒有循環(huán)依賴的情況下，延遲代理對象的創(chuàng)建，使 Bean 的創(chuàng)建符合 Spring 的設(shè)計原則。

如何獲取依賴

我們目前已經(jīng)知道了 Spring 的三級依賴的作用，但是 Spring 在注入屬性的時候是如何去獲取依賴的呢？

他是通過一個 getSingleton() 方法去獲取所需要的 Bean 的。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // 一級緩存
  Object singletonObject = this.singletonObjects.get(beanName);
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    synchronized (this.singletonObjects) {
      // 二級緩存
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null && allowEarlyReference) {
        // 三級緩存
        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
        if (singletonFactory != null) {
          // Bean 工廠中獲取 Bean
          singletonObject = singletonFactory.getObject();
          // 放入到二級緩存中
          this.earlySingletonObjects.put(beanName, singletonObject);
          this.singletonFactories.remove(beanName);
        }
      }
    }
  }
  return singletonObject;
}

當 Spring 為某個 Bean 填充屬性的時候，它首先會尋找需要注入對象的名稱，然后依次執(zhí)行 getSingleton() 方法得到所需注入的對象，而獲取對象的過程就是先從一級緩存中獲取，一級緩存中沒有就從二級緩存中獲取，二級緩存中沒有就從三級緩存中獲取，如果三級緩存中也沒有，那么就會去執(zhí)行 doCreateBean() 方法創(chuàng)建這個 Bean。

二級緩存

我們現(xiàn)在已經(jīng)知道，第三級緩存的目的是為了延遲代理對象的創(chuàng)建，因為如果沒有依賴循環(huán)的話，那么就不需要為其提前創(chuàng)建代理，可以將它延遲到初始化完成之后再創(chuàng)建。

既然目的只是延遲的話，那么我們是不是可以不延遲創(chuàng)建，而是在實例化完成之后，就為其創(chuàng)建代理對象，這樣我們就不需要第三級緩存了。因此，我們可以將addSingletonFactory() 方法進行改造。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(singletonFactory, "Singleton factory must not be null");
  synchronized (this.singletonObjects) {
    if (!this.singletonObjects.containsKey(beanName)) { // 判斷一級緩存中不存在此對象
      object o = singletonFactory.getObject(); // 直接從工廠中獲取 Bean
      this.earlySingletonObjects.put(beanName, o); // 添加至二級緩存中
      this.registeredSingletons.add(beanName);
    }
  }
}

這樣的話，每次實例化完 Bean 之后就直接去創(chuàng)建代理對象，并添加到二級緩存中。測試結(jié)果是完全正常的，Spring 的初始化時間應(yīng)該也是不會有太大的影響，因為如果 Bean 本身不需要代理的話，是直接返回原始 Bean 的，并不需要走復(fù)雜的創(chuàng)建代理 Bean 的流程。

結(jié)論

測試證明，二級緩存也是可以解決循環(huán)依賴的。為什么 Spring 不選擇二級緩存，而要額外多添加一層緩存呢？

如果 Spring 選擇二級緩存來解決循環(huán)依賴的話，那么就意味著所有 Bean 都需要在實例化完成之后就立馬為其創(chuàng)建代理，而 Spring 的設(shè)計原則是在 Bean 初始化完成之后才為其創(chuàng)建代理。所以，Spring 選擇了三級緩存。但是因為循環(huán)依賴的出現(xiàn)，導(dǎo)致了 Spring 不得不提前去創(chuàng)建代理，因為如果不提前創(chuàng)建代理對象，那么注入的就是原始對象，這樣就會產(chǎn)生錯誤。

到此這篇關(guān)于淺談Spring 解決循環(huán)依賴必須要三級緩存嗎的文章就介紹到這了,更多相關(guān)Spring  循環(huán)依賴三級緩存內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！