Spring 如何解决循环依赖问题?

Spring 通过 三级缓存机制 解决了 单例 Bean 的循环依赖问题 ,但无法处理 构造器注入的循环依赖 。其核心思想是 提前暴露半成品 Bean 的引用 ,并通过 工厂对象(ObjectFactory) 动态生成代理对象,从而避免循环链条的无限递归。


🧠 一、Spring 循环依赖的定义与限制

✅ 1. 循环依赖的定义

当两个或多个 Bean 相互依赖,形成一个闭环,称为 循环依赖(Circular Dependency)

示例:
java 复制代码
@Component
class A {
    @Autowired
    private B b;
}

@Component
class B {
    @Autowired
    private A a;
}

✅ 2. Spring 能解决的循环依赖类型

类型 是否支持 说明
字段/Setter 注入 支持,使用三级缓存机制
构造器注入 不支持,构造器注入需在实例化时完成依赖注入
多例(prototype)Bean 不支持,Spring 无法管理多例 Bean 的生命周期

🔄 二、Spring 三级缓存机制详解

Spring 使用 三级缓存 来管理单例 Bean 的创建过程,确保在依赖注入时能获取到"早期引用",从而打破循环依赖。

📦 1. 三级缓存的结构

Spring 使用 DefaultSingletonBeanRegistry 类中的三个 Map 实现三级缓存:

缓存层级 类型 作用
一级缓存(singletonObjects) Map<String, Object> 存放完全初始化完成的 Bean(可直接使用)
二级缓存(earlySingletonObjects) Map<String, Object> 存放提前暴露的"半成品 Bean"(已实例化,但未完成属性注入和初始化)
三级缓存(singletonFactories) Map<String, ObjectFactory<?>> 存放生成 Bean 的工厂对象(用于生成代理对象)

🧱 三、Spring 创建 Bean 的流程与三级缓存的协作

Spring 创建单例 Bean 的核心流程如下:

复制代码
1. 实例化 Bean(构造函数调用)
2. 将 Bean 工厂对象加入三级缓存(singletonFactories)
3. 填充属性(依赖注入)
   - 如果依赖的 Bean 尚未创建,则触发其创建流程
4. 初始化 Bean(调用 Aware、BeanPostProcessor、初始化方法)
5. 将 Bean 升级到一级缓存(singletonObjects)

✅ 1. 实例化 Bean

调用构造函数创建 Bean 实例,此时 Bean 是"半成品",还未注入属性和初始化。

java 复制代码
// AbstractAutowireCapableBeanFactory.java
protected Object createBeanInstance(...) {
    return getInstantiationStrategy().instantiate(...);
}

✅ 2. 将 Bean 工厂对象加入三级缓存

在实例化后,Spring 会将一个 ObjectFactory 放入三级缓存中,用于后续代理对象的生成。

java 复制代码
// DefaultSingletonBeanRegistry.java
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    if (!this.singletonObjects.containsKey(beanName)) {
        this.singletonFactories.put(beanName, singletonFactory); // 放入三级缓存
    }
}

✅ 3. 填充属性(依赖注入)

在填充属性时,如果发现某个依赖的 Bean 还未创建,则会递归调用 getBean() 方法,尝试获取该 Bean。

java 复制代码
// AbstractAutowireCapableBeanFactory.java
protected void populateBean(...) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            PropertyValues pvsToUse = ((InstantiationAwareBeanPostProcessor) bp).postProcessProperties(...);
            applyPropertyValues(beanName, mbd, bw, pvsToUse);
        }
    }
}
如果依赖的 Bean 还未完全初始化:
  • Spring 会调用 getSingleton(String beanName) 方法,尝试从缓存中获取 Bean。
  • 如果一级缓存没有,就尝试从二级缓存获取。
  • 如果二级缓存也没有,就从三级缓存中获取 ObjectFactory,调用 getObject() 生成 Bean 引用。
java 复制代码
// DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                singletonObject = singletonFactory.getObject(); // 生成早期引用
                this.earlySingletonObjects.put(beanName, singletonObject);
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

✅ 4. 初始化 Bean(调用 Aware、BeanPostProcessor、初始化方法)

初始化阶段包括:

  • 调用 BeanNameAwareBeanFactoryAware 等接口
  • 执行 BeanPostProcessor.postProcessBeforeInitialization()
  • 调用 @PostConstructInitializingBean.afterPropertiesSet()、自定义 init-method
  • 执行 BeanPostProcessor.postProcessAfterInitialization()
java 复制代码
// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(...) {
    invokeAwareMethods(beanName, wrappedBean); // 调用 Aware 接口
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); // 前置处理器
    invokeInitMethods(beanName, wrappedBean, mbd); // 初始化方法
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); // 后置处理器
    return wrappedBean;
}

✅ 5. 将 Bean 升级到一级缓存

在 Bean 完全初始化完成后,将其从三级缓存中移除,放入一级缓存中,供后续使用。

java 复制代码
// DefaultSingletonBeanRegistry.java
protected void addSingleton(String beanName, Object singletonObject) {
    this.singletonObjects.put(beanName, singletonObject);
    this.singletonFactories.remove(beanName);
    this.earlySingletonObjects.remove(beanName);
}

🧩 四、AOP 代理的处理(结合三级缓存)

如果 Bean 需要 AOP 代理,Spring 会在 BeanPostProcessor.postProcessAfterInitialization() 中生成代理对象。

java 复制代码
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null && !containsSingletonCandidate(beanName)) {
        return wrapIfNecessary(bean, beanName, new NullSourceClass());
    }
    return bean;
}

生成代理的过程会调用 AbstractAutoProxyCreator.getProxy(),最终生成一个代理对象。

这个代理对象会被缓存到 三级缓存 中,供其他 Bean 依赖注入时使用。


❗ 五、Spring 解决循环依赖的前提条件

条件 说明
单例 Bean Spring 只能解决单例作用域 Bean 的循环依赖
Setter/字段注入 支持,因为依赖注入发生在属性填充阶段
构造器注入 ❌ 不支持,构造器注入需在实例化时完成依赖注入
非代理对象 如果 Bean 需要 AOP 代理,代理对象必须通过 ObjectFactory 提前生成

✅ 六、总结

特性 Spring 三级缓存机制
解决类型 单例 Bean、Setter/字段注入的循环依赖
不支持类型 构造器注入、多例 Bean
核心机制 提前暴露 Bean 的早期引用(半成品 Bean)
三级缓存结构 singletonObjects(一级)、earlySingletonObjects(二级)、singletonFactories(三级)
缓存协作流程 三级 → 二级 → 一级
AOP 代理处理 通过 ObjectFactory 动态生成代理对象
核心类 DefaultSingletonBeanRegistryAbstractAutowireCapableBeanFactory

🧪 七、完整流程图(简化版)

复制代码
createBean(A)
 └── 实例化 A(构造函数)
 └── addSingletonFactory(A, ObjectFactory)
 └── populateBean(A)
      └── 依赖注入 b → getBean(B)
           └── createBean(B)
                └── 实例化 B(构造函数)
                └── addSingletonFactory(B, ObjectFactory)
                └── populateBean(B)
                     └── 依赖注入 a → getBean(A)
                          └── getSingleton(A) → 从三级缓存获取 A 的早期引用
                └── initializeBean(B)
                     └── postProcessAfterInitialization() → AOP 代理(如有)
                └── addSingleton(B, proxyB)
      └── initializeBean(A)
           └── postProcessAfterInitialization() → AOP 代理(如有)
      └── addSingleton(A, proxyA)

相关推荐
Albert Edison19 分钟前
【最新版】IntelliJ IDEA 2025 创建 SpringBoot 项目
java·spring boot·intellij-idea
超级小忍1 小时前
JVM 中的垃圾回收算法及垃圾回收器详解
java·jvm
weixin_446122461 小时前
JAVA内存区域划分
java·开发语言·redis
Piper蛋窝1 小时前
深入 Go 语言垃圾回收:从原理到内建类型 Slice、Map 的陷阱以及为何需要 strings.Builder
后端·go
勤奋的小王同学~1 小时前
(javaEE初阶)计算机是如何组成的:CPU基本工作流程 CPU介绍 CPU执行指令的流程 寄存器 程序 进程 进程控制块 线程 线程的执行
java·java-ee
TT哇1 小时前
JavaEE==网站开发
java·redis·java-ee
2401_826097621 小时前
JavaEE-Linux环境部署
java·linux·java-ee
缘来是庄2 小时前
设计模式之访问者模式
java·设计模式·访问者模式
Bug退退退1232 小时前
RabbitMQ 高级特性之死信队列
java·分布式·spring·rabbitmq
梵高的代码色盘3 小时前
后端树形结构
java