详解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.java

protected 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>
							// 获得 bean
							singletonObject = singletonFactory.getObject();
							// 添加 bean 到 早期单例对象的缓存 中
							this.earlySingletonObjects.put(beanName, singletonObject);
							// 从 singletonFactories 中移除对应的 ObjectFactory
							this.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> 判断是否有后置处理
	// 如果有后置处理，则允许后置处理修改 BeanDefinition
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				// 后置处理修改 BeanDefinition
				applyMergedBeanDefinitionPostProcessors(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 的属性
		// 则会递归初始依赖 bean
		populateBean(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 思否