Appearance
3.1-4 循环依赖与三级缓存
所属:03 主流框架 / 3.1 Spring 分级:A 状态:◐ 初稿 关联:3.1-1、3.1-2、3.1-5、3.1-6、3.1-10、3.2-1
题型:原理 / 流程 / 排障
一句话结论:Spring 用三级缓存解决 setter/字段注入的单例循环依赖:一级
singletonObjects放成品,二级earlySingletonObjects放早期引用,三级singletonFactories放ObjectFactory。核心不是“提前 new”,而是 实例化后、属性注入前暴露工厂,让依赖方按需拿到早期引用;必要时由getEarlyBeanReference提前生成 AOP 代理。构造器循环依赖和 prototype 循环依赖默认无解;Boot 2.6+ 默认禁止循环依赖。分层要点:
- 先分类:循环依赖有直接/间接、自依赖、构造器/字段/setter 注入、singleton/prototype 等类型。Spring 只解决 单例 + setter/字段注入 的循环依赖;构造器注入在对象还没实例化时就需要对方,无法提前暴露;prototype 不走单例缓存,也无法提前暴露。
- 一级缓存
singletonObjects:存放完全初始化完成的单例(经过实例化、注入、初始化、BPP after)。getBean首先查它;命中直接返回。FactoryBean的产品不在这个 map,而在factoryBeanObjectCache。 - 二级缓存
earlySingletonObjects:存放早期引用,可能是原始对象,也可能是提前生成的 AOP 代理;它的作用是保证同一个 Bean 在循环依赖中被多次获取时拿到同一个引用,避免重复创建代理/对象。 - 三级缓存
singletonFactories:存放ObjectFactory<?>,通常是() -> getEarlyBeanReference(beanName, mbd, bean)。它把“是否要提前创建代理”延迟到真正发生循环依赖查询时;如果没人提前要,就不触发,避免所有 Bean 都提前代理。 - 解决流程:A 实例化后、
populateBean前,把 A 的ObjectFactory放入三级缓存;A 注入 B 时创建 B;B 注入 A 时getSingleton(A, allowEarlyReference=true)从三级缓存取工厂,调用getEarlyBeanReference得到早期 A,放入二级缓存;B 完成初始化;A 继续注入/初始化,最后放入一级缓存并清理二三级。 - AOP 一致性:
AbstractAutoProxyCreator实现SmartInstantiationAwareBeanPostProcessor,其getEarlyBeanReference会在必要时提前创建代理,并把代理记到earlyProxyReferences;A 初始化后的postProcessAfterInitialization发现已有 early proxy,就返回同一个代理,避免二次代理。不是所有 BPP 都实现这个接口,所以自定义代理/BPP 要特别小心。 - 解决不了的场景:构造器循环依赖(
BeanCurrentlyInCreationException)、prototype 循环依赖(prototypesCurrentlyInCreation)、@DependsOn形成的环、部分非 Smart BPP 创建的代理(循环引用方可能拿到原始对象)、@PostConstruct中过早getBean导致的“半初始化”依赖。 - 工程取舍:
@Lazy/ObjectProvider能打破环,但多数时候是“止痛药”;更好的做法是抽取第三方的协调服务、用事件解耦、调整职责边界。Boot 2.6+ 默认spring.main.allow-circular-references=false,升级后暴露的循环依赖应优先重构,而不是长期打开开关。
图/流程:
text
A、B setter 循环依赖:
getBean(A)
→ createBean(A)
→ createBeanInstance(A) // A 原始对象
→ addSingletonFactory(A, ...) // 三级缓存
→ populateBean(A)
→ 需要 B
→ createBean(B)
→ createBeanInstance(B)
→ addSingletonFactory(B, ...)
→ populateBean(B)
→ 需要 A
→ getSingleton(A, allowEarlyReference=true)
→ 三级缓存取 A 的 ObjectFactory
→ getEarlyBeanReference(A) → 早期 A(可能是代理)
→ 放入二级缓存
→ 早期 A 注入到 B
→ initializeBean(B) → 一级缓存
→ A 注入已就绪的 B
→ initializeBean(A) → 一级缓存text
三级缓存状态:
singletonObjects 成品 Bean
earlySingletonObjects 早期引用(原始对象或 early proxy)
singletonFactories ObjectFactory(按需生成早期引用)text
early proxy 一致性:
A 实例化 → 暴露 ObjectFactory
→ B 依赖 A → getEarlyBeanReference(A)
→ AbstractAutoProxyCreator 创建 early proxy
→ earlyProxyReferences 记录
→ A 初始化后 postProcessAfterInitialization
→ 发现 earlyProxyReferences 有 A
→ 直接返回 early proxy,不再二次代理text
构造器循环依赖:
A 构造器需要 B
→ B 构造器需要 A
→ A 还在 singletonsCurrentlyInCreation
→ 没有 early reference(对象还没实例化)
→ BeanCurrentlyInCreationExceptiontext
prototype 循环依赖:
A prototype 创建中
→ B prototype 创建中
→ 再要 A
→ prototypesCurrentlyInCreation(ThreadLocal)检测到 A
→ BeanCurrentlyInCreationException版本/源码锚点:
- Spring Framework 5.3.x / 6.x:
DefaultSingletonBeanRegistry的singletonObjects、earlySingletonObjects、singletonFactories、singletonsCurrentlyInCreation;getSingleton(String, boolean)、addSingletonFactory、addSingleton、beforeSingletonCreation。 AbstractAutowireCapableBeanFactory#doCreateBean:实例化后、populateBean前调用addSingletonFactory;getEarlyBeanReference遍历SmartInstantiationAwareBeanPostProcessor。AbstractAutoProxyCreator#getEarlyBeanReference、postProcessAfterInitialization、earlyProxyReferences;@Transactional的InfrastructureAdvisorAutoProxyCreator继承AbstractAutoProxyCreator,通常可提前代理。AbstractBeanFactory#doGetBean的 prototype 分支:beforePrototypeCreation/afterPrototypeCreation用ThreadLocal检测 prototype 循环。- Spring Boot 2.6+:
spring.main.allow-circular-references默认false;2.5 及以前默认true。Boot 3 延续默认禁止。 @Lazy、ObjectProvider、@DependsOn、@Scope("prototype")是常见干预点。
- Spring Framework 5.3.x / 6.x:
三级缓存对比:
| 层级 | 结构 | 存放内容 | 何时放入 | 何时清理 | 作用 |
|---|---|---|---|---|---|
| 一级 | singletonObjects | 完整单例 | 初始化完成后 addSingleton | 容器销毁 | 正常 getBean 命中 |
| 二级 | earlySingletonObjects | 早期引用(原始/代理) | 首次从三级工厂取到后 | 放入一级时 | 复用同一早期引用 |
| 三级 | singletonFactories | ObjectFactory | 实例化后、注入前 | 取到二级/放入一级时 | 延迟生成早期引用 |
- 为什么不是两级:
| 方案 | 问题 |
|---|---|
| 只有一级 | 无法在初始化完成前暴露引用,setter 循环依赖无解 |
| 一级 + 二级(直接放原始对象) | B 拿到原始 A,A 最终是代理,B 持有的引用绕过 AOP/事务 |
| 一级 + 二级(立即放代理) | 所有 Bean 都要提前代理,代理创建过早;可能依赖未完成状态;还要处理二次代理 |
| 三级 + 二级 | 工厂按需生成;需要时才提前代理;二级保证同一引用;一级存最终成品 |
- 场景与结论:
| 场景 | 能否解决 | 原因/处理 |
|---|---|---|
| singleton + setter/字段 | 能 | 实例化后暴露 early reference |
| singleton + 构造器 | 默认不能 | 对象未实例化;@Lazy 参数/ObjectProvider/改 setter |
| prototype + 任意注入 | 不能 | 无单例缓存;ObjectProvider/@Lazy/重构 |
| 自依赖(构造器) | 不能 | 同构造器循环;@Lazy 自注入 |
| 自依赖(字段) | 通常能 | early reference;但不建议 |
@DependsOn 成环 | 不能 | 依赖顺序成环;去掉/重构 |
@Async + 循环 | 有风险 | 非 Smart BPP 可能注入原始对象;@Lazy/重构 |
@Transactional + 循环 | 通常能 | auto-proxy creator 是 Smart;自调用仍失效 |
| 自定义 BPP 代理 + 循环 | 取决于实现 | 实现 getEarlyBeanReference 才能提前代理 |
@PostConstruct 中 getBean | 有风险 | 早期引用可能未初始化;移到 ApplicationRunner |
- 常见解决方式:
| 方式 | 原理 | 适用 | 代价 |
|---|---|---|---|
| 改 setter/字段注入 | 实例化后暴露 early reference | 非强制构造器 | 可变性/空指针风险 |
@Lazy 注入点 | 注入代理,首次调用才创建 | 构造器/字段 | 代理、首调用延迟、设计味道 |
ObjectProvider | 延迟获取,不立即解析依赖 | 构造器/原型 | 调用方需显式 getObject |
| 抽取第三 Bean | 消除双向依赖 | 业务允许 | 重构成本 |
| 事件解耦 | 发布/订阅替代直接调用 | 异步/旁路逻辑 | 最终一致/复杂度 |
@DependsOn | 只控制顺序 | 不是循环依赖解决方案 | 可能制造新环 |
allow-circular-references=true | 恢复旧行为 | 临时升级兼容 | 掩盖设计问题 |
- Boot 配置与版本:
| 版本 | 默认 | 配置 |
|---|---|---|
| Boot ≤ 2.5 | 允许循环依赖 | spring.main.allow-circular-references=true |
| Boot 2.6+ | 禁止 | 默认 false;可显式设 true 临时恢复 |
| Boot 3.x | 禁止 | 同上;仍建议重构 |
- 失败与定位:
| 现象 | 原因 | 处理 |
|---|---|---|
BeanCurrentlyInCreationException | 构造器循环/自依赖/prototype 环 | 看 Bean 名与创建栈;改注入方式/@Lazy/重构 |
BeanCreationException(Circular depends-on) | @DependsOn 成环 | 去掉 @DependsOn/重构依赖 |
| 启动日志提示 “currently in creation” | 循环依赖 | 定位 A↔B,画依赖图 |
@Async 不生效 | 循环依赖注入原始对象/自调用 | @Lazy/重构/检查代理 |
@Transactional 不生效 | 自调用/代理未生效/异常被吞 | 拆 Bean/TransactionTemplate/检查代理 |
@PostConstruct NPE | 依赖的早期引用未初始化 | 移到 ApplicationRunner/SmartLifecycle |
| 升级 Boot 2.6 启动失败 | 默认禁止循环依赖 | 重构或临时开关 |
| 开了开关仍失败 | 构造器/prototype 循环 | 三级缓存救不了,必须改结构 |
深挖点(面试官常追的 6 个):
- 为什么需要三级缓存,而不是两级:如果只有一级,初始化完成前拿不到引用,setter 循环依赖无解;如果只有“一级 + 二级”,实例化后就得决定放原始对象还是代理。放原始对象,B 拿到的是未代理的 A,A 最终代理后 B 仍持原始引用,事务/异步失效;放代理,则所有 Bean 都要在注入前提前代理,代理创建过早,还可能二次代理。三级缓存放
ObjectFactory,只在真的发生循环查询时调用getEarlyBeanReference,把“是否提前代理”延迟到需要时;二级缓存再保证同一个早期引用只生成一次。 getEarlyBeanReference与 AOP 一致性:AbstractAutoProxyCreator的getEarlyBeanReference会调用wrapIfNecessary提前生成代理,并记录到earlyProxyReferences;A 初始化完成后,postProcessAfterInitialization发现该 Bean 已有 early proxy,就直接返回它,不再包一层。这样 B 注入的早期 A 和最终一级缓存里的 A 是同一个代理。自定义 BPP 如果也要提前代理,必须实现SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference,否则循环依赖方可能拿到原始对象。- 构造器循环依赖为什么无解:构造器注入发生在
createBeanInstance,对象还没创建,无法放入三级缓存;B 在构造 A 时又需要 A,singletonsCurrentlyInCreation已包含 A,beforeSingletonCreation直接抛BeanCurrentlyInCreationException。解决不是“加大缓存”,而是改注入方式:@Lazy构造参数注入代理、ObjectProvider延迟获取、改 setter,或者重构依赖。 - prototype 为什么不行:prototype 不走
singletonObjects/三级缓存,每次getBean都新建;Spring 用ThreadLocal的prototypesCurrentlyInCreation检测同线程内的 prototype 循环,发现后抛异常。解决同样靠ObjectProvider/@Lazy/重构,不能靠单例缓存。 - Boot 2.6 为什么默认禁止:循环依赖通常是职责边界不清的信号,容易导致半初始化对象、代理不一致、测试困难。Boot 2.6 把
spring.main.allow-circular-references默认改为false,让问题在启动期暴露。临时打开开关可以兼容老系统,但长期应抽取第三方 Bean、用事件解耦、调整分层;@Lazy只是让环“晚一点断”,不是架构修复。 - 循环依赖 + AOP/异步的坑:
@Transactional的 auto-proxy creator 是AbstractAutoProxyCreator子类,能 early proxy,通常 B 拿到的是事务代理;但@Async的AsyncAnnotationBeanPostProcessor在 5.3/6.x 中不是 Smart 类型,循环依赖下 B 可能拿到原始 A,导致异步失效。@PostConstruct里调用依赖方也可能拿到“早期但未初始化”的对象。判断标准不是“有没有报错”,而是“注入的引用是不是最终代理、对象是否已完成初始化”。
- 为什么需要三级缓存,而不是两级:如果只有一级,初始化完成前拿不到引用,setter 循环依赖无解;如果只有“一级 + 二级”,实例化后就得决定放原始对象还是代理。放原始对象,B 拿到的是未代理的 A,A 最终代理后 B 仍持原始引用,事务/异步失效;放代理,则所有 Bean 都要在注入前提前代理,代理创建过早,还可能二次代理。三级缓存放
追问链:
- 什么是循环依赖? → A 依赖 B,B 又依赖 A,形成环。
- 有哪些类型? → 构造器/字段/setter、自依赖、单例/原型、直接/间接。
- Spring 能解决哪些? → 单例 + setter/字段注入。
- 为什么需要三级缓存? → 提前暴露 + 延迟代理 + 保证同一引用。
- 一级缓存存什么? → 完整单例。
- 二级缓存存什么? → 早期引用,可能是原始对象或代理。
- 三级缓存存什么? →
ObjectFactory,不是 Bean。 - 一级何时放入? → 初始化完成后
addSingleton。 - 二级何时放入? → 首次从三级工厂取到早期引用后。
- 三级何时放入? → 实例化后、
populateBean前。 - 为什么不是两级? → 直接放原始对象会绕过 AOP;直接放代理会过早/二次代理。
- 为什么三级是 ObjectFactory? → 延迟到真正需要时再生成早期引用。
getSingleton流程? → 一级 → 二级 → 三级工厂 → 放入二级。addSingletonFactory条件? → 单例 + 允许循环 + 正在创建。getEarlyBeanReference做什么? → 让 Smart BPP 提前生成代理/引用。- AOP 代理何时提前? → 循环依赖查询触发时。
- early proxy 和最终代理如何一致? →
earlyProxyReferences+ after-init 直接返回。 earlyProxyReferences作用? → 避免二次代理。- 构造器循环依赖为什么无解? → 对象未实例化,无 early reference。
- 构造器循环依赖报什么错? →
BeanCurrentlyInCreationException。 @Lazy如何打破? → 注入代理,首次调用才创建目标。ObjectProvider如何打破? → 延迟getObject,不立即解析依赖。- setter 循环依赖一定安全吗? → 不一定,早期引用可能未初始化。
- prototype 循环依赖? → 无单例缓存,
ThreadLocal检测后抛异常。 @Async+ 循环依赖? → 可能注入原始对象,异步失效。@Transactional+ 循环依赖? → 通常 early proxy 可用;自调用仍失效。- 自定义 BPP 代理 + 循环? → 实现
getEarlyBeanReference才能提前代理。 @PostConstruct中 getBean 循环? → 可能拿到半初始化对象,移到 runner。@DependsOn能解决吗? → 不能,只控制顺序,可能成环。- 自注入怎么做? → 字段自注入可能靠 early reference;构造器自注入需
@Lazy。 @Lazy自注入? → 注入自身代理,解决自调用事务。- Boot 2.6 变化? → 默认禁止循环依赖。
- 如何开启? →
spring.main.allow-circular-references=true。 - 为什么不建议长期开? → 掩盖设计问题/半初始化/代理不一致。
- 如何排查? → 看
BeanCurrentlyInCreationException、Bean 名、创建栈、依赖图。 - 如何重构? → 抽第三 Bean、事件、接口下沉、调整分层。
- 事件解耦怎么做? →
ApplicationEventPublisher/@EventListener。 - 循环依赖影响启动性能吗? → 有,提前代理/额外缓存;但主要是设计问题。
- 循环依赖影响内存吗? → 早期引用/代理对象;通常不是主因。
- 三级缓存线程安全吗? → 关键操作在
singletonObjects锁内;集合本身并发/受锁保护。 - 并发 getBean 会怎样? → 单例创建加锁,避免重复创建。
singletonObjects为什么 ConcurrentHashMap? → 读多写少,并发读取。singletonFactories为什么 HashMap? → 访问在锁内,不需要额外并发结构。- FactoryBean 产品在哪个缓存? →
factoryBeanObjectCache,不是singletonObjects。 - 循环依赖与
@Configuration? →@Bean工厂方法参数也可能成环;@Lazy/重构。 - 循环依赖与 AOP 切面顺序? → 早期代理可能受 BPP 顺序影响,保持切面简单。
@Async自调用? → 代理调用才生效;循环依赖不修复自调用。@Transactional自调用? → 同上,需拆 Bean/TransactionTemplate。- 怎么测试循环依赖? → 启动上下文、构造器/字段两种注入、Boot 2.6 默认配置。
- 面试怎么总结? → 三级缓存各存什么 → 为什么不是两级 → early proxy → 构造器/原型无解 → Boot 2.6 默认禁止 → 重构优先。
生产案例/取舍(示例,替换成你的项目):
- 订单服务 ↔ 库存服务字段注入,升级 Boot 2.6 启动失败;抽取
OrderInventoryCoordinator或改事件,消除环。 @Transactional+ setter 循环依赖,B 注入到 early proxy,事务生效;但 B 调用 A 的自调用方法仍无事务。@Async+ 循环依赖,B 拿到原始 A,异步不生效;@Lazy注入或重构后恢复。- 构造器循环依赖,启动报
BeanCurrentlyInCreationException;给构造参数加@Lazy或改 setter。 - prototype 循环依赖,
ThreadLocal检测后抛异常;改ObjectProvider/@Lazy。 @PostConstruct里调用 B,B 又依赖 A,拿到半初始化 A 导致 NPE;移到ApplicationRunner。- 用
@DependsOn想“修”循环依赖,结果形成@DependsOn环;删除并重构。 - 打开
allow-circular-references=true让老系统先启动,排期重构;不长期保留。 - 自定义 BPP 提前代理但未实现
getEarlyBeanReference,循环依赖方拿到原始对象;补实现或调整 BPP。 - 自注入 +
@Lazy解决自调用事务;能工作,但优先拆 Bean。 @Configuration的@Bean方法互相调用形成环;改参数注入/@Lazy/抽配置。- 取舍:
@Lazy换快速解环,代价是代理/首调用延迟/隐藏设计问题;ObjectProvider换显式延迟,代价是调用方复杂度;重构换长期清晰,代价是短期成本;开关换兼容,代价是风险后移。
- 订单服务 ↔ 库存服务字段注入,升级 Boot 2.6 启动失败;抽取
易错点:
- 认为三级缓存能解决构造器循环依赖。
- 认为三级缓存能解决 prototype 循环依赖。
- 认为三级缓存是三个 Bean 对象。
- 认为
singletonFactories存的是 Bean 实例。 - 认为 early reference 一定是最终代理。
- 认为所有 BPP 创建的代理都能 early reference。
- 认为
@Async在循环依赖下一定生效。 - 认为
@Transactional在循环依赖下一定生效或一定失效(取决于代理/自调用)。 - 认为
@Lazy是循环依赖的最佳实践。 - 认为
allow-circular-references=true可以长期使用。 - 认为
@DependsOn能解决循环依赖。 - 认为 setter 循环依赖一定安全。
- 认为
@PostConstruct时依赖已完全初始化。 - 认为
getEarlyBeanReference每次都会创建新代理。 - 认为 early proxy 会被二次代理。
- 认为
singletonObjects在实例化后立即有 Bean。 - 认为
earlySingletonObjects永远存原始对象。 - 认为
@Lazy只延迟 Bean 创建,不影响注入代理。 - 认为
ObjectProvider注入的是 Bean 本身。 - 认为 Boot 2.5 默认禁止循环依赖。
- 认为 Spring 6 取消了三级缓存。
- 认为循环依赖只会发生在两个 Bean 之间。
- 认为字段注入循环依赖一定启动失败。
- 认为
BeanCurrentlyInCreationException一定是循环依赖。 - 认为
@Lazy代理能解决所有 AOP 问题。 - 认为
@PostConstruct里getBean一定安全。 - 认为循环依赖只影响启动,不影响运行时代理。
- 认为打开开关后所有循环依赖都能解决。
30 秒口述稿:
Spring 用三级缓存解决单例的 setter/字段循环依赖:一级放成品,二级放早期引用,三级放
ObjectFactory。A 实例化后、注入前把工厂放进三级;B 依赖 A 时通过getSingleton取工厂,getEarlyBeanReference生成早期引用(必要时提前 AOP 代理),放进二级;B 完成后 A 继续初始化,最后进一级并清理二三级。三级是为了延迟代理决策,二级是为了复用同一引用。构造器和 prototype 循环依赖无解,@Lazy/ObjectProvider可打破;Boot 2.6+ 默认禁止循环依赖,优先重构。
- 3 分钟展开顺序:结论(三级缓存 + 单例 setter/字段)→ 三类缓存各存什么 → A/B 解决时序 → 为什么不是两级 →
getEarlyBeanReference/AOP 一致性 → 构造器/prototype/@DependsOn无解 → Boot 2.6 默认禁止与重构 →@Async/@Transactional/自定义 BPP 的坑 → 排查与取舍。