Skip to content

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+ 默认禁止循环依赖。

  • 分层要点:

    1. 先分类:循环依赖有直接/间接、自依赖、构造器/字段/setter 注入、singleton/prototype 等类型。Spring 只解决 单例 + setter/字段注入 的循环依赖;构造器注入在对象还没实例化时就需要对方,无法提前暴露;prototype 不走单例缓存,也无法提前暴露。
    2. 一级缓存 singletonObjects:存放完全初始化完成的单例(经过实例化、注入、初始化、BPP after)。getBean 首先查它;命中直接返回。FactoryBean 的产品不在这个 map,而在 factoryBeanObjectCache。
    3. 二级缓存 earlySingletonObjects:存放早期引用,可能是原始对象,也可能是提前生成的 AOP 代理;它的作用是保证同一个 Bean 在循环依赖中被多次获取时拿到同一个引用,避免重复创建代理/对象。
    4. 三级缓存 singletonFactories:存放 ObjectFactory<?>,通常是 () -> getEarlyBeanReference(beanName, mbd, bean)。它把“是否要提前创建代理”延迟到真正发生循环依赖查询时;如果没人提前要,就不触发,避免所有 Bean 都提前代理。
    5. 解决流程:A 实例化后、populateBean 前,把 A 的 ObjectFactory 放入三级缓存;A 注入 B 时创建 B;B 注入 A 时 getSingleton(A, allowEarlyReference=true) 从三级缓存取工厂,调用 getEarlyBeanReference 得到早期 A,放入二级缓存;B 完成初始化;A 继续注入/初始化,最后放入一级缓存并清理二三级。
    6. AOP 一致性:AbstractAutoProxyCreator 实现 SmartInstantiationAwareBeanPostProcessor,其 getEarlyBeanReference 会在必要时提前创建代理,并把代理记到 earlyProxyReferences;A 初始化后的 postProcessAfterInitialization 发现已有 early proxy,就返回同一个代理,避免二次代理。不是所有 BPP 都实现这个接口,所以自定义代理/BPP 要特别小心。
    7. 解决不了的场景:构造器循环依赖(BeanCurrentlyInCreationException)、prototype 循环依赖(prototypesCurrentlyInCreation)、@DependsOn 形成的环、部分非 Smart BPP 创建的代理(循环引用方可能拿到原始对象)、@PostConstruct 中过早 getBean 导致的“半初始化”依赖。
    8. 工程取舍:@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(对象还没实例化)
      → BeanCurrentlyInCreationException
text
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") 是常见干预点。
  • 三级缓存对比:

层级结构存放内容何时放入何时清理作用
一级singletonObjects完整单例初始化完成后 addSingleton容器销毁正常 getBean 命中
二级earlySingletonObjects早期引用(原始/代理)首次从三级工厂取到后放入一级时复用同一早期引用
三级singletonFactoriesObjectFactory实例化后、注入前取到二级/放入一级时延迟生成早期引用
  • 为什么不是两级:
方案问题
只有一级无法在初始化完成前暴露引用,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 个):

    1. 为什么需要三级缓存,而不是两级:如果只有一级,初始化完成前拿不到引用,setter 循环依赖无解;如果只有“一级 + 二级”,实例化后就得决定放原始对象还是代理。放原始对象,B 拿到的是未代理的 A,A 最终代理后 B 仍持原始引用,事务/异步失效;放代理,则所有 Bean 都要在注入前提前代理,代理创建过早,还可能二次代理。三级缓存放 ObjectFactory,只在真的发生循环查询时调用 getEarlyBeanReference,把“是否提前代理”延迟到需要时;二级缓存再保证同一个早期引用只生成一次。
    2. getEarlyBeanReference 与 AOP 一致性:AbstractAutoProxyCreator 的 getEarlyBeanReference 会调用 wrapIfNecessary 提前生成代理,并记录到 earlyProxyReferences;A 初始化完成后,postProcessAfterInitialization 发现该 Bean 已有 early proxy,就直接返回它,不再包一层。这样 B 注入的早期 A 和最终一级缓存里的 A 是同一个代理。自定义 BPP 如果也要提前代理,必须实现 SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference,否则循环依赖方可能拿到原始对象。
    3. 构造器循环依赖为什么无解:构造器注入发生在 createBeanInstance,对象还没创建,无法放入三级缓存;B 在构造 A 时又需要 A,singletonsCurrentlyInCreation 已包含 A,beforeSingletonCreation 直接抛 BeanCurrentlyInCreationException。解决不是“加大缓存”,而是改注入方式:@Lazy 构造参数注入代理、ObjectProvider 延迟获取、改 setter,或者重构依赖。
    4. prototype 为什么不行:prototype 不走 singletonObjects/三级缓存,每次 getBean 都新建;Spring 用 ThreadLocal 的 prototypesCurrentlyInCreation 检测同线程内的 prototype 循环,发现后抛异常。解决同样靠 ObjectProvider/@Lazy/重构,不能靠单例缓存。
    5. Boot 2.6 为什么默认禁止:循环依赖通常是职责边界不清的信号,容易导致半初始化对象、代理不一致、测试困难。Boot 2.6 把 spring.main.allow-circular-references 默认改为 false,让问题在启动期暴露。临时打开开关可以兼容老系统,但长期应抽取第三方 Bean、用事件解耦、调整分层;@Lazy 只是让环“晚一点断”,不是架构修复。
    6. 循环依赖 + AOP/异步的坑:@Transactional 的 auto-proxy creator 是 AbstractAutoProxyCreator 子类,能 early proxy,通常 B 拿到的是事务代理;但 @Async 的 AsyncAnnotationBeanPostProcessor 在 5.3/6.x 中不是 Smart 类型,循环依赖下 B 可能拿到原始 A,导致异步失效。@PostConstruct 里调用依赖方也可能拿到“早期但未初始化”的对象。判断标准不是“有没有报错”,而是“注入的引用是不是最终代理、对象是否已完成初始化”。
  • 追问链:

    1. 什么是循环依赖? → A 依赖 B,B 又依赖 A,形成环。
    2. 有哪些类型? → 构造器/字段/setter、自依赖、单例/原型、直接/间接。
    3. Spring 能解决哪些? → 单例 + setter/字段注入。
    4. 为什么需要三级缓存? → 提前暴露 + 延迟代理 + 保证同一引用。
    5. 一级缓存存什么? → 完整单例。
    6. 二级缓存存什么? → 早期引用,可能是原始对象或代理。
    7. 三级缓存存什么? → ObjectFactory,不是 Bean。
    8. 一级何时放入? → 初始化完成后 addSingleton。
    9. 二级何时放入? → 首次从三级工厂取到早期引用后。
    10. 三级何时放入? → 实例化后、populateBean 前。
    11. 为什么不是两级? → 直接放原始对象会绕过 AOP;直接放代理会过早/二次代理。
    12. 为什么三级是 ObjectFactory? → 延迟到真正需要时再生成早期引用。
    13. getSingleton 流程? → 一级 → 二级 → 三级工厂 → 放入二级。
    14. addSingletonFactory 条件? → 单例 + 允许循环 + 正在创建。
    15. getEarlyBeanReference 做什么? → 让 Smart BPP 提前生成代理/引用。
    16. AOP 代理何时提前? → 循环依赖查询触发时。
    17. early proxy 和最终代理如何一致? → earlyProxyReferences + after-init 直接返回。
    18. earlyProxyReferences 作用? → 避免二次代理。
    19. 构造器循环依赖为什么无解? → 对象未实例化,无 early reference。
    20. 构造器循环依赖报什么错? → BeanCurrentlyInCreationException。
    21. @Lazy 如何打破? → 注入代理,首次调用才创建目标。
    22. ObjectProvider 如何打破? → 延迟 getObject,不立即解析依赖。
    23. setter 循环依赖一定安全吗? → 不一定,早期引用可能未初始化。
    24. prototype 循环依赖? → 无单例缓存,ThreadLocal 检测后抛异常。
    25. @Async + 循环依赖? → 可能注入原始对象,异步失效。
    26. @Transactional + 循环依赖? → 通常 early proxy 可用;自调用仍失效。
    27. 自定义 BPP 代理 + 循环? → 实现 getEarlyBeanReference 才能提前代理。
    28. @PostConstruct 中 getBean 循环? → 可能拿到半初始化对象,移到 runner。
    29. @DependsOn 能解决吗? → 不能,只控制顺序,可能成环。
    30. 自注入怎么做? → 字段自注入可能靠 early reference;构造器自注入需 @Lazy。
    31. @Lazy 自注入? → 注入自身代理,解决自调用事务。
    32. Boot 2.6 变化? → 默认禁止循环依赖。
    33. 如何开启? → spring.main.allow-circular-references=true。
    34. 为什么不建议长期开? → 掩盖设计问题/半初始化/代理不一致。
    35. 如何排查? → 看 BeanCurrentlyInCreationException、Bean 名、创建栈、依赖图。
    36. 如何重构? → 抽第三 Bean、事件、接口下沉、调整分层。
    37. 事件解耦怎么做? → ApplicationEventPublisher/@EventListener。
    38. 循环依赖影响启动性能吗? → 有,提前代理/额外缓存;但主要是设计问题。
    39. 循环依赖影响内存吗? → 早期引用/代理对象;通常不是主因。
    40. 三级缓存线程安全吗? → 关键操作在 singletonObjects 锁内;集合本身并发/受锁保护。
    41. 并发 getBean 会怎样? → 单例创建加锁,避免重复创建。
    42. singletonObjects 为什么 ConcurrentHashMap? → 读多写少,并发读取。
    43. singletonFactories 为什么 HashMap? → 访问在锁内,不需要额外并发结构。
    44. FactoryBean 产品在哪个缓存? → factoryBeanObjectCache,不是 singletonObjects。
    45. 循环依赖与 @Configuration? → @Bean 工厂方法参数也可能成环;@Lazy/重构。
    46. 循环依赖与 AOP 切面顺序? → 早期代理可能受 BPP 顺序影响,保持切面简单。
    47. @Async 自调用? → 代理调用才生效;循环依赖不修复自调用。
    48. @Transactional 自调用? → 同上,需拆 Bean/TransactionTemplate。
    49. 怎么测试循环依赖? → 启动上下文、构造器/字段两种注入、Boot 2.6 默认配置。
    50. 面试怎么总结? → 三级缓存各存什么 → 为什么不是两级 → 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 换显式延迟,代价是调用方复杂度;重构换长期清晰,代价是短期成本;开关换兼容,代价是风险后移。
  • 易错点:

    • 认为三级缓存能解决构造器循环依赖。
    • 认为三级缓存能解决 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 的坑 → 排查与取舍。