循环依赖是之前很爱问的一个面试题，最近不咋问了，但是梳理Spring解决循环依赖的源码，会让我们对Spring创建bean的流程有一个清晰的认识，有必要搞一搞。开始搞之前，先参考了这个老哥写的文章，对Spring处理循环依赖有了一个基本的认识之后，然后开始进行源码debug，感谢这位老哥的分享：https://developer.aliyun.com/article/766880
我们搞一个简单的例子，先看看什么是循环依赖，我们只讲最简单的这种，set方法循环依赖，除此之外还有构造器循环依赖，我们讲最简单的这种，其实道理是一样的。
搞一个demo

@Data
@Component
public class TestA {@Autowiredprivate TestB testB;public void getA(){System.out.println("我是getA方法");}
}

@Data
@Component
public class TestB {@Autowiredprivate TestA testA;
}

A依赖B，B依赖A。这样就形成了一个简单的循环依赖。众所周知，Spring解决循环依赖的经典方法是三级缓存，当然还有其他的方法也可以处理，比如懒加载。今天我们只聊三级缓存，其他方式，感兴趣的话，可以自己查一些资料。
如果之前看过Spring的代码，我们就知道，Spring在创建bean之前都会先获取bean，如果获取不到，才会创建bean。所以我们从获取bean开始看起。
获取bean的入口在AbstractBeanFactory的doGetBean方法中。第一行代码，我们先看到从缓存获取bean的流程

// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);

这个方法里，我们想看的三级缓存就全了

protected 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;}

刚开始，这三个缓存里，肯定都没有，父容器中也不会有。所以此时，需要创建A。
创建A的流程也在doGetBean方法里，我们向下看，有这样一段逻辑

// Create bean instance.
if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}catch (BeansException ex) {}});
}

createBean就是创建一个bean，但是这个createBean的过程是getSingleton方法的一个参数，是一个工厂方法，也就是说先执行getSingleton方法，某一个时机下，再触发工厂方法，我们看一下getSingleton的逻辑，我去掉了无关代码。先从一级缓存中获取，如果没有获取到，会触发createBean工厂方法的执行

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {synchronized (this.singletonObjects) {//从一级缓存中获取Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {//一级缓存不存在,执行工厂方法创建beansingletonObject = singletonFactory.getObject();newSingleton = true;//bean创建成功,放入一级缓存if (newSingleton) {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);}}

从上面的逻辑，我们可以得到一个结论，一级缓存的bean已经是创建完成的bean，可以对外提供服务。
接下来，我们继续看工厂方法createBean的流程，创建bean的流程在AbstractAutowireCapableBeanFactory的doCreateBean方法中，我去掉了无关逻辑。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {//初始化bean,相当于new对象操作if (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));//Spring解决循环依赖的核心逻辑if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}//放入三级缓存addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;//对当前bean进行依赖注入populateBean(beanName, mbd, instanceWrapper);//初始化bean,执行bean的一些初始化方法,比如各种aware、实现各种接口啥的。这个流程也有一个经典的面试题,bean的生命周期exposedObject = initializeBean(beanName, exposedObject, mbd);return exposedObject;}

上面就是创建A的具体逻辑，我们画个图梳理一下

创建A的流程中可以看到，在实例化A之后，就执行了放入三级缓存的动作。只要你没有禁止循环依赖，刚实例化的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);}}}

添加进三级缓存的是一个lambda表达式，() -> getEarlyBeanReference(beanName, mbd, bean)，我们经常叫做工厂，那这个工厂方法又是什么时候触发呢?先按下不表，我们继续往下看，A进入三级缓存后，逻辑紧接着就要对A进行依赖注入，A需要依赖注入B，此时要去容器中获取B，获取B的流程和获取A的流程是一样的，获取入口也是AbstractBeanFactory的doGetBean方法，和获取A一样，也执行一遍三级缓存的获取操作，就是getSingleton方法。当然也是没有，所以需要创建B。
创建B的过程和创建A的过程一样。
实例化—>依赖注入—>初始化
我们把B的创建流程也画一下

B的依赖注入，需要注入A，我们需要先获取A，此时就又会走到AbstractBeanFactory的doGetBean的逻辑中。又会执行getSingleton逻辑。

protected 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;}

一级缓存还是没有，二级缓存也没有，但是三级，此时就有了，因为我们创建A的过程中，已经把A先放入了三级缓存。此时从三级缓存中获取出来的工厂方法 “() -> getEarlyBeanReference(beanName, mbd, bean)” 就会触发，拿到A，然后将A放入二级缓存。我们看下这个工厂方法的逻辑里都干了啥

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

以上代码等价于

Object exposedObject = bean;
exposedObject = beanPostProcessor.getEarlyBeanReference(exposedObject, beanName);
return exposedObject;

processor虽然是一个集合，但是真正起作用的processor只有一个，就是AnnotationAwareAspectJAutoProxyCreator，它是通过@EnableAspectJAutoProxy注解导入到bean容器中的，从名字也能看到它是处理AOP的。我们看看这个processor的处理逻辑

@Overridepublic Object getEarlyBeanReference(Object bean, String beanName) {Object cacheKey = getCacheKey(bean.getClass(), beanName);this.earlyProxyReferences.put(cacheKey, bean);//获取AOP代理对象return wrapIfNecessary(bean, beanName, cacheKey);}

实际上就是AOP代理的增强过程
但是，我们的业务代码，不一定都会用到AOP吧。那如果不用AOP的话，容器中就不会有AnnotationAwareAspectJAutoProxyCreator对象，那getEarlyBeanReference方法就可以简化为：

Object exposedObject = bean;
return exposedObject;

相当于工厂方法啥也没干。所以这就是为啥Spring放入三级缓存的是一个工厂方法，而不是立即获取代理对象放入三级缓存，因为在创建A的过程中，并不一定存在循环依赖，如果没有循环依赖，Spring处理AOP增强的逻辑统一在bean创建流程的末尾，就是initializeBean方法中

//对当前bean进行依赖注入populateBean(beanName, mbd, instanceWrapper);//初始化bean,执行bean的一些初始化方法,比如各种aware、实现各种接口啥的。这个流程也有一个经典的面试题,bean的生命周期exposedObject = initializeBean(beanName, exposedObject, mbd);

就是因为Spring也不确认依赖注入过程中是否会有循环依赖，它没办法，只能先暴露一个工厂方法，等到循环依赖真正产生的时候，再执行工厂方法，相当于把AOP增强过程延迟了。
至此，我们小结一下，我们完善一下创建A的流程

此时，我们就拿到了A，虽然不完美，但是已经可以让B的创建流程继续往下走，B创建完成后，将B放入单例池。然后，继续创建A。A完成，放入单例池，结束。Spring的循环依赖就是这样解决的。
下面，我们说2个经典的面试题
1、为什么需要三级缓存，二级缓存可以吗？
不但不可以，而且可能会破坏Spring的整体设计。我们说2种情况。
A是一个AOP对象，对A进行依赖注入前，Spring也不知道会不会存在循环依赖，只能先把A进行AOP增强，放入二级缓存，这样做明显是不合理的，如果后面不存在循环依赖，我们提前搞了一个代理对象，就做了无用功，并且也破坏了Spring的整体设计，因为Spring会在bean创建的末尾统一进行AOP增强，提前搞没有任何意义。有的同学会说，工厂方法确实有必要存在，那二级缓存有必要吗？我只保留一级和三级，不要二级可以吗?那就是下面这道面试题了。
2、只有一级和三级，没有二级可以吗？
猛地一看，二级缓存确实啥也没干，就是存取对象，真实的情况是这样吗？肯定不是的。抛开代码不说，就凭Spring的使用范围如此之广，不可能出现一段无用代码。那二级缓存的作用是什么呢？我举一个例子，你马上就明白了。下面这种场景，二级缓存必须得有。

A依赖B，B依赖A(三级缓存中获取A，将A加入二级缓存)，B依赖C，C依赖A(二级缓存中获取A)，如果没有二级缓存，那我们需要执行两次A的三级缓存工厂方法，如果依赖关系更复杂，可能需要执行多次工厂方法，显然是不合理的，所以Spring的二级缓存很重要。
我们画一下以上循环依赖的处理过程
我标注了序号，你可以按照序号来看一下整个过程，然后自己debug一遍代码，对二级缓存存在的必要会有一个更清洗的认识

我们总结一下Spring三级缓存的作用。
第一级缓存：存放完整的bean对象，这里面的bean已经可以对外提供服务
第二级缓存：已经进行了实例化，但是未完成依赖注入和初始化的对象
第三级缓存：存放工厂方法。提前暴露的一个对象，Spring解决循环依赖的核心所在