Spring 循环依赖源码深挖

2026-11-01

循环依赖是 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) 解决了这个矛盾:

  1. 实例化后,只把 () -> getEarlyBeanReference(...) 这个 lambda 放进三级缓存,不立即执行。
  2. 若没有循环依赖 → 没人调用三级缓存的工厂 → Bean 正常走 initializeBean 创建代理。
  3. 若发生循环依赖 → 有人调用 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。

九、三级缓存失效的常见场景

  1. @Async 注解:AsyncAnnotationBeanPostProcessor 的代理是提前创建的,但它的 getEarlyBeanReference 不生效(需要 earlyProxyReferences 处理),可能导致循环依赖时报错,通常配合 @Lazy 解决。
  2. @Transactional:事务代理的提前暴露依赖 SmartInstantiationAwareBeanPostProcessor,某些组合下会失效。
  3. 构造器注入:天然无法解决(见第七节)。
  4. 非单例 Bean:prototype 等不缓存,无法解决。
  5. 关闭了 allowCircularReferences:setAllowCircularReferences(false) 时直接抛异常。

十、面试话术总结

如果面试官问「讲一下 Spring 如何解决循环依赖」,按这个层次答:

  1. 结论:Spring 只解决「单例 setter 注入」的循环依赖,靠三级缓存。

  2. 三级缓存:一级 singletonObjects 存完整 Bean;二级 earlySingletonObjects 存早期引用;三级 singletonFactories 存 ObjectFactory 工厂。

  3. 流程:实例化后、属性填充前,把 () -> getEarlyBeanReference() 放进三级缓存;属性填充时发现依赖 B,去 getBean(B),B 又依赖 A,通过三级缓存拿到 A 的早期引用,B 完成创建,A 也完成。

  4. 为什么三级(关键加分点):三级缓存的 ObjectFactory 是懒执行的,只有真正发生循环依赖时才调用 getEarlyBeanReference 提前创建 AOP 代理,避免无循环依赖时 Bean 被提前代理。

  5. 为什么二级缓存:缓存工厂结果,保证同一个早期引用只生成一次,避免多个依赖方拿到不同代理,保证单例。

  6. 哪些不能解决:构造器注入(实例化阶段卡死,用 @Lazy 解决)、prototype(不缓存)。