Spring 循环依赖源码深挖
循环依赖是 Spring 面试的「压轴题」,能讲到「三级缓存 + 懒加载的 ObjectFactory + AOP 提前代理」这一层,基本就碾压大部分候选人了。本文带你逐行看源码。
一、什么是循环依赖
两个或多个 Bean 互相依赖,形成闭环:
@Service
public class A {
@Autowired
private B b;
}
@Service
public class B {
@Autowired
private A a;
}graph LR
A[A] -->|依赖| B[B]
B -->|依赖| A三种场景及能否解决
| 场景 | 能否解决 | 说明 |
|---|---|---|
| 单例 setter 注入 | ✅ 能 | 三级缓存 |
| 单例构造器注入 | ❌ 不能 | 实例化阶段就无法进行 |
| prototype 循环依赖 | ❌ 不能 | 不缓存,无法提前暴露 |
二、三级缓存是什么
三级缓存定义在 DefaultSingletonBeanRegistry 中:
// 一级缓存:存放完整可用的单例 Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存:存放「早期引用」,即实例化完成但未填充属性/初始化的半成品
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存:存放 ObjectFactory(工厂),延迟生成早期引用/代理
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);graph TD
L1["一级缓存 singletonObjects<br/>完整 Bean"]
L2["二级缓存 earlySingletonObjects<br/>早期引用(半成品)"]
L3["三级缓存 singletonFactories<br/>ObjectFactory 工厂"]
L3 -->|getObject() 调用后| L2
L2 -->|初始化完成后| L1
style L1 fill:#e6f7e6
style L2 fill:#fff3cd
style L3 fill:#e8f4fd- 一级:保证单例,最终所有完整 Bean 都在这里。
- 二级:缓存三级工厂的执行结果,保证循环依赖时拿到的是同一个早期对象。
- 三级:ObjectFactory,只有真正发生循环依赖时才被调用,实现「懒」代理。
三、核心流程(A → B → A)
以 A、B 互相依赖为例,画完整时序:
sequenceDiagram
participant C as 容器
participant A as Bean A
participant B as Bean B
C->>A: 1. getBean(A) → createBean(A)
Note over A: 实例化 A(构造器)<br/>A 加入三级缓存
C->>A: 2. populateBean(A) 填充属性
A->>B: 3. 发现依赖 B → getBean(B)
C->>B: 4. createBean(B) → 实例化 B
Note over B: B 加入三级缓存
C->>B: 5. populateBean(B) 填充属性
B->>A: 6. 发现依赖 A → getSingleton(A)
Note over A: 从三级缓存取出 ObjectFactory<br/>生成 A 早期引用→放入二级缓存
B-->>A: 7. B 拿到 A 的早期引用, 完成填充
C->>B: 8. B 初始化完成, 放入一级缓存
A-->>B: 9. A 拿到完整 B, 完成填充
C->>A: 10. A 初始化完成, 放入一级缓存关键点:A 在「实例化后、属性填充前」就把自己暴露到三级缓存,B 才能拿到 A 的早期引用。
四、核心源码逐段解析
1. 入口:AbstractBeanFactory#doGetBean
protected <T> T doGetBean(String name, ...) {
// ① 先从缓存拿(三级缓存查找)
Object bean = getSingleton(beanName);
if (bean != null) {
return bean;
}
// ② 没拿到,进入创建流程
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
return createBean(beanName, mbd, args); // ③ 真正创建
});
}
return sharedInstance;
}2. 三级缓存查找:getSingleton(beanName, allowEarlyReference)
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
// 没找到 && 该 Bean 正在创建中(说明有循环依赖)
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 二级缓存
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 三级缓存:拿 ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用工厂生成早期引用(可能触发 AOP 提前代理)
singletonObject = singletonFactory.getObject();
// 结果放入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 移除三级缓存(用完即弃)
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}注意查找顺序:一级 → 二级 → 三级,且只有
isSingletonCurrentlyInCreation为 true 时才查二级/三级。
3. 提前暴露:AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
// ① 实例化(构造器创建,此时对象还是空壳)
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
Object bean = instanceWrapper.getWrappedInstance();
// ② 判断是否需要提前暴露(单例 && 允许循环依赖 && 正在创建中)
boolean earlySingletonExposure =
(mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// ③ 加入三级缓存,这里传的是 lambda(懒执行)
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// ④ 属性填充(可能递归触发 getBean,发生循环依赖)
populateBean(beanName, mbd, instanceWrapper);
// ⑤ 初始化(含 AOP 代理创建)
Object exposedObject = initializeBean(beanName, exposedObject, mbd);
...
}4. 加入三级缓存:addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}5. 提前代理:getEarlyBeanReference
// AbstractAutoProxyCreator(AOP 核心)
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 记录:这个 Bean 已经提前代理过了
this.earlyProxyReferences.put(cacheKey, bean);
// 提前创建 AOP 代理对象
return wrapIfNecessary(bean, beanName, cacheKey);
}五、为什么必须是「三级」缓存?
这是最体现深度的问题。核心答案:三级缓存的 ObjectFactory 是「懒」的,能避免无循环依赖时也被提前 AOP 代理。
假设只有两级缓存(去掉三级,直接存早期对象):
- 二级缓存里存的必须是什么?如果存原始对象,那 AOP 场景下 B 拿到的是 A 的原始对象,而最终 A 会变成代理对象,导致 B 里的 A 和容器里的 A 不是同一个(拿到没增强的 A),功能错误。
- 如果存代理对象,那就必须在「实例化后」立即调用
getEarlyBeanReference创建代理。问题是:即使没有循环依赖,所有 Bean 也会被提前代理,破坏了 Spring「无循环依赖时,AOP 代理在 initializeBean 阶段才创建」的正常流程。
三级缓存用 ObjectFactory(lambda) 解决了这个矛盾:
- 实例化后,只把
() -> getEarlyBeanReference(...)这个 lambda 放进三级缓存,不立即执行。 - 若没有循环依赖 → 没人调用三级缓存的工厂 → Bean 正常走 initializeBean 创建代理。
- 若发生循环依赖 → 有人调用
getObject()→ 此时才触发getEarlyBeanReference提前代理。
graph TD
A[实例化 Bean] --> B{放入三级缓存<br/>ObjectFactory 工厂}
B --> C{是否发生循环依赖?}
C -->|否| D[不触发工厂<br/>正常 initializeBean 创建代理]
C -->|是| E[调用 getObject<br/>提前 getEarlyBeanReference 代理]
style D fill:#e6f7e6
style E fill:#fff3cd一句话总结:一级缓存保证单例,二级缓存缓存结果(保证同一个早期对象,避免重复生成代理),三级缓存通过「懒执行的工厂」解决 AOP 代理的时机问题。
六、二级缓存的作用(容易被忽略)
既然三级缓存能生成早期引用,为什么还要二级缓存?
getEarlyBeanReference每次调用都可能wrapIfNecessary新生成一个代理对象。- 若 A 被 B、C 两个 Bean 依赖,B 和 C 都来拿 A 的早期引用,若无二级缓存,会调用两次工厂,生成两个不同的代理,破坏单例。
- 二级缓存把工厂结果缓存下来,保证同一个早期引用只生成一次。
// 三级缓存生成后立即缓存到二级,并从三级移除
singletonObject = singletonFactory.getObject(); // 只执行一次
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName); // 用完移除七、构造器循环依赖为什么无法解决
public class A {
public A(B b) {} // 构造器注入
}
public class B {
public B(A a) {}
}- 三级缓存的本质是「实例化后、属性填充前」提前暴露对象。
- 但构造器注入在实例化阶段就卡住了:创建 A 需要先 new B,创建 B 需要先 new A,连实例都创建不出来,根本没机会进入「实例化后」的提前暴露环节。
解决方案:@Lazy 注解,用代理延迟注入。
public class A {
public A(@Lazy B b) {} // 注入的是 B 的代理,真正用到时才解析
}八、prototype 循环依赖为什么无法解决
- prototype 作用域的 Bean 不缓存(不进入三级缓存),无法提前暴露早期引用。
- 且 prototype Bean 每请求都新建,本身就无「单例」概念,循环依赖无从打破。
- 遇到时 Spring 直接抛
BeanCurrentlyInCreationException。
九、三级缓存失效的常见场景
- @Async 注解:
AsyncAnnotationBeanPostProcessor的代理是提前创建的,但它的 getEarlyBeanReference 不生效(需要earlyProxyReferences处理),可能导致循环依赖时报错,通常配合@Lazy解决。 - @Transactional:事务代理的提前暴露依赖
SmartInstantiationAwareBeanPostProcessor,某些组合下会失效。 - 构造器注入:天然无法解决(见第七节)。
- 非单例 Bean:prototype 等不缓存,无法解决。
- 关闭了 allowCircularReferences:
setAllowCircularReferences(false)时直接抛异常。
十、面试话术总结
如果面试官问「讲一下 Spring 如何解决循环依赖」,按这个层次答:
结论:Spring 只解决「单例 setter 注入」的循环依赖,靠三级缓存。
三级缓存:一级
singletonObjects存完整 Bean;二级earlySingletonObjects存早期引用;三级singletonFactories存 ObjectFactory 工厂。流程:实例化后、属性填充前,把
() -> getEarlyBeanReference()放进三级缓存;属性填充时发现依赖 B,去 getBean(B),B 又依赖 A,通过三级缓存拿到 A 的早期引用,B 完成创建,A 也完成。为什么三级(关键加分点):三级缓存的 ObjectFactory 是懒执行的,只有真正发生循环依赖时才调用
getEarlyBeanReference提前创建 AOP 代理,避免无循环依赖时 Bean 被提前代理。为什么二级缓存:缓存工厂结果,保证同一个早期引用只生成一次,避免多个依赖方拿到不同代理,保证单例。
哪些不能解决:构造器注入(实例化阶段卡死,用
@Lazy解决)、prototype(不缓存)。