详解Spring循环依赖

一. 什么是循环依赖

循环依赖，就是两个或则两个以上的bean互相依赖对方，最终形成闭环。比如“A对象依赖B对象，而B对象也依赖A对象”，或者“A对象依赖B对象，B对象依赖C对象，C对象依赖A对象”；类似以下代码：

public class A {private B b;
}public class B {private A a;
}

常规情况下，会出现以下情况：

通过构建函数创建A对象（A对象是半成品，还没注入属性和调用init方法）。
A对象需要注入B对象，发现对象池（缓存）里还没有B对象（对象在创建并且注入属性和初始化完成之后，会放入对象缓存里）。
通过构建函数创建B对象（B对象是半成品，还没注入属性和调用init方法）。
B对象需要注入A对象，发现对象池里还没有A对象。
创建A对象，循环以上步骤。

Spring 循环依赖的场景有两种：

构造器的循环依赖。
field 属性的循环依赖。

对于构造器的循环依赖，Spring 是无法解决的，只能抛出 BeanCurrentlyInCreationException 异常表示循环依赖，所以下面我们分析的都是基于 field 属性的循环依赖。

Spring 只解决 scope 为 singleton 的循环依赖。对于scope 为 prototype 的 bean ，Spring 无法解决，直接抛出 BeanCurrentlyInCreationException 异常。

二. 解决循环依赖

Spring创建Bean的过程中会用到三级缓存：

// DefaultSingletonBeanRegistry.java/*** 一级缓存，存放可用的成品Bean。* 对应关系为 bean name --> bean instance*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/*** 二级缓存，存放半成品的Bean，半成品的Bean是已创建对象，但是未注入属性和初始化。用以解决循环依赖。* 对应关系也是 bean name --> bean instance。*/
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);/*** 三级缓存，存的是Bean工厂对象，用来生成半成品的Bean并放入到二级缓存中。用以解决循环依赖。* 对应关系是 bean name --> ObjectFactory*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

要了解解决循环依赖的原理，得从Bean的创建过程说起：

// AbstractBeanFactory.java
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly){//<1> 从缓存中或者实例工厂中获取 Bean 对象Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {...}else {....if (mbd.isSingleton()) {// <3> 将创建好的Bean实例放入一级缓存sharedInstance = getSingleton(beanName, () -> {try {// <2> bean 实例化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.// 显式从单例缓存中删除 Bean 实例// 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它。destroySingleton(beanName);throw ex;}});beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}...  }
}

<1> 首先尝试从三级缓存中获取实例
<2> 如果三级缓存都没有获取到bean实例，则说明需要创建该实例，则进行bean的实例化
<3> 将创建好的实例，放入一级缓存中

2.1 从缓存中获取Bean

从三级缓存中读取实例的代码如下：

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.javaprotected Object getSingleton(String beanName, boolean allowEarlyReference) {// Quick check for existing instance without full singleton lock// 从单例缓冲中加载 bean（一级缓存）Object singletonObject = this.singletonObjects.get(beanName);// 缓存中的 bean 为空，且当前 bean 正在创建if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 二级缓存singletonObject = this.earlySingletonObjects.get(beanName);// 如果earlySingletonObjects 中没有，且允许提前创建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) {// 从 singletonFactories 中获取对应的 ObjectFactory（三级缓存）ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {//<1.1>// 获得 beansingletonObject = singletonFactory.getObject();// 添加 bean 到 早期单例对象的缓存 中this.earlySingletonObjects.put(beanName, singletonObject);// 从 singletonFactories 中移除对应的 ObjectFactorythis.singletonFactories.remove(beanName);}}}}}}return singletonObject;
}

<1.1>处，如果从三级缓存中获取到实例后，就会放入二级缓存，并删除三级缓存。

2.2 实例化Bean

<2>处，如果三级缓存都没有获取到bean实例，则说明需要创建该实例，则进行bean的实例化，代码如下：

//org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {....try {// <2.1> 创建 Bean 对象Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName + "'");}return beanInstance;}....
}

调用doCreateBean方法创建实例：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {...// <2.1.1> 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化if (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}...// <2.1.2> 判断是否有后置处理// 如果有后置处理，则允许后置处理修改 BeanDefinitionsynchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {// 后置处理修改 BeanDefinitionapplyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed = true;}}// <2.1.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");}// 提前将创建的 bean 实例加入到 singletonFactories（三级缓存） 中 // 这里是为了后期避免循环依赖addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// 开始初始化 bean 实例对象Object exposedObject = bean;try {// <2.1.4> 对 bean 进行填充，将各个属性值注入，其中，可能存在依赖于其他 bean 的属性// 则会递归初始依赖 beanpopulateBean(beanName, mbd, instanceWrapper);// <2.1.5> 调用初始化方法exposedObject = initializeBean(beanName, exposedObject, mbd);}...return exposedObject;
}

该方法整体流程比较复杂，详细逻辑可以参考《创建Bean的流程》，但是整体流程如下：

<2.1.1> 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
<2.1.2> 后置处理
<2.1.3> 判断是否提前曝光，如果提前曝光，则将当前Bean的ObjectFactory放入三级缓存中。
<2.1.4> 对 bean 进行填充，其中，如果依赖于其他 bean 的属性，则会递归调用getBean创建依赖的实例。
<2.1.5> 调用初始化方法

解决循环依赖非常关键的一步就是<2.1.3>，将当前刚创建好的Bean实例（未初始化），封装成ObjectFactory，放入三级缓存中：

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
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);}}
}

2.3 将创建好的Bean实例放入一级缓存

<3>处，将创建好的实例，放入一级缓存中，代码如下：

 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");// 全局锁synchronized (this.singletonObjects) {...try {// <3.1> 初始化 bean// 这个过程其实是调用 createBean() 方法（策略模式，具体的创建逻辑由传入的ObjectFactory决定）singletonObject = singletonFactory.getObject();newSingleton = true;}...// <3.2> 加入一级缓存中if (newSingleton) {addSingleton(beanName, singletonObject);}return singletonObject;}}

<3.1>，调用<2>处的代码创建实例，详见《2.2 实例化Bean》
<3.2>，由于<2>处的代码创建的实例已经是初始化完成的，所以在此处将Bean实例加入一级缓存中。

2.4 整体流程

2.5 循环依赖流程

我们以最简单的循环依赖为例，A、B两个类都互相依赖对方：

public class A {private B b;
}public class B {private A a;
}

假如Spring容器启动时，先加载A，那么A、B循环依赖初始化流程如下图所示：

本文参考至：

Spring为什么不使用二级缓存？Spring 动态代理时是如何解决循环依赖的？为什么要使用三级缓存？… - 知乎 (zhihu.com)

Spring循环依赖三级缓存是否可以去掉第三级缓存？ - SegmentFault 思否