spring源码分析之如何解决循环依赖

@Service
public class ACircleService {
   

    @Autowired
    private BCircleService bCircleService;
}

@Service
public class BCircleService {
   

    @Autowired
    private ACircleService aCircleService;
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
   

   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   //（1）.先依次从一级、二级、三级缓存中看看能否取到
   Object sharedInstance = getSingleton(beanName);
    //（2）.如果缓存中能取到，则不会走下面的创建
   if (sharedInstance != null && args == null) {
   
      if (logger.isTraceEnabled()) {
   
         if (isSingletonCurrentlyInCreation(beanName)) {
   
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
   
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }
//（3）.如果缓存中取不到，则走创建的逻辑
   else {
   
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
		//省略代码...
         // Create bean instance.
         if (mbd.isSingleton()) {
   
             //（4）.主要的创建逻辑
            sharedInstance = getSingleton(beanName, () -> {
   
               try {
   
                   //（5）.java8函数式编程
                  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;
               }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }
		//省略代码...
   }

   //省略代码...
   return (T) bean;
}

public 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 + "'");
         }
         //（1）.开始创建之前调用方法
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
   
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
   
             //（2）.真正的调用方法
            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;
            }
            //（3）.开始创建之后调用方法
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
   
             //（4）.创建成功之后调用的方法
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

protected void beforeSingletonCreation(String beanName) {
   
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
   
      throw new BeanCurrentlyInCreationException(beanName);
   }
}

protected void afterSingletonCreation(String beanName) {
   
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
   
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}

protected void addSingleton(String beanName, Object singletonObject) {
   
   synchronized (this.singletonObjects) {
   
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
   
//省略代码....
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    //省略代码...

}

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) {
   
       //（1）.创建bean包装类BealWrapper，这段代码执行结束，说明bean已经构建完成，在堆上创建了实例
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
    //（2）.拿到bean
   final Object bean = instanceWrapper.getWrappedInstance();

   //省略部分代码...

   // Eagerly cache singletons to be able to resolve circular references
   // even when triggered by lifecycle interfaces like BeanFactoryAware.
    //（3）.这里非常重要，没有删除原来的英文注释，这里就是提前曝光
   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");
      }
       //(3-1)
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }

   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
   
       //（4）.给属性赋值
      populateBean(beanName, mbd, instanceWrapper);
       //（5）.调用初始化方法
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
   if (earlySingletonExposure) {
   
       //（6）.bean在容器中移动
      Object earlySingletonReference = getSingleton(beanName, false);

  //省略部分代码...

   return exposedObject;
}

addSingletonFactory(beanName, new ObjectFactory<Object>(){
   

    @Override
    public Object getObject() throws BeansException {
   
        return 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;
}