一、3 级缓存的源码定义
// DefaultSingletonBeanRegistry（Spring 核心源码）
public class DefaultSingletonBeanRegistry {
/** 1 级缓存：存放完全初始化好的 Bean（成品） */
private final Map<String, Object> singletonObjects =
new ConcurrentHashMap<>(256);
/** 2 级缓存：存放早期暴露的 Bean（半成品，已实例化但未填充属性） */
private final Map<String, Object> earlySingletonObjects =
new ConcurrentHashMap<>(16);
/** 3 级缓存：存放 ObjectFactory（能产生早期 Bean 引用） */
private final Map<String, ObjectFactory<?>> singletonFactories =
new HashMap<>(16);
}
3 级缓存本质：3 个 Map，分别存不同状态的 Bean。
| 缓存 | 内容 | 状态 |
|---|---|---|
| singletonObjects（一级） | 完整 Bean | 已实例化 + 已注入 + 已初始化 |
| earlySingletonObjects（二级） | 早期 Bean | 已实例化 + 未注入 + 未初始化 |
| singletonFactories（三级） | ObjectFactory | 工厂方法（产生早期 Bean） |
二、3 级缓存解决循环依赖的完整流程
场景：A 和 B 互相依赖（字段注入或 setter 注入）
@Servicepublic class A { @Autowired private B b; // A 依赖 B}@Servicepublic class B { @Autowired private A a; // B 依赖 A}2.1 完整流程┌─────────────────────────────────────────────────────────┐
│ 步骤 1：实例化 A │
│ new A() → 创建 A 原始对象（属性 b 还是 null） │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 2：暴露早期引用（核心！） │
│ A-ObjectFactory → singletonFactories（3 级缓存） │
│ ⚠️ 此时 A 还是半成品，b=null │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 3：给 A 注入依赖 │
│ 需要注入 B（@Autowired B b） │
│ ↓ │
│ 去容器找 B → B 不存在 → 开始创建 B │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 4：实例化 B │
│ new B() → 创建 B 原始对象（属性 a 还是 null） │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 5：从 3 级缓存获取 A（关键步骤！） │
│ B 需要注入 A → 容器找 A → A 在 singletonFactories 中 │
│ ↓ │
│ 调用 A-ObjectFactory.getObject() → 创建 A 早期引用（半成品）│
│ ↓ │
│ ⚠️ A 早期引用 → earlySingletonObjects（2 级缓存） │
│ 此时 A 还是半成品，b=null │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 6：将 A 注入给 B │
│ B.a = A 早期引用（半成品） │
│ ↓ │
│ B 创建成功（B.a 已注入） │
│ ↓ │
│ B → singletonObjects（1 级缓存，完整 Bean） │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 步骤 7：回到 A，注入 B │
│ 步骤 3 暂停的地方继续：把 B 注入给 A │
│ A.b = B 完整引用 │
│ ↓ │
│ A 创建成功（A.b 已注入） │
│ ↓ │
│ A → singletonObjects（1 级缓存，完整 Bean） │
└─────────────────────────────────────────────────────────┘
2.2 关键时序
步骤 1: 实例化 A → 原始对象 A
步骤 2: A-ObjectFactory → singletonFactories（3 级）
步骤 3: 需要注入 B
步骤 4: 实例化 B → 原始对象 B
步骤 5: 从 singletonFactories 获取 A-ObjectFactory
→ 创建 A 早期引用
→ 放入 earlySingletonObjects（2 级）
步骤 6: B.a = A 早期引用 → B 创建成功 → singletonObjects（1 级）
步骤 7: A.b = B 完整引用 → A 创建成功 → singletonObjects（1 级）
三、3 级缓存的 4 大核心要点
3.1 为什么需要 3 级缓存？1 级不行吗？
1 级缓存为什么不行： // 假设只有 1 级缓存
步骤 1: new A() → A 原始对象
步骤 2: 需要注入 B → B 不存在 → 创建 B
步骤 3: B 需要注入 A → A 还是 null（没创建完）→ ❌ 死循环
2 级缓存（早期引用）为什么不够：
// 假设只有 2 级缓存（早期引用）
步骤 1: new A() → A 原始对象
步骤 2: A 早期引用 → earlySingletonObjects（2 级）
步骤 3: 需要注入 B → 创建 B
步骤 4: B 需要注入 A → 从 earlySingletonObjects 取 A 早期引用 ✅
步骤 5: B 创建成功
步骤 6: A 注入 B 成功
2 级缓存理论上能解决！ 但 Spring 还是要 3 级，原因是 AOP。
3.2 3 级缓存 vs AOP（核心原因）
@Service
public class A {
@Autowired
private B b;
@Transactional // ⚠️ A 需要 AOP 代理
public void doSomething() { ... }
}
问题： A 在步骤 1 实例化时还是原始对象 （没 AOP 代理），但 B 在步骤 4 需要注入 A，如果注入原始对象，后续 A 的 AOP 代理就废了。
3 级缓存的解决：
// 3 级缓存存的不是原始对象，是 ObjectFactory
singletonFactories.put("A", () -> {
// 这个 lambda 在调用时才执行
// 此时可以决定返回原始对象还是 AOP 代理对象
return getEarlyBeanReference("A", mbd, A 原始对象);
});
// getEarlyBeanReference 会判断 A 是否需要 AOP 代理
// 需要：返回 AOP 代理对象
// 不需要：返回原始对象
关键事实：
- 3 级缓存存的是 ObjectFactory（lambda / 工厂方法）
- B 注入 A 时调用 ObjectFactory.getObject()
- getObject() 内部判断是否需要 AOP 代理
- 这样保证 B 拿到的 A 是"最终版本"（可能是代理）
3.3 完整时序图（含 AOP）
步骤 1: 实例化 A → 原始对象 A
步骤 2: A-ObjectFactory → singletonFactories（3 级）
ObjectFactory 内部: getEarlyBeanReference() → 返回 A 代理对象（@Transactional 触发 AOP）
步骤 3: 需要注入 B
步骤 4: 实例化 B → 原始对象 B
步骤 5: 从 singletonFactories 获取 A-ObjectFactory
→ getObject() → 返回 A 代理对象（AOP 已生成）
→ 放入 earlySingletonObjects（2 级）
步骤 6: B.a = A 代理对象 → B 创建成功
步骤 7: A.b = B 完整引用 → A 创建成功
⚠️ A 此时也会经过 BeanPostProcessor#after 生成 AOP 代理
⚠️ 但 A 早期引用已经是代理对象了，所以最终一致
3.4 为什么 3 级缓存能解决，构造注入不行？
关键差异：
| 注入方式 | 实例化 vs 注入 | 3 级缓存能否解决 |
|---|---|---|
| 字段注入 | 实例化（new A）→ 暴露 ObjectFactory → 注入（setter 注入 b） | ✅ 能解决（因为 setter 注入是后置的） |
| setter 注入 | 同上 | ✅ 能解决 |
| 构造注入 | 实例化（new A(B b)）→ 必须立刻拿到 b | ❌ 不能解决（构造方法执行时 b 还不存在） |
结论：
- 字段/setter 注入：实例化（先 new 一个空对象）→ 暴露 ObjectFactory → 注入依赖
- 构造注入 ：实例化（必须立刻拿到所有依赖）→ 没法分两步
四、面试官追问应对
追问：Spring 怎么解决循环依赖？
"3 级缓存：
1.singletonObjects（完整 Bean）
2.earlySingletonObjects（早期引用）
3.singletonFactories（ObjectFactory）
核心流程：
1.A 实例化 → 暴露 ObjectFactory（3 级）
2.A 注入 B → 创建 B
3.B 注入 A → 从 3 级缓存获取 A 早期引用 → B 创建成功
4.A 注入 B → A 创建成功
注意：构造注入的循环依赖 3 级缓存解不了，要用 @Lazy 或改成 setter/字段注入。"
追问 2：3 级缓存为什么能解决 AOP + 循环依赖？
"3 级缓存存的不是 Bean 本身，是 ObjectFactory（lambda）。
ObjectFactory.getObject() 内部会判断是否需要 AOP 代理：
- 需要：返回 AOP 代理对象
- 不需要：返回原始对象
这样 B 注入的 A 始终是'最终版本'（可能是代理），保证 AOP 不会失效。"
追问 3：构造注入的循环依赖为什么 3 级缓存解不了？
"构造注入必须立刻拿到所有依赖 ，不能分两步（实例化 → 注入）。
但 3 级缓存的核心是**'先实例化空对象，再注入依赖'，这要求注入是后置的**。
- 字段注入 ✅（后置，setter 注入）
- setter 注入 ✅（后置）
- 构造注入 ❌（前置，必须立刻拿到依赖）
解决：构造注入 + @Lazy（参数是代理对象，不真正创建）。"
追问 4：@Lazy 怎么解决循环依赖？
"@Lazy 注入的是代理对象（不是 Bean 本体），第一次调用时才真正创建。
流程：
1.A 构造注入 @Lazy B → 拿到 B 的代理对象
2.A 创建成功
3.真正用到 B 时才创建 B
4.B 创建时 A 已经存在 → 不会循环
@Lazy 是打破时序的关键。"
追问 5：3 级缓存能解决构造注入 + @Async 的循环依赖吗？
"不能。
- 字段/setter 注入 + @Async ✅（3 级缓存 + AOP 代理都能解决）
- 构造注入 + @Async ❌（构造注入本身不能循环）
解决：构造注入 + @Lazy + @Async（两个都用）。"
五、记忆口诀
"3 级缓存：完整 → 早期 → ObjectFactory"
"ObjectFactory 内部判断 AOP，返回代理或原始对象"
"字段/setter 注入能解，构造注入不能解"
"构造 + @Lazy 解决循环，时序是关键"
"prototype 循环依赖 3 级缓存解不了"
六、一句话总结
"Spring 3 级缓存解决循环依赖：
1.singletonObjects（完整 Bean，1 级）
2.earlySingletonObjects（早期引用，2 级）
3.singletonFactories（ObjectFactory，3 级）
核心：实例化 A → 暴露 ObjectFactory → 注入 B → B 从 ObjectFactory 拿 A 早期引用 → B 创建成功 → A 注入 B → A 创建成功。
关键限制：构造注入的循环依赖 3 级缓存解不了，要用 @Lazy 或改成 setter/字段注入。"