先说结论
Spring 的三级缓存解决的是单例 Bean + 字段注入(setter 注入)的循环依赖,核心思路是"实例化早期就把工厂引用暴露出去"。三类场景依然无解:构造器循环依赖、prototype 作用域循环依赖,以及 Spring Boot 2.6+ 默认关闭了循环依赖支持,出现即启动失败——正确姿势是重构消除依赖,而不是打开开关硬扛。循环依赖本身几乎总是"职责没拆干净"的信号,Spring 给的解法越精巧,越说明这两个 Bean 本不该互相纠缠。
三级缓存是什么
DefaultSingletonBeanRegistry 里的三个 Map:
| 缓存 | 存什么 | 什么时候用 |
|---|---|---|
| singletonObjects(一级) | 完成品单例 Bean | 生命周期走完的 Bean,日常 getBean 直接命中 |
| earlySingletonObjects(二级) | 提前暴露的早期引用(可能是代理) | 发生循环依赖时,工厂产物升级到这里缓存 |
| singletonFactories(三级) | ObjectFactory 工厂,能生产早期引用 | 实例化之后、属性填充之前放入,用完即删 |
三个缓存的分工是"成品、半成品、半成品的生产工厂"。工厂被设计成延迟执行的:放进三级缓存时只是挂了个钩子,只有真的发生循环依赖、别的 Bean 回头找它时,工厂才会被执行一次。
源码入口是 AbstractAutowireCapableBeanFactory#doCreateBean 里的 addSingletonFactory 调用,读取走 getSingleton(String beanName, boolean allowEarlyReference) 的逐级查找:先查一级、再查二级、最后锁单例锁查三级工厂并升级到二级。调试循环依赖问题时,在这两个方法上下断点,整个时序能看得一清二楚,比读十篇文章直观。
A、B 互相依赖的完整时序
- 创建 A:实例化(构造器跑完)后,把"能生产 A 早期引用的 ObjectFactory"放进三级缓存,然后开始属性填充;
- A 注入 B → 触发 getBean(B):B 同样实例化后把工厂放进三级缓存,然后属性填充;
- B 注入 A → getBean(A) →
getSingleton("A")逐级查找:三级缓存命中工厂,调用工厂得到 A 的早期引用(若有 AOP,这里拿到的是代理),把它升级放入二级缓存、删掉三级缓存里的工厂; - B 拿到 A 的引用,完成初始化,成品放入一级缓存;
- A 回到属性填充现场,拿到成品 B,完成初始化,同样放入一级缓存。
注意第 3 步的一个细节:升级到二级缓存后三级工厂就删掉了,保证同一个 Bean 的早期引用至多通过工厂生产一次——如果 A 有 AOP,这个代理只会被创建一次,不会出现两份代理。
这套机制能运转的隐含前提值得点破:B 在第 3 步拿到的,是一个属性填充还没完成的"半成品"引用。字段注入能容忍这一点——引用到手后,等 A 初始化完成,B 里的引用指向的就是同一个已完整的对象;构造器注入做不到,因为构造器要的不是一个"未来才完整"的引用,而是"当下就可用的对象"。这就是无解场景里构造器问题的本质,不是缓存不够多,而是时机上无物可给。
为什么必须是三级,两级不行
如果只有两个缓存,要保证 AOP 正确就得在实例化后立刻给所有 Bean 提前生成代理,这打破了 Spring 的设计原则——代理本应在初始化完成后由 BeanPostProcessor 统一生成。三级缓存的工厂把"是否需要提前代理"的决策推迟到真的发生循环依赖的那一刻:没有循环依赖时,Bean 走正常生命周期,代理照常在初始化后生成且只生成一次;有循环依赖时,只有被依赖的那个 Bean 才走"工厂提前产出代理"的例外路径。两级缓存在功能上能解环,代价是全量 Bean 的代理时机被改变;三级缓存用一层工厂缓存,把例外控制在最小范围——这是"设计原则"与"现实妥协"之间的工程平衡,也是这个问题真正值得理解的点。
无解的三类场景
// 场景一:构造器注入的循环依赖,无解
@Service
public class A {
private final B b; // 构造器注入:实例化阶段就要对方,缓存里还什么都没有
public A(B b) { this.b = b; }
}
- 构造器循环依赖:实例化是依赖注入的前提,构造器还没跑完就没有"早期引用"可暴露,启动直接抛
BeanCurrentlyInCreationException; - prototype 循环依赖:原型 Bean 每次都要新建,没有"单例缓存"这个前提,同样无法解环——A 要 B 的新实例,B 又要 A 的新实例,只能无限递归创建下去;
- Spring Boot 2.6+:
spring.main.allow-circular-references默认 false,循环依赖直接启动报错(官方有意为之,鼓励消灭循环依赖)。
# 迁移期的兜底开关:只建议作为升级过渡,不推荐长期开启
spring:
main:
allow-circular-references: true
重构手法:从依赖环里出来
出现循环依赖时,按优先级依次尝试四种手法:
- 拆出第三个 Bean 承载公共逻辑:A、B 互相调用,往往是因为它们共享了一段谁都不该拥有的逻辑,把它抽成 C,A、B 都依赖 C,环消失;
- 改用事件解耦:A 做完事发布事件,B 监听事件——依赖方向从"双向调用"变成"单向发布 + 被动监听",还能顺带削断同步调用链;
@Lazy错开创建时序:注入的是延迟代理,第一次真正使用时才解析目标,适合确实需要互相持有的场景;注意它是延迟问题而不是消除问题,运行期首次调用仍会触发完整解析;- 依赖倒置:在 A、B 之间定义接口,让依赖指向抽象而不是具体实现,环在实现层断裂。
四种手法不是平级关系:拆第三者和事件解耦是"消除环",@Lazy 和依赖倒置是"绕开环"。消除环的方案有运行期收益——依赖方向更清晰、两边可独立测试;绕开环的方案只是推迟或遮蔽问题,@Lazy 尤其会引入"首次调用才暴露创建问题"的运行期不确定性。代码评审遇到环时按这个优先级谈,比直接争论该用哪个注解更有效。
// 错误写法:OrderService 与 NotifyService 互相字段注入,职责纠缠
@Service
public class OrderService {
@Autowired private NotifyService notifyService; // A -> B
}
@Service
public class NotifyService {
@Autowired private OrderService orderService; // B -> A,环成立
}
// 正确写法:把"订单变更后如何通知"抽成独立协调者,环消失
@Service
public class OrderService {
@Autowired private OrderEventPublisher publisher; // 只依赖事件发布器
public void complete(Order order) {
publisher.publish(new OrderCompletedEvent(order)); // 发布即返回,不感知通知方
}
}
@Service
public class NotifyCoordinator {
// 通知逻辑集中在这里,单向依赖订单领域的契约,不再反向依赖 OrderService
}
生产案例
一个消息回调服务在升级 Spring Boot 2.6 后直接启动失败,报 BeanCurrentlyInCreationException——OrderService 与 NotifyService 互相字段注入,之前一直靠旧版本的默认放行活着。当时有两个选项:打开 allow-circular-references 开关十分钟上线,或者花半天重构。团队选了重构:排查这对 Bean 的调用关系后发现,NotifyService 反向调用 OrderService 只是为了"回调完成后更新订单状态",这段逻辑本属于订单领域;拆出独立的 OrderStatusUpdater 承接该逻辑后,依赖从双向环变成了单向链,启动恢复的同时,两边的单测也第一次可以独立运行——因为互相纠缠的 Bean 连 Mock 都拆不开。回头看,升级报错只是把一笔早就欠下的设计债记在了账面上。
检查清单
- 能完整复述 A、B 互相依赖时三级缓存的五步时序
- 说得清"为什么三级而不是两级":工厂缓存把提前代理的决策推迟到循环依赖真正发生时
- 知道构造器注入与 prototype 作用域的循环依赖无解,遇到直接重构
- Spring Boot 2.6+ 项目里没有通过 allow-circular-references 硬扛的存量环
- 处理循环依赖的优先级固化:拆第三者 > 事件解耦 > @Lazy > 依赖倒置
- 知道 @Lazy 只是延迟解析,运行期首次调用仍会触发完整创建链
- 新代码评审时把"互相注入"当作职责纠缠的设计信号对待