一、循环依赖的本质与典型场景

循环依赖指两个或多个Bean在初始化过程中相互引用，形成闭环依赖链。例如：

@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB; // 依赖ServiceB
}
@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA; // 又依赖ServiceA
}

这种相互依赖在Spring容器启动时会导致初始化流程卡死，最终抛出BeanCurrentlyInCreationException。循环依赖的常见场景包括：

字段注入循环：如上述ServiceA与ServiceB的案例
构造器注入循环：通过构造函数相互引用
代理对象循环：AOP代理与原始对象间的依赖
多级循环：A→B→C→A的复杂依赖链

二、三级缓存机制：Spring的破局之道

Spring通过三级缓存体系解决循环依赖问题，其核心设计如下：

1. 一级缓存：singletonObjects（单例池）

作用：存储完全初始化完成的Bean实例
特点：
- Key为Bean名称，Value为完整对象
- 线程安全，采用ConcurrentHashMap实现
- 只有通过getSingleton()方法获取的对象才会进入此缓存

示例：

// 伪代码展示单例池访问逻辑
Object getSingleton(String beanName) {
  Object bean = singletonObjects.get(beanName);
  if (bean != null) {
      return bean; // 直接返回已初始化对象
  }
  // 其他缓存查找逻辑...
}

2. 二级缓存：earlySingletonObjects（早期暴露池）

作用：存储已完成属性填充但未执行初始化方法的半成品Bean
使用场景：
- 当检测到循环依赖时，从三级缓存提升到二级缓存
- 避免重复创建代理对象（如AOP场景）
关键特性：
- 对象状态：已完成populateBean()但未执行initializeBean()
- 生命周期短暂，仅在循环依赖处理期间存在

3. 三级缓存：singletonFactories（对象工厂池）

作用：存储ObjectFactory实例，用于延迟创建代理对象

核心设计：

public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

工作原理：
1. 创建Bean时立即注册工厂到三级缓存
2. 发生循环依赖时，调用工厂的getObject()方法
3. 如果是普通对象，直接返回实例；如果是代理对象，动态生成代理
4. 将生成的对象提升到二级缓存

三、完整处理流程解析

以ServiceA→ServiceB→ServiceA的循环依赖为例，Spring的处理步骤如下：

初始化ServiceA：
- 创建原始对象（未设置属性）
- 注册ServiceA的ObjectFactory到三级缓存
- 开始填充属性，发现需要ServiceB
初始化ServiceB：
- 创建原始对象
- 注册ServiceB的ObjectFactory
- 填充属性时发现需要ServiceA
循环依赖检测：
- 从三级缓存获取ServiceA的ObjectFactory
- 调用getObject()获取早期引用（可能是代理对象）
- 将生成的早期对象提升到二级缓存
- 将ServiceA的早期引用注入ServiceB
完成ServiceB初始化：
- 执行初始化方法（如@PostConstruct）
- 将完整对象移入一级缓存
- 清除二级缓存中的早期对象
继续ServiceA初始化：
- 获取到已初始化的ServiceB实例
- 完成剩余初始化流程
- 最终对象进入一级缓存

四、特殊场景处理方案

1. 构造器注入循环

Spring默认不支持构造器注入的循环依赖，解决方案包括：

重构设计：通过依赖倒置原则拆分职责
Setter注入：将构造器注入改为字段注入

延迟注入：使用@Lazy注解实现按需加载

@Service
public class ServiceA {
  @Lazy
  @Autowired
  private ServiceB serviceB; // 实际注入的是代理对象
}

2. 代理对象循环

当涉及AOP代理时，三级缓存的工厂机制尤为重要：

// 伪代码展示代理创建逻辑
Object getObjectFromFactory(String beanName) {
    ObjectFactory<?> factory = singletonFactories.get(beanName);
    if (factory != null) {
        Object earlyReference = factory.getObject(); // 可能创建代理
        if (shouldCreateProxy(beanName)) {
            return createProxy(earlyReference); // 动态生成代理
        }
        return earlyReference;
    }
    return null;
}

3. 多级循环依赖

对于A→B→C→A的复杂场景，处理原则与双循环一致，但需注意：

缓存提升顺序：三级→二级→一级
每个Bean只能被提升一次
确保最终所有对象都进入一级缓存

五、最佳实践与避坑指南

优先使用字段注入：
- 构造器注入在循环依赖时需要特殊处理
- 字段注入配合@Lazy可灵活解决大多数场景
合理设计Bean作用域：
- 原型作用域（prototype）的Bean不支持循环依赖
- 单例Bean的循环依赖可通过缓存机制解决
避免过度依赖早期暴露：
- 早期对象可能未执行初始化逻辑
- 业务代码中不应直接依赖二级缓存中的对象
监控循环依赖：
- 通过ApplicationContext的getDependenciesForBean()方法检测依赖关系
- 使用监控工具跟踪Bean初始化过程
测试场景覆盖：
- 编写集成测试验证循环依赖场景
- 模拟高并发下的初始化过程

六、性能与线程安全分析

Spring的三级缓存机制在性能方面做了精心设计：

缓存层级递进：
- 优先从一级缓存获取，减少锁竞争
- 二级缓存作为临时过渡，避免重复代理创建
线程安全保障：
- 所有缓存操作使用synchronized块或ConcurrentHashMap
- 对象提升过程采用原子操作
内存开销控制：
- 早期对象仅在循环依赖时存在
- 及时清理二级缓存中的临时对象

结语

理解Spring的循环依赖处理机制，不仅能帮助开发者快速定位和解决NPE异常，更能指导进行合理的架构设计。通过掌握三级缓存的协作原理，可以更自信地处理复杂依赖场景，构建出高可用的企业级应用。在实际开发中，建议结合具体业务场景选择合适的注入方式，并通过单元测试验证依赖关系的正确性。

Spring Bean循环依赖深度解析：从三级缓存机制到最佳实践