摘要：從創(chuàng)建的的起點(diǎn)開始首先會(huì)在緩存中查找，這里一共有三級(jí)緩存，保存初始化完成的單例實(shí)例，保存提前曝光的單例實(shí)例，保存單例的工廠函數(shù)對(duì)象后面兩級(jí)都是為了解決循環(huán)依賴設(shè)置的，具體查找邏輯在后續(xù)其他情況下調(diào)用會(huì)說明。

在開發(fā)過程中，遇到需要把方法調(diào)用改為異步的情況，本來以為簡(jiǎn)單得加個(gè)@Asyn在方法上就行了，沒想到項(xiàng)目啟動(dòng)的時(shí)候報(bào)了如下的錯(cuò)誤：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
Error creating bean with name "customerServiceImpl": 
Bean with name "customerServiceImpl" has been injected into other beans [customerServiceImpl,followServiceImpl,cupidService] in its raw version as part of a circular reference, 
but has eventually been wrapped. This means that said other beans do not use the final version of the bean. 
This is often the result of over-eager type matching - consider using "getBeanNamesOfType" with the "allowEagerInit" flag turned off, for example.

看了下好像報(bào)的是循環(huán)依賴的錯(cuò)誤，但是Spring單例是支持循環(huán)依賴的，當(dāng)時(shí)一臉懵逼。
拿著報(bào)錯(cuò)去百度了下，說是多個(gè)動(dòng)態(tài)代理導(dǎo)致的循環(huán)依賴報(bào)錯(cuò)，也找到了報(bào)錯(cuò)的地點(diǎn)，但是還是不明白為什么會(huì)這樣，所以打算深入源碼探個(gè)究竟，順便回顧下Bean的獲取流程和循環(huán)依賴的內(nèi)容。

用SpringBoot新建一個(gè)demo項(xiàng)目，因?yàn)樵?xiàng)目是有定義切面的，這里也定義一個(gè)切面：

@Aspect
@Component
public class TestAspect {

    @Pointcut("execution(public * com.example.demo.service.CyclicDependencyService.sameClassMethod(..))")
    private void testPointcut() {}

    @AfterReturning("testPointcut()")
    public void after(JoinPoint point) {
        System.out.println("在" + point.getSignature() + "之后干點(diǎn)事情");
    }

}

然后新建一個(gè)注入自己的Service構(gòu)成循環(huán)依賴，然后提供一個(gè)方法滿足切點(diǎn)要求，并且加上@Async注解：

@Service
public class CyclicDependencyService {

    @Autowired
    private CyclicDependencyService cyclicDependencyService;

    public void test() {
        System.out.println("調(diào)用同類方法");
        cyclicDependencyService.sameClassMethod();
    }

    @Async
    public void sameClassMethod() {
        System.out.println("循環(huán)依賴中的異步方法");
        System.out.println("方法線程：" + Thread.currentThread().getName());
    }

}

還有別忘了給Application啟動(dòng)類加上@EnableAsync和@EnableAspectJAutoProxy：

@EnableAsync
@EnableAspectJAutoProxy
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

最后打好斷點(diǎn)，開始debug。

從Bean創(chuàng)建的的起點(diǎn)--AbstractBeanFactory#getBean開始

// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);

首先會(huì)在緩存中查找，DefaultSingletonBeanRegistry#getSingleton(String beanName, boolean allowEarlyReference)：

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) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

這里一共有三級(jí)緩存：

singletonObjects，保存初始化完成的單例bean實(shí)例；

earlySingletonObjects，保存提前曝光的單例bean實(shí)例；

singletonFactories，保存單例bean的工廠函數(shù)對(duì)象；

后面兩級(jí)都是為了解決循環(huán)依賴設(shè)置的，具體查找邏輯在后續(xù)其他情況下調(diào)用會(huì)說明。

緩存中找不到，就要?jiǎng)?chuàng)建單例：

sharedInstance = getSingleton(beanName, () -> {
   try {
      return createBean(beanName, mbd, args);
   }
   catch (BeansException ex) {
      // Explicitly remove instance from singleton cache: It might have been put there
      // eagerly by the creation process, to allow for circular reference resolution.
      // Also remove any beans that received a temporary reference to the bean.
      destroySingleton(beanName);
      throw ex;
   }
});

調(diào)用DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory singletonFactory):

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
    ...
    beforeSingletonCreation(beanName);
    ...
    singletonObject = singletonFactory.getObject();
    ...
    afterSingletonCreation(beanName);
    ...
    addSingleton(beanName, singletonObject);
    ...
}

創(chuàng)建前后分別做了這幾件事：

前，beanName放入singletonsCurrentlyInCreation，表示單例正在創(chuàng)建中

后，從singletonsCurrentlyInCreation中移除beanName

后，將創(chuàng)建好的bean放入singletonObjects，移除在singletonFactories和earlySingletonObjects的對(duì)象

創(chuàng)建單例調(diào)用getSingleton時(shí)傳入的工廠函數(shù)對(duì)象的getObject方法，實(shí)際上就是createBean方法，主要邏輯在AbstractAutowireCapableBeanFactory#doCreateBean中：

...
instanceWrapper = createBeanInstance(beanName, mbd, args);
final Object bean = instanceWrapper.getWrappedInstance();
...
// 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");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
   populateBean(beanName, mbd, instanceWrapper);
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}
...
if (earlySingletonExposure) {
   Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {
      if (exposedObject == bean) {
         exposedObject = earlySingletonReference;
      }
      else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
         String[] dependentBeans = getDependentBeans(beanName);
         Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
         for (String dependentBean : dependentBeans) {
            if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
               actualDependentBeans.add(dependentBean);
            }
         }
         if (!actualDependentBeans.isEmpty()) {
            throw new BeanCurrentlyInCreationException(beanName,
                  "Bean with name "" + beanName + "" has been injected into other beans [" +
                  StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                  "] in its raw version as part of a circular reference, but has eventually been " +
                  "wrapped. This means that said other beans do not use the final version of the " +
                  "bean. This is often the result of over-eager type matching - consider using " +
                  ""getBeanNamesOfType" with the "allowEagerInit" flag turned off, for example.");
         }
      }
   }
}

可以看到報(bào)錯(cuò)就是在這個(gè)方法里拋出的，那么這個(gè)方法就是重點(diǎn)中的重點(diǎn)。

首先實(shí)例化單例，instantiate，只是實(shí)例化獲取對(duì)象引用，還沒有注入依賴。我debug時(shí)記錄的bean對(duì)象是CyclicDependencyService@4509；

然后判斷bean是否需要提前暴露，需要滿足三個(gè)條件：1、是單例；2、支持循環(huán)依賴；3、bean正在創(chuàng)建中，也就是到前面提到的singletonsCurrentlyInCreation中能查找到，全滿足的話就會(huì)調(diào)用DefaultSingletonBeanRegistry#addSingletonFactory把beanName和單例工廠函數(shù)對(duì)象（匿名實(shí)現(xiàn)調(diào)用AbstractAutowireCapableBeanFactory#getEarlyBeanReference方法）放入singletonFactories；

接著就是注入依賴，填充屬性，具體怎么注入這里就不展開了，最后會(huì)為屬性cyclicDependencyService調(diào)用DefaultSingletonBeanRegistry.getSingleton(beanName, true)，注意這里和最開始的那次調(diào)用不一樣，isSingletonCurrentlyInCreation為true，就會(huì)在singletonFactories中找到bean的單例工廠函數(shù)對(duì)象，也就是在上一步提前暴露時(shí)放入的，然后調(diào)用它的匿名實(shí)現(xiàn)AbstractAutowireCapableBeanFactory#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;
}

方法邏輯就是挨個(gè)調(diào)用實(shí)現(xiàn)了SmartInstantiationAwareBeanPostProcessor接口的后置處理器（以下簡(jiǎn)稱BBP）的getEarlyBeanReference方法。一個(gè)一個(gè)debug下來，其他都是原樣返回bean，只有AnnotationAwareAspectJAutoProxyCreator會(huì)把原bean（CyclicDependencyService@4509）存在earlyProxyReferences，然后將bean的代理返回（debug時(shí)記錄的返回對(duì)象是CyclicDependencyService$$EnhancerBySpringCGLIB$$6ed9e2db@4740）并放入earlySingletonObjects，再賦給屬性cyclicDependencyService。

public Object getEarlyBeanReference(Object bean, String beanName) {
   Object cacheKey = getCacheKey(bean.getClass(), beanName);
   this.earlyProxyReferences.put(cacheKey, bean);
   return wrapIfNecessary(bean, beanName, cacheKey);
}

屬性填充完成后就是調(diào)用初始化方法AbstractAutowireCapableBeanFactory#initializeBean：

...
invokeAwareMethods(beanName, bean);
...
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
...
invokeInitMethods(beanName, wrappedBean, mbd);
...
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
...

初始化主要分為這幾步：

如果bean實(shí)現(xiàn)了BeanNameAware、BeanClassLoaderAware或BeanFactoryAware，把相應(yīng)的資源放入bean；

順序執(zhí)行BBP的postProcessBeforeInitialization方法；

如果實(shí)現(xiàn)了InitializingBean就執(zhí)行afterPropertiesSet方法，然后執(zhí)行自己的init-method；

順序執(zhí)行BBP的postProcessAfterInitialization。

debug的時(shí)候發(fā)現(xiàn)是第4步改變了bean，先執(zhí)行AnnotationAwareAspectJAutoProxyCreator#postProcessAfterInitialization：

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

這里會(huì)獲取并移除之前存在earlyProxyReferences的bean（CyclicDependencyService@4509），因?yàn)楹彤?dāng)前bean是同一個(gè)對(duì)象，所以什么都沒做直接返回。隨后會(huì)執(zhí)行AsyncAnnotationBeanPostProcessor#postProcessAfterInitialization：

if (isEligible(bean, beanName)) {
   ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
   if (!proxyFactory.isProxyTargetClass()) {
      evaluateProxyInterfaces(bean.getClass(), proxyFactory);
   }
   proxyFactory.addAdvisor(this.advisor);
   customizeProxyFactory(proxyFactory);
   return proxyFactory.getProxy(getProxyClassLoader());
}

先判斷bean是否有需要代理，因?yàn)镃yclicDependencyService有方法帶有@Async注解就需要代理，返回代理對(duì)象是CyclicDependencyService$$EnhancerBySpringCGLIB$$e66d8f6e@5273。

返回的代理對(duì)象賦值給AbstractAutowireCapableBeanFactory#doCreateBean方法內(nèi)的exposedObject，接下來就到了檢查循環(huán)依賴的地方了：

if (earlySingletonExposure) {
   Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {
      if (exposedObject == bean) {
         exposedObject = earlySingletonReference;
      }
      else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
         String[] dependentBeans = getDependentBeans(beanName);
         Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
         for (String dependentBean : dependentBeans) {
            if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
               actualDependentBeans.add(dependentBean);
            }
         }
         if (!actualDependentBeans.isEmpty()) {
            throw new BeanCurrentlyInCreationException(beanName,
                  "Bean with name "" + beanName + "" has been injected into other beans [" +
                  StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                  "] in its raw version as part of a circular reference, but has eventually been " +
                  "wrapped. This means that said other beans do not use the final version of the " +
                  "bean. This is often the result of over-eager type matching - consider using " +
                  ""getBeanNamesOfType" with the "allowEagerInit" flag turned off, for example.");
         }
      }
   }
}

首先從earlySingletonObjects里拿到前面屬性填充時(shí)放入的bean代理（CyclicDependencyService$$EnhancerBySpringCGLIB$$6ed9e2db@4740），不為空的話就比較bean和exposedObject，分別是CyclicDependencyService@4509和CyclicDependencyService$$EnhancerBySpringCGLIB$$e66d8f6e@5273，很明顯不是同一個(gè)對(duì)象，然后會(huì)判斷allowRawInjectionDespiteWrapping屬性和是否有依賴的bean，然后判斷這些bean是否是真實(shí)依賴的，一旦存在真實(shí)依賴的bean，就會(huì)拋出BeanCurrentlyInCreationException。

總結(jié)下Spring解決循環(huán)依賴的思路：在創(chuàng)建bean時(shí)，對(duì)于滿足提前曝光條件的單例，會(huì)把該單例的工廠函數(shù)對(duì)象放入三級(jí)緩存中的singletonFactories中；然后在填充屬性時(shí)，如果存在循環(huán)依賴，必然會(huì)嘗試獲取該單例，也就是執(zhí)行之前放入的工廠函數(shù)的匿名實(shí)現(xiàn)，這時(shí)候拿到的有可能是原bean對(duì)象，也有可能是被某些BBP處理過返回的代理對(duì)象，會(huì)放入三級(jí)緩存中的earlySingletonObjects中；接著bean開始初始化，結(jié)果返回的有可能是原bean對(duì)象，也有可能是代理對(duì)象；最后對(duì)于滿足提前曝光的單例，如果真的有提前曝光的動(dòng)作，就會(huì)去檢查初始化后的bean對(duì)象是不是原bean對(duì)象是同一個(gè)對(duì)象，只有不是的情況下才可能拋出異常。重點(diǎn)就在于存在循環(huán)依賴的情況下，初始化過的bean對(duì)象是不是跟原bean是同一個(gè)對(duì)象。

從以上的debug過程可以看出，是AsyncAnnotationBeanPostProcessor這個(gè)BBP在初始化過程中改變了bean，使得結(jié)果bean和原bean不是一個(gè)對(duì)象，而AnnotationAwareAspectJAutoProxyCreator則是在填充屬性獲取提前曝光的對(duì)象時(shí)把原始bean緩存起來，返回代理的bean。然后在初始化時(shí)執(zhí)行它的postProcessAfterInitialization方法時(shí)如果傳入的bean是之前緩存的原始bean，就直接返回，不進(jìn)行代理。如果其他BBP也都沒有改變bean的話，初始化過后的bean就是跟原始bean是同一個(gè)對(duì)象，這時(shí)就會(huì)把提前曝光的對(duì)象（代理過的）作為最終生成的bean。