Spring 原始碼（14）Spring Bean 的建立過程（6）物件的提前暴露

玲丶蹊發表於2022-05-18
Spring原始碼Bean物件

知識回顧

解析完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方法。

相關文章