Spring 框架中的循环依赖问题及其解决方案
什么是循环依赖？
循环依赖是指在对象间存在互相依赖的关系，形成了一个闭环，导致 Spring 容器无法正确地实例化对象。换句话说，就是两个或多个对象之间，存在直接或间接的相互依赖，造成对象无法在容器初始化时正确地创建。理解这一概念很重要，因为它直接关系到我们如何设计和管理 Spring 应用的对象。
举例说明：
1. 简单循环依赖
在最简单的循环依赖场景中，两个对象直接相互依赖。
class A {
private B b;
// 使用构造器或setter注入 B
public void setB(B b) {
this.b = b;
}
}
class B {
private A a;
// 使用构造器或setter注入 A
public void setA(A a) {
this.a = a;
}
}
在这个例子中，A 依赖 B，而 B 又依赖 A，这就形成了一个简单的循环依赖。如果我们使用 Spring 容器来管理这两个类，Spring 会因为无法找到一个起始点而无法实例化它们。
2. 多层循环依赖
在更复杂的场景中，依赖链可以很长，例如：
class A {
private B b;
public void setB(B b) {
this.b = b;
}
}
class B {
private C c;
public void setC(C c) {
this.c = c;
}
}
class C {
private D d;
public void setD(D d) {
this.d = d;
}
}
class D {
private A a;
public void setA(A a) {
this.a = a;
}
}
在这个例子中，A 依赖 B，B 依赖 C，C 依赖 D，而最终 D 又依赖 A，形成了一个闭环。这个循环依赖问题更加复杂，但本质上与简单循环依赖相同，Spring 容器也无法正确地初始化这些对象。
Spring 如何解决循环依赖问题？
1. Spring 的三级缓存机制（默认解决方案）
Spring 框架采用了三级缓存机制来处理循环依赖，特别是在单例模式下。三级缓存机制的核心思想是通过提前暴露部分对象的代理或早期实例化对象，来解决循环依赖的问题。
三级缓存的工作原理：
- 一级缓存（
singletonObjects）：用于存储已完全初始化的单例对象。 - 二级缓存（
earlySingletonObjects）：用于存储尚未完全初始化，但可以被其他对象依赖的对象。 - 三级缓存（
singletonFactories）：存储一个对象工厂，工厂可以在需要时创建对象实例，通常是代理对象。
代码示例：
public class DefaultSingletonBeanRegistry {
// 一级缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
// 三级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
public Object getSingleton(String beanName) {
// 先从一级缓存中获取
Object singletonObject = singletonObjects.get(beanName);
if (singletonObject == null) {
// 如果一级缓存中没有，则尝试从二级缓存中获取
singletonObject = earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 如果二级缓存中也没有，则尝试通过三级缓存来获取
ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 放入二级缓存，表示已完成部分初始化
earlySingletonObjects.put(beanName, singletonObject);
// 移除三级缓存中的工厂方法
singletonFactories.remove(beanName);
}
}
}
return singletonObject;
}
}
缓存机制解释：
- 当 Spring 容器启动并请求一个 Bean 时，首先从一级缓存中查找该 Bean。如果找不到，则继续查找二级缓存。
- 如果二级缓存也没有，Spring 会创建该 Bean 的工厂（通常是一个代理对象），并把它存储在三级缓存中。这个工厂方法将负责后续的初始化工作。
- 当循环依赖的对象被代理或部分初始化后，它就会被加入到二级缓存中，最终完成初始化并进入一级缓存。
限制：
- Spring 的三级缓存机制只适用于 单例模式 下的 setter 或字段注入。如果是 原型模式 或 构造器注入，则无法解决循环依赖。
- 通过三级缓存机制，Spring 只解决了对象的部分初始化，但并没有完全解决设计上的循环依赖问题。
2. 使用 @Lazy 注解（延迟加载）
@Lazy 注解可以让我们延迟初始化某个依赖，避免在启动时直接加载，从而避免循环依赖问题。
@Component
public class A {
@Autowired
@Lazy
private B b;
public A() {
System.out.println("A is created");
}
}
@Component
public class B {
@Autowired
private A a;
public B() {
System.out.println("B is created");
}
}
原理：
- 通过在类 A 中对 B 进行
@Lazy注解，Spring 容器在实例化 A 时不会立即去实例化 B。只有在 A 需要使用 B 时，Spring 才会创建 B。 - 这种方式有效避免了因两个对象相互依赖导致的初始化冲突。
3. 从设计层面避免循环依赖
尽管 Spring 提供了机制来解决循环依赖，但从根本上解决循环依赖问题，需要优化代码设计，减少紧密耦合关系。
-
明确职责分离：通过拆分业务逻辑，将复杂的循环依赖关系拆解成更简单的组件，减少类之间的紧耦合。
class A { private Service service; } class B { private Service service; } class Service { private A a; private B b; }通过引入中间服务类，可以避免 A 和 B 直接相互依赖，从而消除循环依赖。
-
使用接口减少复杂性：通过定义接口，将 A、B 类与
Service解耦，避免直接依赖。interface CommonService { void execute(); } class A implements CommonService { public void execute() { System.out.println("A executed"); } } class B { private CommonService commonService; }
4. 特殊情况下的其他处理方法
如果循环依赖是不可避免的，例如由于第三方库的引入，或者存在较为复杂的依赖关系，可以尝试以下方法：
-
使用代理对象：通过 AOP 或动态代理技术，在运行时懒加载依赖，从而避免循环依赖。
-
手动控制 Bean 的加载顺序：在
@Configuration配置类中手动注入 Bean，避免自动装配时发生循环依赖。
总结
- Spring 的三级缓存机制：通过提前暴露对象或工厂方法，解决单例模式下的循环依赖问题，适用于 setter 注入。
@Lazy注解：通过延迟加载某些依赖，避免循环依赖的发生。- 从设计层面优化：通过解耦、分离职责，避免不必要的循环依赖。
- 特殊场景下的应对措施：如使用代理对象、手动注入等方式应对复杂的循环依赖问题。
在 Spring 开发中，最根本的解决方案是通过优化设计来杜绝循环依赖问题。良好的设计不仅有助于消除循环依赖，还能显著提高系统的可维护性和稳定性。
