public class BeanA {
    private BeanB beanB;
    public BeanA(BeanB beanB){
        this.beanB = beanB;
    }
}
public class BeanB {

    private BeanA beanA;

    public BeanB(BeanA beanA){
        this.beanA = beanA;
    }
}

<bean id="beanA" class="cn.itsource._01_di.BeanA" >
        <constructor-arg type="cn.itsource._01_di.BeanB" ref="beanB"  />
 </bean>

 <bean id="beanB" class="cn.itsource._01_di.BeanB"  >
         <constructor-arg type="cn.itsource._01_di.BeanA" ref="beanA" />
 </bean>

public class BeanA {
    private BeanB beanB;
    public void setBeanB(BeanB beanB){
        this.beanB = beanB;
    }
}
@Data
public class BeanB {

    private BeanA beanA;

    public void setBeanA(BeanA beanA){
        this.beanA = beanA;
    }
}

<bean id="beanA" class="cn.itsource._01_di.BeanA" >
    <property name="beanB" ref="beanB" />
</bean>
<bean id="beanB" class="cn.itsource._01_di.BeanB">
    <property name="beanA" ref="beanA" />
</bean>

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
 @Nullable
 private Boolean allowBeanDefinitionOverriding;
 //是否允許循環(huán)依賴
 @Nullable
 private Boolean allowCircularReferences;

 //設置循環(huán)依賴
 public void setAllowCircularReferences(boolean allowCircularReferences) {
  this.allowCircularReferences = allowCircularReferences;
 }

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
//禁用循環(huán)依賴
applicationContext.setAllowCircularReferences(false);
//刷新容器
applicationContext.refresh();
...

//正在創(chuàng)建中的Bean
private final Set<String> singletonsCurrentlyInCreation =
   Collections.newSetFromMap(new ConcurrentHashMap<>(16));
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  ...省略...
  //把該Bean的名字加入 singletonsCurrentlyInCreation 正在創(chuàng)建池 中
  beforeSingletonCreation(beanName);
  boolean newSingleton = false;
  boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  if (recordSuppressedExceptions) {
   this.suppressedExceptions = new LinkedHashSet<>();
  }
  try {
   //調用ObjectFactory創(chuàng)建Bean的實例
   singletonObject = singletonFactory.getObject();
   newSingleton = true;
  }
...省略...

//如果singletonsCurrentlyInCreation中沒該Ｂｅａｎ，就把該Bean存儲到singletonsCurrentlyInCreation中，
//如果 singletonsCurrentlyInCreation 中有 該Bean，就報錯循環(huán)依賴異常BeanCurrentlyInCreationException
//也就意味著同一個beanName進入該方法2次就會拋異常
protected void beforeSingletonCreation(String beanName) {
  if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
  }
 }

 protected Object getSingleton(String beanName, boolean allowEarlyReference) {
     //一級緩存，存儲實例化好的Bean
  Object singletonObject = this.singletonObjects.get(beanName);
  //如果單利緩存池中沒有，但是beanName正在創(chuàng)建
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
   synchronized (this.singletonObjects) {
       //獲取二級緩存，這個里面存儲的是正在創(chuàng)建的Bean,半成品
    singletonObject = this.earlySingletonObjects.get(beanName);
     //如果也為空，但是允許循環(huán)依賴
    if (singletonObject == null && allowEarlyReference) {
     //從三級緩存獲取Bean的創(chuàng)建工廠，
     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
     if (singletonFactory != null) {
        //創(chuàng)建Bean的實例
      singletonObject = singletonFactory.getObject();
      //把Bean存儲到二級緩存
      this.earlySingletonObjects.put(beanName, singletonObject);
       //移除三級緩存中的創(chuàng)建工廠
      this.singletonFactories.remove(beanName);
     }
    }
   }
  }
  return (singletonObject != NULL_OBJECT ? singletonObject : null);
 }

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.
  //緩存中獲取Bean,解決了循環(huán)依賴問題
  Object sharedInstance = getSingleton(beanName);
      ...緩存中沒有走下面...
  if (mbd.isSingleton()) {
     //走 DefaultSingletonBeanRegistry#getSingleton ，方法會把bean加入“正在創(chuàng)建bean池”
     //然后調用ObjectFactory實例化Bean
     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;
      }
     });
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }

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) {
  //實例化Bean
   instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  ...省略...
  //如果是單利 ，如果是允許循環(huán)依賴，如果 beanName 出于創(chuàng)建中，已經被添加到“創(chuàng)建中的bean池”
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
    logger.debug("Eagerly caching bean '" + beanName +
      "' to allow for resolving potential circular references");
   }
   //把ObjectFactory 添加到 singletonFactories 中。
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

 try {
  //走依賴注入流程
   populateBean(beanName, mbd, instanceWrapper);
   exposedObject = initializeBean(beanName, exposedObject, mbd);
  }

//緩存單利Bean的創(chuàng)建工廠，用于解決循環(huán)依賴
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(singletonFactory, "Singleton factory must not be null");
  synchronized (this.singletonObjects) {
   //singletonObjects單利緩存中是否包含Bean
   if (!this.singletonObjects.containsKey(beanName)) {
    //提前暴露ObjectFactory，把ObjectFactory放到singletonFactories中，
    //后面解決循環(huán)依賴，獲取Bean實例的時候會用到
    this.singletonFactories.put(beanName, singletonFactory);
    //早期單利bean緩存中移除Bean
    this.earlySingletonObjects.remove(beanName);
    //把注冊的Bean加入registeredSingletons中
    this.registeredSingletons.add(beanName);
   }
  }
 }

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.
  //從緩存中獲取Bean
  Object sharedInstance = getSingleton(beanName);
  ...省略...
  //如果緩存中沒有Bean，就創(chuàng)建Bean
  if (mbd.isSingleton()) {
     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;
      }
     });
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }

//allowEarlyReference ：是否創(chuàng)建早期應用，主要用來解決循環(huán)依賴
 @Nullable
 protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // Quick check for existing instance without full singleton lock
  //從Map中 singletonObjects = new ConcurrentHashMap<>(256); 獲取單利Bean
  //【一級緩存】singletonObject緩存中是否有Bean , 它存儲的是已經實例化好的Bean
  Object singletonObject = this.singletonObjects.get(beanName);
  //如果singletonObjects中沒有Bean，但是Bean出于正在創(chuàng)建池中，即：Set<String> singletonsCurrentlyInCreation中有Bean，
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

   //【二級緩存】從早期單例對象的緩存 earlySingletonObjects 中獲取
   singletonObject = this.earlySingletonObjects.get(beanName);

   //早期單利對象緩存中也沒有，但是允許循環(huán)依賴
   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) {

       //【三級緩存】獲取ObjectFactory ， 對象創(chuàng)建工廠,得到Bean創(chuàng)建過程中提前暴露的工廠。
       ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
       if (singletonFactory != null) {
        //通過工廠ObjectFactory 獲取對象實例
        singletonObject = singletonFactory.getObject();
        //把對象存儲到早期緩存中
        this.earlySingletonObjects.put(beanName, singletonObject);
        //把ObjectFactory移除
        this.singletonFactories.remove(beanName);
       }
      }
     }
    }
   }
  }
  return singletonObject;
 }