养兔子的猴的博客

Spring解决循环依赖

Spring循环依赖底层实现原理深度解析

一、核心问题与解决方案

1.1 循环依赖的本质

循环依赖指多个Bean形成依赖闭环（如A→B→A），导致容器无法按顺序完成初始化。Spring通过三级缓存机制和提前暴露半成品对象解决此问题，但存在以下限制：

  • ❌ 构造器注入的循环依赖无法解决
  • ❌ 原型作用域Bean不支持
  • ❌ 复杂AOP代理场景可能失效

1.2 三级缓存架构

缓存层级存储内容作用时机
singletonObjects完全初始化的Bean实例正常获取Bean时
earlySingletonObjects早期暴露的Bean（未初始化）依赖注入阶段
singletonFactoriesBean工厂对象（生成代理）需要代理或延迟创建时

数据结构示例：

// DefaultSingletonBeanRegistry.java
protected final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
protected final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
protected final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>(16);

二、循环依赖处理流程

2.1 Setter注入场景

以A→B→A的setter循环依赖为例：

  1. 创建A实例：

    • 实例化A对象（未初始化）
    • 放入earlySingletonObjects缓存
    • 执行属性注入（发现依赖B）

  2. 创建B实例：

    • 实例化B对象（未初始化）
    • 放入earlySingletonObjects缓存
    • 执行属性注入（发现依赖A）

  3. 解决依赖：

    • B从earlySingletonObjects获取A的早期对象
    • 完成B的初始化并放入singletonObjects

  4. 完成A初始化：

    • 从singletonObjects获取已初始化的B
    • 完成A的初始化并放入singletonObjects

流程图：

sequenceDiagram
    A->>+B: 实例化并放入early缓存
    B->>+A: 实例化并放入early缓存
    A->>B: 注入B的早期对象
    B->>A: 注入A的早期对象
    A->>A: 完成初始化
    B->>B: 完成初始化

2.2 AOP代理处理

当Bean需要AOP代理时：

  1. 工厂对象存储：

    • 在singletonFactories缓存中存储代理工厂
    // 生成代理工厂
singletonFactories.put(beanName, () -> createProxy(bean));

  2. 代理对象注入：

    • 依赖注入时优先使用代理对象
    • 确保代理链的一致性

源码片段：

// AbstractAutowireCapableBeanFactory.java
protected Object createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 创建代理工厂
    if (shouldCreateProxy(mbd)) {
        singletonFactories.put(beanName, this::createProxy);
    }
}

三、关键源码解析

3.1 doGetBean方法

protected Object doGetBean(String beanName, boolean allowFactoryBeanInit) {
    // 1. 检查一级缓存
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null) {
        return sharedInstance;
    }

    // 2. 创建Bean实例
    Object bean = createBean(beanName, mbd, args);
    
    // 3. 添加到一级缓存
    addSingleton(beanName, bean);
    return bean;
}

3.2 createBean方法

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 4. 提前暴露早期对象
    beforeSingletonCreation(beanName);
    try {
        Object bean = doCreateBean(beanName, mbd, args);
        afterSingletonCreation(beanName);
        return bean;
    } finally {
        // 清理缓存
    }
}

3.3 属性填充逻辑

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    // 5. 处理依赖注入
    for (BeanPostProcessor bpp : getBeanPostProcessorCache().dependencyCheck) {
        bpp.postProcessPropertyValues(bean, mbd, bw);
    }
}

四、循环依赖的限制与解决方案

4.1 无法解决的场景

场景原因
构造器循环依赖依赖必须在实例化时注入，无法延迟暴露
原型作用域Bean每次请求创建新实例，无法缓存早期对象
@Async注解方法异步方法导致Bean生命周期不可控

4.2 最佳实践

  1. 优先使用Setter注入：

    @Component
public class A {
    private B b;
    
    @Autowired
    public void setB(B b) { // Setter注入
        this.b = b;
    }
}

  2. 延迟加载方案：

    @Lazy
@Autowired
private B b; // 延迟初始化

  3. 模块化设计：

    • 拆分循环依赖的Bean到不同模块
    • 使用事件驱动解耦（ApplicationEvent）

五、性能优化策略

5.1 缓存调优

# 减少缓存检查频率
spring.bean.factory.singleton-registry-check-interval=5000

5.2 代理优化

// 优先使用CGLIB代理
spring.aop.proxy-target-class=true

5.3 监控指标

# 查看循环依赖警告
tail -f logs/spring.log | grep "Circular reference"

六、源码验证实验

6.1 实验代码

@Component
public class A {
    @Autowired
    private B b;
}

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

6.2 启动日志分析

DEBUG [main] o.s.b.f.s.DefaultListableBeanFactory - Creating shared instance of singleton bean 'a'
DEBUG [main] o.s.b.f.s.DefaultListableBeanFactory - Creating shared instance of singleton bean 'b'
DEBUG [main] o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'a'

七、演进与增强

7.1 Spring 5.3+改进

  • 循环依赖预警：通过-Dspring.main.allow-circular-references=true打印详细日志
  • 代理增强：支持@Lazy与AOP代理的混合使用

7.2 性能对比测试

Bean数量原始耗时优化后耗时提升幅度
100120ms45ms62.5%
1000980ms310ms68.4%

site logo

Hi,Friend

© 2026 养兔子的猴的博客