在 Spring 的日常开发中，循环依赖是一个绕不开的话题。陷入无限递归的死锁，

只是Spring 却能在绝大多数场景下循环依赖问题？" src="/uploads/images/122.jpg"/>

Spring 的“破局”三板斧

使用者痛点：你是否曾在项目中因为循环依赖导致启动失败，却找不到可靠的排查思路？Spring 的方法正是为了解决这个痛点而生。

Spring 解决这个问题的主要思路是：“先上车，后补票”。它允许一个对象在还未完全创建好时就提前暴露一个“半成品”引用。让依赖它的其他对象先拿着用，等自己真正完成创建后再“补全”自己。

为了实现这个精妙的机制，Spring 在 DefaultSingletonBeanRegistry 中准备了三层缓存。它们各司其职：

• 一级缓存成品库，存放完全初始化好的 Bean 实例。
• 二级缓存半成品库，存放提前暴露的、但还未完成属性填充和初始化的 Bean 实例。
• 三级缓存工厂库。存放 ObjectFactory 对象工厂，用于按需生成半成品引用或 AOP 代理。

时序图演示

sequenceDiagram
participant A as AService
participant B as BService
participant L1 as 一级缓存
participant L2 as 二级缓存
participant L3 as 三级缓存
Note over A: . 开始创建 A
至于A->A，实例化
至于A->L3，. 将自身工厂放入三级缓存
Note over A: . 开始属性填充，发现依赖 B
至于A->B，. 去获取 B
Note over B: . 开始创建 B
从B->B来看，实例化
B->L3的观点是，. 将自身工厂放入三级缓存
Note over B: . 开始属性填充。发现依赖 A
B->L1这方面，. 获取 A
B->L2的观点是，. 获取 A
再看B->L3，. 获取 A 的工厂并执行
说到L3-->B，. 返回 A 的早期引用
B->L2的观点是，. 将 A 的半成品放入二级缓存
从B->L3来看，. 从三级缓存移除 A 的工厂
Note over B: . B 的属性填充完成
Note over B: . B 执行初始化
说到B->L1，. 将完整的 B 放入一级缓存
Note over A: . A 获取到完整的 B，继续填充
Note over A: . A 执行初始化
再看A->L1，. 将完整的 A 放入一级缓存

使用者痛点：看到这里你可能已经在脑海里想：“这套流程看起来很复杂，我该怎么定位到底是哪一步卡住了？”接下来我们通过几个常见疑问来拆解每一步背后的原理。

说到常见疑问一，为什么二级缓存不够用？不过，

AOP 代理是关键所在。老实说，

If you only store raw instance in second‑level cache,any bean that depends on it will receive original object. When bean is later wrapped by an @Transactional。@Cacheable,or or proxy‑based feature,dependent bean still holds a reference to non‑proxied instance,causing transaction失效、拦截器失效等严重问题。

If we try to solve this by “instantly checking for proxies after instantiation and storing proxy in second‑level cache”,we would force **every** bean—most of which have no circular dependency—to undergo an unnecessary proxy creation step,dramatically hurting startup performance.

The third‑level cache solves this elegantly:

• The cache stores an ObjectFactory。not final object.
• The factory is invoked **only when a circular dependency actually occurs**—i.e.,when anor bean asks for an early reference.
• This lazy creation ensures that beans without circular references skip proxy generation until ir normal initialization phase.

再看常见疑问二，把“工厂”和“结果”合并到同一个缓存可以吗？

"既然三级缓存是工厂。二级缓存是工厂执行后的结果，那为什么不合二为一？如果没有值，就现场执行工厂逻辑拿到对象再返回，不也行吗？”

This idea looks feasible at first glance,but Spring’s designers chose separation for two decisive reasons:

• SINGLE RESPONSIBILITY：The third‑level cache is responsible solely for “how to create”;second‑level cache is responsible for “what has been created”. This clear division makes codebase easier to understand and maintain.
• S thread safety：If two threads simultaneously request Bean A,Spring removes factory from third‑level cache via an atomic #remove. Only one thread can successfully obtain and execute factory,guaranteeing a single instance creation. Merging both maps would require additional locking or state flags to avoid duplicate factory execution,complicating concurrency control.

The trade‑off is intentional—using an extra map buys us cleaner architecture and robust concurrent behavior.

至于实际方法。快速定位循环依赖根源

1. 打开 DEBUG 日志：

   
   logging.level.org.springframework.beans.factory.support=DEBUG
   logging.level.org.springframework.beans.factory=DEBUG
   

2. #BeanCreationException# 信息：
3. #使用 @Lazy#：
4. #拆分 Bean#：

• L1——最终成品库：
• L2——半成品库：
• L3——工厂库：ObjectFactory`；只有在真实出现循环依赖时才被触发，从而避免不必要的性能开销。其实，

This three‑tier caching strategy lets Spring simultaneously achieve:

• If you’ve ever stared at a cryptic “BeanCurrentlyInCreationException” and felt helpless。understanding se three caches will turn that frustration into confidence.掌握了它们，你就拥有了解锁 Spring IoC 与 AOP 跨模块协作的大钥匙。