为什么一定能是三级缓存？

一、先定一个最小 Demo 场景

1. A / B 循环依赖 + AOP

// 接口只是为了看得更清晰，可有可无
public interface AService {void foo();
}public interface BService {void bar();
}

两个互相依赖的实现：

@Service
public class AServiceImpl implements AService {@Autowiredprivate BService bService;@Override@Transactional   // 或者你自己写个 @Aspect 切这个方法public void foo() {System.out.println("A.foo");bService.bar();}
}@Service
public class BServiceImpl implements BService {@Autowiredprivate AService aService;@Overridepublic void bar() {System.out.println("B.bar");}
}

一个简单的 AOP 切面（也可以不用写，直接用 @Transactional）：

@Aspect
@Component
public class LogAspect {@Before("execution(* com.example.AService.foo(..))")public void beforeFoo() {System.out.println("before A.foo");}
}

重点：

A 依赖 B
B 依赖 A
A 上有事务/切面（会被代理）

这样就能触发：循环依赖 + AOP 代理 + 三级缓存的完整流程。

二、按源码顺序走一遍：getBean → getSingleton → doCreateBean

下面以 getBean("aServiceImpl") 为入口，按 Spring 源码主线（省略细节调用）展开。

第 0 步：Client 调用

AService a = applicationContext.getBean(AService.class);
a.foo();

内部相当于：

AbstractBeanFactory#doGetBean("aServiceImpl", AService.class, ...)

第 1 步：doGetBean – 先尝试从单例缓存拿

伪代码：

Object sharedInstance = getSingleton(beanName);
// ↓ 实际调用的是 DefaultSingletonBeanRegistry#getSingleton(name, true)

在 getSingleton(beanName, allowEarlyReference=false) 中：

查 一级缓存 singletonObjects：还没有 → 返回 null
isSingletonCurrentlyInCreation(beanName) 此时是 false（第一次创建）
返回 null

于是 doGetBean 知道：需要创建新的单例。

第 2 步：标记 “正在创建” + 调 createBean

doGetBean 大致做：

beforeSingletonCreation(beanName); // 标记 inCreation=trueObject beanInstance = createBean(beanName, mbd, args); 
// → AbstractAutowireCapableBeanFactory#doCreateBean

此时：

isSingletonCurrentlyInCreation("aServiceImpl") = true
还没有任何缓存命中

第 3 步：doCreateBean – 实例化 A（只构造，不注入）

doCreateBean 里核心几步：

createBeanInstance(beanName, mbd, args)
👉 通过构造器反射，实例化出 原始的 AServiceImpl 对象 rawA。

把一个生成“早期引用”的工厂丢进三级缓存：

真实代码逻辑大概是：

if (mbd.isSingleton() && allowCircularReferences && isSingletonCurrentlyInCreation(beanName)) {addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, rawA));
}

对应到三级缓存：

singletonFactories.put("aServiceImpl", ObjectFactory@A);

这里没有立刻生成早期引用，也没有做代理，
只是先注册了一个“懒生成”的工厂。

接下来准备做属性注入：populateBean(beanName, mbd, beanWrapper)

第 4 步：populateBean A – 发现需要注入 B → getBean("bServiceImpl")

在属性注入阶段，Spring 发现 AServiceImpl 有：

@Autowired
private BService bService;

于是调用：

getBean("bServiceImpl");

这又走回 doGetBean("bServiceImpl") 流程。

第 5 步：创建 B – 前半段流程与 A 一样

对 B 来说，步骤完全类似：

getSingleton("bServiceImpl")
👉 一级/二级/三级都没东西 → null
beforeSingletonCreation("bServiceImpl") 标记正在创建
doCreateBean("bServiceImpl")
- createBeanInstance 得到原始的 rawB
- addSingletonFactory("bServiceImpl", () -> getEarlyBeanReference("bServiceImpl", rawB))
  👉 把 B 的 ObjectFactory 放入三级缓存

然后进入 populateBean("bServiceImpl", ...)。

第 6 步：populateBean B – 注入 A → getBean("aServiceImpl")（关键点）

B 有：

@Autowired
private AService aService;

于是调用：

getBean("aServiceImpl");

此时情况已经不同：

A 正在创建中（isSingletonCurrentlyInCreation("aServiceImpl") == true）
三级缓存里已经有了 aServiceImpl 对应的 ObjectFactory

来看这次 getSingleton("aServiceImpl", allowEarlyReference=true) 的执行过程。

三、关键：第二次 getSingleton("aServiceImpl") 的三级缓存命中过程

源码结构（简化版）：

public Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;
}

这次调用时的命中顺序：

singletonObjects.get("aServiceImpl")
👉 一级缓存：没有（A 还没完全初始化）
isSingletonCurrentlyInCreation("aServiceImpl")
👉 true（我们在创建 A 时标记过）
earlySingletonObjects.get("aServiceImpl")
👉 二级缓存：还没有（还没生成过早期引用）
allowEarlyReference == true，于是查三级缓存：
```
singletonFactory = singletonFactories.get("aServiceImpl");
```
👉 命中之前在 doCreateBean(A) 时放进去的 ObjectFactory@A
调用工厂：singletonFactory.getObject()
👉 实际调用的是：
```
getEarlyBeanReference("aServiceImpl", rawA)
```
在这个方法里，会遍历所有 SmartInstantiationAwareBeanPostProcessor，其中就包括 AOP 的那个：
```
for (SmartInstantiationAwareBeanPostProcessor bp : postProcessors) {exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
}
```
- 如果 A 需要被代理（比如有 @Transactional / @Aspect 命中），这里会生成 代理对象 proxyA
- 如果不需要，则直接返回原始对象 rawA
拿到早期引用之后：
```
earlySingletonObjects.put("aServiceImpl", proxyA);
singletonFactories.remove("aServiceImpl");
```
至此：
- 三级缓存命中 → 产出早期引用（可能是代理）
- 早期引用被放进 二级缓存
- 对应的 ObjectFactory 从三级缓存中移除（保证只生成一次）

返回 proxyA，注入到 BServiceImpl 中的 aService 字段：

bService.aService = proxyA; // B 拿到的是代理过的 A

B 的依赖注入完成，后续 B 走自己的初始化流程，最后放进一级缓存。

四、回到 A：完成初始化并升级到一级缓存

现在回到当初在创建 A 的 doCreateBean("aServiceImpl")：

刚才是 A 在 populateBean 时需要 B，导致递归创建 B；
B 填好依赖（拿到的是 proxyA）之后，B 完成初始化，进入 singletonObjects["bServiceImpl"]。

A 那边 populateBean 继续进行，此时给 A 注入 B：

aService.bService = bServiceImpl; // 这个 bServiceImpl 中持有的是 proxyA

A 完成自己的初始化（initializeBean），再经过一轮 BeanPostProcessor（包括 AOP 的后置处理）。
- AOP 部分会检测：如果已经是代理了，就不会再次生成新代理（这里用的是 BPP 的机制保证幂等）。
registerSingleton("aServiceImpl", proxyA)：
👉 把最终的 bean（其实就是那个早期生成的 proxyA）放入 一级缓存：
```
singletonObjects.put("aServiceImpl", proxyA);
earlySingletonObjects.remove("aServiceImpl");
```

至此，三个缓存的状态变成：

singletonObjects["aServiceImpl"] = proxyA
singletonObjects["bServiceImpl"] = bServiceImpl

earlySingletonObjects 和 singletonFactories 中都没有 A/B 相关条目。

循环依赖解决，AOP 代理也统一：

容器里任何地方拿到的 A，最终都是 同一个代理实例 proxyA。

五、“三级缓存命中”时序图（A/B + AOP 场景）

下面给你画一个简化的时序图，重点标出三级缓存命中点：

sequenceDiagramparticipant Clientparticipant BeanFactoryparticipant S1 as singletonObjectsparticipant S2 as earlySingletonObjectsparticipant S3 as singletonFactoriesparticipant Araw as raw Aparticipant Braw as raw Bparticipant AOP as AopPostProcessorClient->>BeanFactory: getBean("aServiceImpl")BeanFactory->>S1: get("aServiceImpl")S1-->>BeanFactory: nullBeanFactory->>BeanFactory: beforeSingletonCreation("aServiceImpl")BeanFactory->>BeanFactory: doCreateBean("aServiceImpl")Note right of BeanFactory: createBeanInstance → 得到 raw ABeanFactory->>Araw: instantiateNote right of BeanFactory: addSingletonFactory("aServiceImpl", ObjectFactory@A)BeanFactory->>S3: put("aServiceImpl", ObjectFactory@A)Note right of BeanFactory: populateBean(A) → 需要 BBeanFactory->>BeanFactory: getBean("bServiceImpl")BeanFactory->>S1: get("bServiceImpl")S1-->>BeanFactory: nullBeanFactory->>BeanFactory: beforeSingletonCreation("bServiceImpl")BeanFactory->>BeanFactory: doCreateBean("bServiceImpl")Note right of BeanFactory: createBeanInstance → 得到 raw BBeanFactory->>Braw: instantiateNote right of BeanFactory: addSingletonFactory("bServiceImpl", ObjectFactory@B)BeanFactory->>S3: put("bServiceImpl", ObjectFactory@B)Note right of BeanFactory: populateBean(B) → 需要 ABeanFactory->>BeanFactory: getBean("aServiceImpl") (allowEarlyReference = true)BeanFactory->>S1: get("aServiceImpl")S1-->>BeanFactory: nullBeanFactory->>S2: get("aServiceImpl")S2-->>BeanFactory: nullBeanFactory->>S3: get("aServiceImpl")S3-->>BeanFactory: ObjectFactory@ANote right of BeanFactory: 三级缓存命中 → 调用工厂BeanFactory->>AOP: getEarlyBeanReference("aServiceImpl", raw A)AOP-->>BeanFactory: proxyABeanFactory->>S2: put("aServiceImpl", proxyA)BeanFactory->>S3: remove("aServiceImpl")BeanFactory-->>Braw: 注入 aService = proxyANote right of BeanFactory: B 初始化完成 → 放入一级缓存BeanFactory->>S1: put("bServiceImpl", Braw)BeanFactory->>S3: remove("bServiceImpl")Note right of BeanFactory: 回到 A 的 populateBean → 注入 BBeanFactory-->>Araw: 注入 bService = BrawNote right of BeanFactory: A 初始化完成（再次过 AOP BPP）BeanFactory->>S1: put("aServiceImpl", proxyA)BeanFactory->>S2: remove("aServiceImpl")BeanFactory-->>Client: 返回 proxyA

你可以对照这张图记住三次关键动作：

A 实例化后：
addSingletonFactory("aServiceImpl", factory) → 放入 三级缓存。
B 注入 A 时：
getSingleton("aServiceImpl", true)
- 三级缓存命中
- 工厂调用 → getEarlyBeanReference → 生成 proxyA
- proxyA 放入 二级缓存，三级缓存条目删除。
A 初始化完成时：
- singletonObjects.put("aServiceImpl", proxyA) 放入 一级缓存
- 从二级缓存删除。