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

知識回顧

決議完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方法，

標籤：Java

上一篇：Java.lang.Class類中isAssignableFrom()方法具有什么功能呢？

下一篇：萬惡的Jackson