spring boot 通过三级缓存机制解决单例 bean 的循环依赖问题,核心在于允许在 bean 初始化早期暴露一个 objectfactory 或提前引用的代理对象,从而打破实例化与属性填充之间的死锁。具体做法是确保涉及的 bean 均为单例(singleton)作用域,且循环依赖仅发生在构造器注入之外(即使用字段注入或 setter 注入),因为 spring 无法通过构造器参数解析来解决循环引用。若必须使用构造器注入,需借助 @lazy 注解延迟加载其中一个依赖,或者重构代码消除循环依赖。

为什么构造器注入会导致循环依赖报错
当两个或多个 Bean 之间通过构造器相互依赖时,Spring 容器在实例化第一个 Bean 时需要先创建其依赖的第二个 Bean,而第二个 Bean 又需要第一个 Bean,导致无限递归并抛出 BeanCurrentlyInCreationException。这是因为构造器注入要求所有依赖在 Bean 完全创建前就必须就绪,Spring 无法在构造器执行期间“提前暴露”一个未完成的 Bean 实例供其他 Bean 引用。相比之下,字段注入和 Setter 注入允许 Bean 实例先被创建并放入缓存,随后再进行属性填充,从而为循环依赖提供了突破口。

package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ServiceA {
@Autowired
private ServiceB serviceB;
public void doSomething() {
System.out.println("ServiceA doing something");
serviceB.doOther();
}
}
@Component
public class ServiceB {
@Autowired
private ServiceA serviceA;
public void doOther() {
System.out.println("ServiceB doing other");
serviceA.doSomething();
}
}
上述代码展示了典型的字段注入循环依赖场景。ServiceA 和 ServiceB 互相持有对方的引用。在启动应用时,Spring 会先实例化 ServiceA,将其放入 singletonObjects 缓存。接着发现 ServiceA 依赖 ServiceB,于是尝试创建 ServiceB。在创建 ServiceB 时,发现它依赖 ServiceA,此时 Spring 从 earlySingletonObjects 缓存中获取 ServiceA 的早期引用(可能是原始对象或代理),从而成功完成 ServiceB 的创建。最后 ServiceA 的属性填充完成,整个循环依赖得以解决。这种机制依赖于 Spring 的三级缓存:singletonObjects(完整 Bean)、earlySingletonObjects(早期引用)和 singletonFactories(工厂对象)。
@Lazy 注解如何打破构造器注入的死锁
对于必须使用构造器注入的场景,可以通过在其中一个依赖上添加 @Lazy 注解来解决问题。@Lazy 会告诉 Spring 容器不要立即注入真实的 Bean 实例,而是注入一个代理对象。这个代理对象在第一次被调用时才会触发真实 Bean 的初始化。这样,在构造器执行阶段,Spring 只需要创建一个代理对象即可满足依赖,从而避免了在构造器执行期间陷入无限递归。需要注意的是,@Lazy 引入的代理对象可能影响类型匹配,如果接口和实现类之间存在复杂继承关系,可能需要配合 CGLIB 或 JDK 动态代理配置使用。
package com.example.demo;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
@Component
public class ConstructorServiceA {
private final ConstructorServiceB serviceB;
public ConstructorServiceA(@Lazy ConstructorServiceB serviceB) {
this.serviceB = serviceB;
}
public void execute() {
System.out.println("ConstructorServiceA executing");
serviceB.run();
}
}
@Component
public class ConstructorServiceB {
private final ConstructorServiceA serviceA;
public ConstructorServiceB(ConstructorServiceA serviceA) {
this.serviceA = serviceA;
}
public void run() {
System.out.println("ConstructorServiceB running");
serviceA.execute();
}
}
在这个构造器注入的例子中,ConstructorServiceA 的构造器参数被 @Lazy 修饰。当 Spring 容器尝试创建 ConstructorServiceA 时,它会先创建一个 ConstructorServiceB 的代理对象传入构造器。ConstructorServiceA 成功实例化后,再处理 ConstructorServiceB 的创建。ConstructorServiceB 的构造器需要 ConstructorServiceA,此时 Spring 可以直接从缓存中获取已创建的 ConstructorServiceA 实例(因为 ConstructorServiceA 已经完成了实例化,只是属性尚未填充,但构造器注入不需要属性填充)。这样,两者都能成功创建。当业务逻辑首次调用 serviceB.run() 时,代理对象才会触发 ConstructorServiceB 的真实初始化,进而调用 serviceA.execute(),此时 ConstructorServiceA 已经完全可用。
循环依赖中 AOP 代理对象的介入时机
当循环依赖的 Bean 涉及 AOP 代理时,Spring 的三级缓存机制显得尤为重要。如果 Bean 被标记为需要代理(例如使用了 @Transactional 或自定义切面),Spring 需要在 Bean 初始化完成后创建代理对象。但在循环依赖场景中,如果直接在初始化后创建代理,可能会导致另一个 Bean 拿到的是未代理的原始对象。因此,Spring 在 earlySingletonObjects 中存储的是经过 SmartInstantiationAwareBeanPostProcessor 处理后的早期引用。如果该 Bean 需要代理,SmartInstantiationAwareBeanPostProcessor 会在早期就生成代理对象并将其放入缓存,确保其他 Bean 拿到的是正确的代理实例。这一过程确保了即使存在循环依赖,最终注入的也是具备完整功能的代理对象,而非原始对象。


















