spring 循环依赖与三级缓存

@Servicepublic class ServiceA {  @Autowired  private ServiceB serviceB;
  public String say(){    return "hello";  }}
@Servicepublic class ServiceB {
  @Autowired  private ServiceA serviceA;
}

The dependencies of some of the beans in the application context form a cycle:
   cycleController (field com.paw.cycle.dependency.service.ServiceA com.paw.cycle.dependency.controller.CycleController.serviceA)┌─────┐|  serviceA defined in file [/Users/.../target/classes/com/paw/cycle/dependency/service/ServiceA.class]↑     ↓|  serviceB defined in file [/Users/.../target/classes/com/paw/cycle/dependency/service/ServiceB.class]└─────┘

logging:  level:    org.springframework: trace

main] o.s.b.f.s.DefaultListableBeanFactory     : Finished creating instance of bean 'cycleDependencyApplication'main] o.s.b.f.s.DefaultListableBeanFactory     : Returning cached instance of singleton bean 'org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory'main] o.s.b.f.s.DefaultListableBeanFactory     : Creating shared instance of singleton bean 'cycleController'main] o.s.b.f.s.DefaultListableBeanFactory     : Creating instance of bean 'cycleController'main] o.s.b.f.s.DefaultListableBeanFactory     : Eagerly caching bean 'cycleController' to allow for resolving potential circular referencesmain] o.s.b.f.s.DefaultListableBeanFactory     : Finished creating instance of bean 'cycleController'main] o.s.b.f.s.DefaultListableBeanFactory     : Creating shared instance of singleton bean 'serviceA'main] o.s.b.f.s.DefaultListableBeanFactory     : Creating instance of bean 'serviceA'main] o.s.b.f.annotation.InjectionMetadata     : Registered injected element on class [com.paw.cycle.dependency.service.ServiceA]: AutowiredFieldElement for private com.paw.cycle.dependency.service.ServiceB com.paw.cycle.dependency.service.ServiceA.serviceBmain] o.s.b.f.s.DefaultListableBeanFactory     : Eagerly caching bean 'serviceA' to allow for resolving potential circular referencesmain] o.s.b.f.annotation.InjectionMetadata     : Processing injected element of bean 'serviceA': AutowiredFieldElement for private com.paw.cycle.dependency.service.ServiceB com.paw.cycle.dependency.service.ServiceA.serviceBmain] o.s.b.f.s.DefaultListableBeanFactory     : Creating shared instance of singleton bean 'serviceB'main] o.s.b.f.s.DefaultListableBeanFactory     : Creating instance of bean 'serviceB'main] o.s.b.f.annotation.InjectionMetadata     : Registered injected element on class [com.paw.cycle.dependency.service.ServiceB]: AutowiredFieldElement for private com.paw.cycle.dependency.service.ServiceA com.paw.cycle.dependency.service.ServiceB.serviceAmain] o.s.b.f.s.DefaultListableBeanFactory     : Eagerly caching bean 'serviceB' to allow for resolving potential circular referencesmain] o.s.b.f.annotation.InjectionMetadata     : Processing injected element of bean 'serviceB': AutowiredFieldElement for private com.paw.cycle.dependency.service.ServiceA com.paw.cycle.dependency.service.ServiceB.serviceAmain] o.s.b.f.s.DefaultListableBeanFactory     : Returning eagerly cached instance of singleton bean 'serviceA' that is not fully initialized yet - a consequence of a circular referencemain] f.a.AutowiredAnnotationBeanPostProcessor : Autowiring by type from bean name 'serviceB' to bean named 'serviceA'main] o.s.b.f.s.DefaultListableBeanFactory     : Finished creating instance of bean 'serviceB'main] f.a.AutowiredAnnotationBeanPostProcessor : Autowiring by type from bean name 'serviceA' to bean named 'serviceB'main] o.s.b.f.s.DefaultListableBeanFactory     : Finished creating instance of bean 'serviceA'main] o.s.b.f.s.DefaultListableBeanFactory     : Returning cached instance of sinleton bean 'serviceB'    

// 一级实例化好的bean/**Cache of singleton objects: bean name to bean instance.*/private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级半成品  未进行属性注入/** Cache of early singleton objects: bean name to bean instance. */private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级 生成bean的ObjectFactory/** Cache of singleton factories: bean name to ObjectFactory. */private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

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

AbstractAutowireCapableBeanFactoryprotected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)  throws BeanCreationException {      ...    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);  } }}

AbstractBeanFactory#doGetBean// 创建bean实例sharedInstance = getSingleton(beanName, () -> { try {  return createBean(beanName, mbd, args); } ... }
==>  DefaultSingletonBeanRegistry#getSingletonpublic Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) {  Object singletonObject = this.singletonObjects.get(beanName);  if (singletonObject == null) {   if (this.singletonsCurrentlyInDestruction) {    throw new BeanCreationNotAllowedException(beanName,      "Singleton bean creation not allowed while singletons of this factory are in destruction " +      "(Do not request a bean from a BeanFactory in a destroy method implementation!)");   }   if (logger.isDebugEnabled()) {    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");   }   // 创建bean之前的处理   beforeSingletonCreation(beanName);   boolean newSingleton = false;   boolean recordSuppressedExceptions = (this.suppressedExceptions == null);   if (recordSuppressedExceptions) {    this.suppressedExceptions = new LinkedHashSet<>();   }   try {       // 通过三级缓存的objectFactory获取bean对象实例    singletonObject = singletonFactory.getObject();    newSingleton = true;   }   catch (IllegalStateException ex) {    // Has the singleton object implicitly appeared in the meantime ->    // if yes, proceed with it since the exception indicates that state.    singletonObject = this.singletonObjects.get(beanName);    if (singletonObject == null) {     throw ex;    }   }   catch (BeanCreationException ex) {    if (recordSuppressedExceptions) {     for (Exception suppressedException : this.suppressedExceptions) {      ex.addRelatedCause(suppressedException);     }    }    throw ex;   }   finally {    if (recordSuppressedExceptions) {     this.suppressedExceptions = null;    }    // 创建完后的处理    afterSingletonCreation(beanName);   }   if (newSingleton) {       // 创建成功添加到一级缓存    addSingleton(beanName, singletonObject);   }  }  return singletonObject; }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)  throws BeanCreationException {
 // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) {  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) {  instanceWrapper = createBeanInstance(beanName, mbd, args); } final Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) {  mbd.resolvedTargetType = beanType; }
 // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) {  if (!mbd.postProcessed) {   try {    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);   }   catch (Throwable ex) {    throw new BeanCreationException(mbd.getResourceDescription(), beanName,      "Post-processing of merged bean definition failed", ex);   }   mbd.postProcessed = true;  } }
 // 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");  }  // 添加三级缓存 beanFactory  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }
 // Initialize the bean instance. Object exposedObject = bean; try { // 填充bean属性 即注入@Autowired字段  populateBean(beanName, mbd, instanceWrapper);  exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) {  if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {   throw (BeanCreationException) ex;  }  else {   throw new BeanCreationException(     mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);  } }
 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<String> 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.");    }   }  } }
 // Register bean as disposable. try {  registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) {  throw new BeanCreationException(    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); }
 return exposedObject;}

//AbstractAutowireCapableBeanFactoryprotected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) 

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) { InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs); try {  metadata.inject(bean, beanName, pvs); } catch (BeanCreationException ex) {  throw ex; } catch (Throwable ex) {  throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex); } return pvs;}