文章目录
- 1. 什么是循环依赖
- 2. Spring怎么解决循环依赖
- 3. 无法处理的循环依赖
1. 什么是循环依赖
Spring 中的循环依赖是指两个或多个 Bean 之间相互依赖，形成一个循环引用的情况。在 Spring 容器中，循环依赖通常指的是单例（Singleton）作用域的 Bean 之间的循环引用。
循环依赖可能会导致以下问题：
1.提前暴露不完整的 Bean：如果 A 依赖于 B，而 B 又依赖于 A，那么在初始化过程中，A 可能会拿到一个尚未完成初始化的 B 对象，导致对象状态不完整或不一致。
2.无限循环：如果循环依赖链路过长或者存在循环引用关系，可能会导致 Bean 初始化的时候发生死循环，最终导致堆栈溢出。
2. Spring怎么解决循环依赖
Spring 解决循环依赖的机制主要基于三级缓存和提前曝露半初始化的 Bean 的思想。具体步骤如下：
1.实例化对象并放入缓存
当 Spring 容器创建 Bean 时，会先实例化对象，然后将对象放入第一级缓存（singletonObjects）中。此时对象还未完全初始化。
2.设置对象引用
Spring 将对象放入第二级缓存（earlySingletonObjects），并设置对象的引用。这时候对象已经可以被其他对象引用，但仍未完成初始化。
3.提前曝光半初始化的 Bean
如果 Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A，Spring 在创建 Bean A 时，会提前曝光一个半初始化的 Bean A 到第二级缓存中。这个半初始化的 Bean A 具有 Bean A 的代理对象，可以提供给 Bean B 使用。
4.完成 Bean 的初始化
Spring 继续初始化 Bean B，当 Bean B 初始化完成后，Spring 再回头来完成 Bean A 的初始化。这时，Bean A 已经可以通过代理对象访问到 Bean B。
5.将对象移至第三级缓存
当 Bean A 和 Bean B 都初始化完成后，Spring 将它们从第二级缓存移动到第三级缓存（singletonFactories）中，同时清除第一级和第二级缓存中的对象。
public class DefaultSingletonBeanRegistry {
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(64); // 第一级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 第二级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 第三级缓存
public Object getSingleton(String beanName) {
// 1. 从第一级缓存中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject != null) {
return singletonObject;
}
// 2. 从第二级缓存中获取对象
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject != null) {
return singletonObject;
}
// 3. 从第三级缓存中获取对象工厂，并使用工厂创建对象
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
synchronized (this.singletonObjects) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
// 4. 完成 Bean 的初始化
initializeBean(beanName, singletonObject);
// 5. 将对象移至第一级缓存
addToSingletons(beanName, singletonObject);
return singletonObject;
}
return null;
}
private void initializeBean(String beanName, Object singletonObject) {
// 初始化 Bean 的逻辑，包括填充属性、调用初始化方法等
}
private void addToSingletons(String beanName, Object singletonObject) {
this.singletonObjects.put(beanName, singletonObject);
}
}
在这段代码中，模拟了 Spring 的 DefaultSingletonBeanRegistry 类，其中包含了三级缓存 singletonObjects、earlySingletonObjects 和 singletonFactories。当获取单例 Bean 时，首先会从第一级缓存中获取，如果没有找到则尝试从第二级缓存中获取，如果还没有则尝试从第三级缓存中获取对象工厂，并使用工厂创建对象。创建过程中会将对象暂时放入第二级缓存中，等待完成初始化后再移至第一级缓存中。
3. 无法处理的循环依赖
Spring 的循环依赖处理机制无法处理以下两种情况：
1.构造器循环依赖
如果 Bean A 的构造函数依赖于 Bean B，而 Bean B 的构造函数又依赖于 Bean A，则无法通过 Spring 的循环依赖处理机制解决。这是因为在创建 Bean 的过程中，构造函数的调用是在对象实例化之前发生的，此时无法确定构造函数所需的依赖对象是否已经创建，从而导致循环依赖无法被解决。
// BeanA.java
public class BeanA {
private BeanB beanB;
public BeanA(BeanB beanB) {
this.beanB = beanB;
}
}
// BeanB.java
public class BeanB {
private BeanA beanA;
public BeanB(BeanA beanA) {
this.beanA = beanA;
}
}
BeanA 的构造函数依赖于 BeanB，而 BeanB 的构造函数又依赖于 BeanA，构成了构造器循环依赖。
2.原型 Bean 属性注入循环依赖
对于原型（prototype）作用域的 Bean，Spring 容器在创建时不会缓存对象实例，而是在每次请求时都会创建一个新的实例。因此，如果原型 Bean A 的某个属性依赖于原型 Bean B，而 Bean B 的某个属性又依赖于 Bean A，这种循环依赖无法通过 Spring 的循环依赖处理机制解决。这是因为 Spring 容器无法在创建原型 Bean 时提前暴露半初始化的对象，也无法缓存原型 Bean 的实例。
// PrototypeBeanA.java
@Scope("prototype")
public class PrototypeBeanA {
private PrototypeBeanB beanB;
public void setBeanB(PrototypeBeanB beanB) {
this.beanB = beanB;
}
}
// PrototypeBeanB.java
@Scope("prototype")
public class PrototypeBeanB {
private PrototypeBeanA beanA;
public void setBeanA(PrototypeBeanA beanA) {
this.beanA = beanA;
}
}
PrototypeBeanA 的属性 beanB 依赖于 PrototypeBeanB，而 PrototypeBeanB 的属性 beanA 又依赖于 PrototypeBeanA，构成了原型 Bean 属性注入循环依赖。
