在Spring框架中，循环依赖（Circular Dependency）是指多个Bean相互依赖，形成一个循环引用。例如，Bean A依赖于Bean B，而Bean B又依赖于Bean A。这种情况在Bean创建时可能导致Spring容器无法正常完成初始化，抛出错误，如下：
public class A {
private final B b;
public A(B b) {
this.b = b;
}
}
public class B {
private final A a;
public B(A a) {
this.a = a;
}
}
启动时会出现如下错误：
org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'A': Requested bean is currently in creation: Is there an unresolvable circular reference?
一、解决循环依赖的方法
1. 构造器注入
构造器注入不支持循环依赖，因为Spring在创建Bean时需要解析所有构造函数参数，这导致了依赖循环。可以通过使用@Lazy注解延迟Bean的初始化来解决此问题，@Lazy会告诉Spring在第一次使用Bean时才初始化，而不是立即初始化。
@Component
public class A {
private final B b;
@Autowired
public A(@Lazy B b) {
this.b = b;
}
}
@Component
public class B {
private final A a;
@Autowired
public B(@Lazy A a) {
this.a = a;
}
}
2. Setter注入
Setter注入可以解决循环依赖，因为Spring可以先创建Bean的实例，再注入其依赖。
public class A {
private B b;
public void setB(B b) {
this.b = b;
}
}
public class B {
private A a;
public void setA(A a) {
this.a = a;
}
}
3. 使用@Autowired注解
可以使用@Autowired进行Setter注入或字段注入，同样可以解决循环依赖问题。
public class A {
@Autowired
private B b;
}
public class B {
@Autowired
private A a;
}
4. 使用@Lazy注解
@Lazy注解可以延迟Bean的初始化，避免循环依赖。
public class A {
@Autowired
@Lazy
private B b;
}
public class B {
@Autowired
@Lazy
private A a;
}
5. 使用ObjectFactory或Provider
使用ObjectFactory或Provider可以在需要时才获取Bean实例，从而解决循环依赖。
public class A {
@Autowired
private ObjectFactory<B> bFactory;
public void someMethod() {
B b = bFactory.getObject();
// 使用B
}
}
public class B {
@Autowired
private ObjectFactory<A> aFactory;
public void someMethod() {
A a = aFactory.getObject();
// 使用A
}
}
6. 配置allow-circular-references: true
通过allow-circular-references: true配置来允许Spring容器处理Bean之间的循环依赖问题，但从设计角度来看，尽量避免循环依赖更为合理。
spring:
main:
allow-circular-references: true
二、Spring三级缓存解决循环依赖的原理
Spring在创建Bean时使用三级缓存来处理循环依赖问题。整个过程分为三个阶段：
- 实例化：创建Bean实例，对应于
AbstractAutowireCapableBeanFactory的createBeanInstance方法。 - 属性注入：为实例化的Bean注入属性，对应于
populateBean方法。 - 初始化：执行Bean的初始化操作，对应于
initializeBean方法，完成AOP代理等。
Spring使用三级缓存的策略如下：
- 一级缓存（singletonObjects）：存储已经完全初始化的单例Bean。
- 二级缓存（earlySingletonObjects）：存储早期的Bean对象，未完全初始化时放入该缓存。
- 三级缓存（singletonFactories）：存储Bean工厂
ObjectFactory，用于创建Bean的早期引用。
缓存的工作流程如下：
- 创建Bean实例：Spring首先尝试从一级缓存
singletonObjects中获取Bean，如果没有则尝试从二级缓存earlySingletonObjects获取。如果依然没有找到，则从三级缓存singletonFactories获取。 - 提前曝光Bean：当Spring检测到循环依赖时，会将Bean的早期引用（通过
ObjectFactory创建的代理对象）放入三级缓存。 - 解决循环依赖：当另一个Bean需要依赖尚未完全初始化的Bean时，Spring会从三级缓存中获取其早期引用，并将其放入二级缓存。
- 完成初始化：当Bean完全初始化后，Spring会将其移至一级缓存，确保Bean的正常使用。
图解分析：对于通过构造器注入相互依赖的两个类A和B，Spring的处理步骤如下：
- 创建A时，因A依赖B，Spring将A的早期引用放入三级缓存。
- 创建B时，因B依赖A，Spring从三级缓存中获取A的早期引用。
- B初始化完成后，B的实例放入一级缓存。
- A随后也完成初始化，并将其实例放入一级缓存。
三、为什么Spring使用三级缓存而不是二级缓存？
-
代理对象的创建：某些场景（如AOP）需要在Bean初始化的后期生成代理对象。如果仅使用二级缓存，代理对象的创建可能会在Bean未完全初始化时进行，导致代理不完整。三级缓存中的
ObjectFactory可以确保在需要时动态生成代理对象。 -
延迟创建早期引用：三级缓存允许Spring延迟创建早期引用，从而在特殊场景下实现灵活的依赖处理，避免了Bean在完全初始化前被错误引用。
三级缓存机制为Spring处理复杂的依赖关系提供了灵活性和可靠性，同时保证了Bean初始化和代理生成的顺序。
