关于Spring源码是如何解决Bean的循环依赖

Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

// 1. 引入依赖，springboot项目只需要这一个依赖即可测试
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
// 2. 两个测试类
@Component
public class TestA {
    @Autowired
    private TestB testB;
}
@Component
public class TestB {
    @Autowired
    private TestA testA;
}

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
  throws BeansException {
 return doGetBean(name, requiredType, args, false);
}

// 
// 2.1 从缓存中获取实例Bean，第一次肯定没有，为null
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
 beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}else{
 // Create bean instance.
 if (mbd.isSingleton()) {
  // 2.2 获取缓存中的实例
  sharedInstance = getSingleton(beanName, () -> {
   try {
    // 2.3 调用创建Bean实例的方法
    return createBean(beanName, mbd, args);
   } 
  });
  beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 }
}

// 3.1
@Override
@Nullable
public Object getSingleton(String beanName) {
 return getSingleton(beanName, true);
}
// 3.2
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 // Quick check for existing instance without full singleton lock
 Object singletonObject = this.singletonObjects.get(beanName);
 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  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) {
      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
      if (singletonFactory != null) {
       singletonObject = singletonFactory.getObject();
       this.earlySingletonObjects.put(beanName, singletonObject);
       this.singletonFactories.remove(beanName);
      }
     }
    }
   }
  }
 }
 return singletonObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 synchronized (this.singletonObjects) {
  Object singletonObject = this.singletonObjects.get(beanName);
  if (singletonObject == null) {
   beforeSingletonCreation(beanName);
   boolean newSingleton = false;
   try {
    // 4.0.1
    singletonObject = singletonFactory.getObject();
    newSingleton = true;
   }
   finally {
    afterSingletonCreation(beanName);
   }
   if (newSingleton) {
    // 4.0.2
    addSingleton(beanName, singletonObject);
   }
  }
  return singletonObject;
 }
}
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 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 Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {  
 try {
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  return beanInstance;
 } 
}
// 看过一些spring源码的都应该明白spring真正做事情的都是以doXXX开头的，这里也不例外
// 相信大家都已经明白真正创建Bean是由doCreateBean方法实现的，下面我们继续分析这个方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
 BeanWrapper instanceWrapper = null;
 if (instanceWrapper == null) {
  instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 Object bean = instanceWrapper.getWrappedInstance();
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences
  && isSingletonCurrentlyInCreation(beanName));
 if (earlySingletonExposure) {
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 }
 Object exposedObject = bean;
 try {
  // 4.3 填充Bean的属性，依赖bean就是这里初始化的
  populateBean(beanName, mbd, instanceWrapper);
  exposedObject = initializeBean(beanName, exposedObject, mbd);
 }
 if (earlySingletonExposure) {
  // 4.4 再次获取缓存中的实例，注意这里可以从两个缓存处获取，第一个是earlySingletonObjects map，第二个是singletonFactories map获取
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
   if (exposedObject == bean) {
    exposedObject = earlySingletonReference;
   }
  }
 }
 return exposedObject;
}
// isSingletonCurrentlyInCreation方法
public boolean isSingletonCurrentlyInCreation(String beanName) {
 return this.singletonsCurrentlyInCreation.contains(beanName);
}
// addSingletonFactory
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);
 }
}