彻底理解Spring如何解决循环依赖

/** Cache of singleton objects: bean name to bean instance. */
Map<String, Object> singletonObjects;

/** Cache of early singleton objects: bean name to bean instance. */
Map<String, Object> earlySingletonObjects ;

/** Cache of singleton factories: bean name to ObjectFactory. */
Map<String, ObjectFactory<?>> singletonFactories;

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean(beanName:A)
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName:A)
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName:A, allowEarlyReference:true)

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean(beanName:A)
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName:A, ObjectFactory:lamda表达，调用AbstractBeanFactory#createBean(beanName:A))
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton(beanName:A,singletonObject:A)

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(beanName:A, RootBeanDefinition:mbd, Object[]:args)
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean(beanName:A, RootBeanDefinition:mbd, Object[]:args)
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory(beanName:A, () -> getEarlyBeanReference(beanName:A, mbd, bean:A))
//放入三级缓存，beanName:A -> ObjectFactory( () -> getEarlyBeanReference(beanName:A, mbd, bean:A) )
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean//属性填充
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean //初始化

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
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)) {
}
}
}
}

protected Object doCreateBean( ... ){
...
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
... Object exposedObject = bean; /**
*假如A实例有方法注有@Async注解，A实例依赖B实例，B实例依赖A实例。创建A实例时先走到populateBean方法，然后开始填充属性B实例，B实例也会走到populateBean方法，然后从三级缓存中通过A流程中的getEarlyBeanReference()方法，从而拿到A的早期引用*。执行A的getEarlyBeanReference()方法的时候，会执行自动代理创建器，这里最终得到是可能是原始A对象，也可能是代理后的A对象（注意哦，A实例的@Async注解这里还没有被处理呢）。exposedObject此时指向的是原始A实例。
*/
populateBean(beanName, mbd, instanceWrapper); /**
*标注有@Async的A实例的代理对象在此处会被生成， 参照类：AsyncAnnotationBeanPostProcessor。执行完之后，exposedObject指向的是个代理对象而非原始A实例了。
*/
exposedObject = initializeBean(beanName, exposedObject, mbd); ...
// 这里是报错的重点。
if (earlySingletonExposure) {
/**
*因为A被B循环依赖进去了，所以此时A是被放进了二级缓存的，所以此处earlySingletonReference指向的是通过创建A实例流程中的getEarlyBeanReference()返回的A实例（再强调用一下，可能是原始对象，也可能是代理对象）。
*说到这里，什么情况下earlySingletonReference==null？也就是getSingleton(beanName:A, false)==null，只有当A实例没有牵涉到循环依赖的时候（即不存在A依赖B且B依赖A的场景；单独存在B依赖A是没有问题，A的三级缓存根本不会执行，所以二级缓存就不会有值，A创建并初始化完成之后直接放到了一级缓存）。
*/
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//这里exposedObject指向的是被@Aysnc代理过的对象，而bean是原始对象，所以此处不相等，走else逻辑。
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
/**
*allowRawInjectionDespiteWrapping 标注是否允许此Bean的原始类型被注入到其它Bean里面，即使自己最终会被包装（代理）。
*默认是false表示不允许，如果改为true表示允许，就不会报错啦。这是我们后面讲的决方案的其中一个方案。
*另外dependentBeanMap是记录着每个Bean它所依赖的Bean的Map。
*/
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//因为A依赖于B，所以此处拿到了B实例的beanName
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); /**
*B实例经过removeSingletonIfCreatedForTypeCheckOnly最终返返回false 因为alreadyCreated里面已经有它了表示B已经完全创建完成了。
*既然B实例已经创建完成了，通过创建A实例流程中的getEarlyBeanReference()返回的A实例已经注入到了B实例中，此时B实例注入的和exposedObject指向的不是同一个A实例，那肯定就有问题了。
*/
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.");
}
}
}
}
...
}