Spring 源碼（14）Spring Bean 的創建過程（6）對象的提前暴露

知識回顧解析完Bean信息的合併，可以知道Spring在實例化Bean之後，屬性填充前，對Bean進行了Bean的合併操作，這裡的操作主要做了對Bean對象標記了@Autowired、@Value、@Resource、@PostConstruct、@PreDestroy註解的欄位或者方法進行解析， ...

知識回顧

解析完Bean信息的合併，可以知道Spring在實例化Bean之後，屬性填充前，對Bean進行了Bean的合併操作，這裡的操作主要做了對Bean對象標記了@Autowired、@Value、@Resource、@PostConstruct、@PreDestroy註解的欄位或者方法進行解析，主要涉及到類都是BeanPostProcessor的實現，可見BeanPostProcessor介面的重要性。

這裡再次回顧下BeanPostProcessor介面有哪些子介面：

InstantiationAwareBeanPostProcessor

Spring 給機會提前進行實例化，可用通過代理進行對象的創建
SmartInstantiationAwareBeanPostProcessor

用於預測Bean的類型，決定Bean的構造函數，用於實例化
MergedBeanDefinitionPostProcessor

用於合併Bean的信息，即解析Bean對象方法上或者欄位上標記的註解，比如@Resource、@Autowired、@PostConstruct等。
DestructionAwareBeanPostProcessor

用於銷毀Bean時調用的，比如執行標有@PreDestroy註解的方法

這些子介面的實現類比較多，比如：

AutowiredAnnotationBeanPostProcessor
ComonAnnotationBeanPostProcessor
InitDestroyAnnotationBeanPostProcessor
AnnotationAwareAspectJAutoProxyCreator
ScheduledAnnotationBeanPostProcessor

當然還不止這裡列出來的，還有其他的就不列了，接下來分析Spring源碼接下來做了什麼？

對象的提前暴露

看源碼：

// 省略代碼....
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 提前暴露對象，用於解決迴圈依賴
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                  isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
  if (logger.isTraceEnabled()) {
    logger.trace("Eagerly caching bean '" + beanName +
                 "' to allow for resolving potential circular references");
  }
  // 添加一個lambda表達式到三級緩存中
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// Initialize the bean instance.
Object exposedObject = bean;
// 省略代碼....

源碼這裡就添加了一個lambda表達式到一個Map中，然後結束了，並且明確說明瞭提前暴露是為瞭解決迴圈依賴問題。

什麼是迴圈依賴？

迴圈依賴顧名思義，就是你中有我，我中有你，打個比方現在有個對象A，他有個屬性b，這個屬性b是對象B的，然後對象B中有個屬性a，屬性a是對象A的。

現在開始創建對象，按照Spring的標準創建流程getBean-->doGetBean-->createBean-->doCreateBean，先實例化，然後屬性填充，然後執行aware方法，然後執行BeanPostProcessor的before方法，然後執行init-method，然後執行BeanPostProcessor的after方法。那麼在執行屬性填充時必然會去查找a或者b屬性對應的對象，如果找不到就會去創建，那麼就會出現下圖的樣子：

這樣必然就出現了迴圈依賴，你我緊緊相擁，不想放開，死也要在一起的情形。

那麼`Spring`為什麼解決迴圈依賴需要進行提前暴露對象呢？

所以這個問題就很簡單了，我們都知道Bean的創建是將實例化和初始化分開的，實例化之後的對象在JVM堆中已經開闢了記憶體空間地址，這個地址是不會變的，除非山崩地裂，海枯石爛，也就是應用重啟了。

因此可以將已經實例化的對象放在另外一個Map中，一般來說都稱之為半成品，當填充屬性時，可以將先設置半成品對象，等到對象創建完之後在將半成品換成成品，這樣的話對象進行屬性填充時就可以直接先使用半成品填充，等到開始初始化時再將對象創建出來即可。

這樣看來迴圈依賴只需要二級緩存就夠了，但是在Spring中，存在一種特殊的對象，就是代理對象。也就是說在放入的半成品我們現在多了一種對象，那就是代理對象，這個時候就會出現使用代理對象還是普通對象呢？所以乾脆在搞一個Map專門存放代理對象，這樣就區分出來了，然後在使用的時候先判斷下我們創建的對象是需要代理還是不需要代理，如果需要代理，那麼就創建一個代理對象放在map中，否則直接使用普通對象就可以了。

Spring中的實現方式

Spring是怎麼處理的呢？Spring是將所有的對象都放在三級緩存中，也就是lambda表達式中：

// 添加一個lambda表達式到三級緩存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));


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);
    }
  }
}

在屬性填充的時候，會執行到getBean，然後從緩存中獲取getSingleton：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // Quick check for existing instance without full singleton lock
  // 從一級緩存中獲取bean實例
  Object singletonObject = this.singletonObjects.get(beanName);
  // 如果一級緩存中沒有數據並且沒有正在創建的Bean直接返回
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    // 如果有正在創建的Bean，那麼沖二級緩存中獲取，早期的單例對象
    singletonObject = this.earlySingletonObjects.get(beanName);
    if (singletonObject == null && allowEarlyReference) {
      synchronized (this.singletonObjects) {
        // Consistent creation of early reference within full singleton lock
        // 二次檢查一級緩存中是否有單例對象
        singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
          // 二次判斷二級緩存中是否存在單例對象
          singletonObject = this.earlySingletonObjects.get(beanName);
          if (singletonObject == null) {
            // 從三級緩存中獲取Bean
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
              // 如果三級緩存中 單例工廠中有對象，那麼就將該對象放在二級緩存中，並且清掉三級緩存
              singletonObject = singletonFactory.getObject();
              this.earlySingletonObjects.put(beanName, singletonObject);
              this.singletonFactories.remove(beanName);
            }
          }
        }
      }
    }
  }
  return singletonObject;
}

在獲取單例對象時，會執行到三級緩存，然後執行getObject方法，最終就會觸發getEarlyBeanReference方法的調用:

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;
}

這裡會判斷，如果這個BeanDefinition是否滿足條件，如果不滿足，那麼直接返回了，否則就會執行到for迴圈中的代碼，而getEarlyBeanReference方法在Spring中只有AbstractAutoProxyCreator類進行了實質的實現：

public Object getEarlyBeanReference(Object bean, String beanName) {
  Object cacheKey = getCacheKey(bean.getClass(), beanName);
  // 早期代理對象的引用集合
  this.earlyProxyReferences.put(cacheKey, bean);
  // 創建代理
  return wrapIfNecessary(bean, beanName, cacheKey);
}

點進去：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
    return bean;
  }
  if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
    return bean;
  }
  if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
  }

  // Create proxy if we have advice.
  Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  if (specificInterceptors != DO_NOT_PROXY) {
    this.advisedBeans.put(cacheKey, Boolean.TRUE);
    // 創建代理對象
    Object proxy = createProxy(
      bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    this.proxyTypes.put(cacheKey, proxy.getClass());
    return proxy;
  }

  this.advisedBeans.put(cacheKey, Boolean.FALSE);
  return bean;
}

首先進行了判斷，如果不滿足創建代理的條件，都是直接返回這個對象，否則進入創建代理的方法，創建出代理對象，最終放入緩存中。點入到最後會發現使用了兩種代理創建方式：

源碼中的提前暴露對象牽扯出很多東西，迴圈依賴，三級緩存，aop等，這裡解析了個大概，接下來繼續主流程中的屬性填充populaeBean方法。