Spring三级缓存机制深度解析：破解循环依赖的技术密码

2026年2月10日 互联网

一、循环依赖的本质与挑战

在Spring应用中，当两个或多个Bean存在双向依赖关系时（例如ServiceA依赖ServiceB，同时ServiceB也依赖ServiceA），就会形成循环依赖闭环。这种场景在微服务架构中尤为常见，例如订单服务与库存服务可能存在双向调用需求。

技术困境：
Spring容器采用”实例化→属性填充→初始化”的单向流程创建Bean。若遇到循环依赖，容器会陷入无限递归：

  1. 创建ServiceA实例并填充属性时，发现需要注入ServiceB
  2. 创建ServiceB实例时，又发现需要注入ServiceA
  3. 此时ServiceA尚未完成初始化，导致整个流程阻塞

传统解决方案的局限性：

  • 同步阻塞：通过@Lazy注解延迟加载虽能解决，但会牺牲运行时性能
  • 接口代理：使用CGLIB生成代理类会增加内存开销与调用复杂度
  • 手动拆分：重构代码结构可能破坏业务逻辑的完整性

二、三级缓存的架构设计

Spring通过三级缓存机制实现非侵入式的循环依赖解决方案，其核心设计包含三个存储层级：

1. 一级缓存（SingletonObjects）

  • 定位：最终存储完全初始化完成的Bean实例
  • 特点：线程安全的ConcurrentHashMap结构，采用全量存储策略
  • 访问时机：当Bean完成所有初始化流程后，从三级缓存逐级晋升至此

2. 二级缓存（EarlySingletonObjects）

  • 定位：存储已完成属性填充但未执行初始化方法的Bean
  • 特点：采用Optional包装的弱引用存储，避免内存泄漏
  • 作用：当多个线程同时请求同一个未初始化完成的Bean时，提供一致的早期引用

3. 三级缓存（SingletonFactories）

  • 定位：存储Bean工厂对象（ObjectFactory）
  • 特点：采用Lambda表达式实现延迟加载，存储格式为() -> getEarlyBeanReference()
  • 核心价值：
    • 支持AOP代理的提前生成
    • 保持Bean引用的线程安全性
    • 最小化内存占用（仅存储工厂而非完整对象）

三、缓存协同工作流程

以典型的循环依赖场景为例，完整处理流程如下：

  1. // 伪代码展示核心逻辑
  2. public Object getBean(String beanName) {
  3.     // 1. 检查一级缓存
  4.     Object bean = singletonObjects.get(beanName);
  5.     if (bean != null) return bean;
  7.     // 2. 检查二级缓存
  8.     bean = earlySingletonObjects.get(beanName);
  9.     if (bean != null) return bean;
  11.     // 3. 检查三级缓存
  12.     ObjectFactory<?> factory = singletonFactories.get(beanName);
  13.     if (factory != null) {
  14.         // 触发AOP代理生成（如果存在）
  15.         bean = factory.getObject();
  16.         // 晋升到二级缓存
  17.         earlySingletonObjects.put(beanName, bean);
  18.         // 移除三级缓存记录
  19.         singletonFactories.remove(beanName);
  20.         return bean;
  21.     }
  23.     // 4. 创建新实例
  24.     bean = createBeanInstance(beanName);
  25.     // 填充属性时触发依赖解析
  26.     populateProperties(bean);
  27.     // 注册三级缓存（此时可能触发循环依赖检测）
  28.     addSingletonFactory(beanName, () -> {
  29.         // 应用AOP增强
  30.         return getEarlyBeanReference(beanName, bean);
  31.     });
  33.     // 执行初始化逻辑
  34.     initializeBean(bean);
  36.     // 5. 缓存晋升
  37.     singletonFactories.remove(beanName);
  38.     earlySingletonObjects.remove(beanName);
  39.     singletonObjects.put(beanName, bean);
  41.     return bean;
  42. }

关键处理逻辑：

  1. 依赖发现阶段：当属性填充遇到未初始化Bean时，触发缓存查找
  2. 代理生成时机：在三级缓存的ObjectFactory中完成AOP代理创建
  3. 缓存晋升策略：Bean状态变更时自动清理下级缓存，避免内存泄漏
  4. 线程安全保障：所有缓存操作均通过synchronized块或CAS机制保证原子性

四、高级应用场景分析

1. 原型作用域的特殊处理

原型Bean（prototype scope）默认不进入缓存体系，其循环依赖需通过以下方式解决：

  • 显式使用@Lazy注解延迟加载
  • 改用方法注入（Method Injection）模式
  • 在配置类中通过@Bean方法实现依赖传递

2. 构造器注入的局限性

当使用构造器注入时，Spring无法在实例化阶段暴露未完成的Bean引用，此时循环依赖会导致： 

  1. BeanCurrentlyInCreationException: Requested bean is currently in creation

解决方案：

  • 改用setter注入或字段注入
  • 将部分依赖改为@Lazy加载
  • 重新设计服务耦合度

3. 代理对象的特殊处理

对于带有@Async、@Transactional等注解的Bean，三级缓存机制会：

  1. 在ObjectFactory中提前生成CGLIB/JDK动态代理
  2. 保证代理对象与原始对象引用的一致性
  3. 避免初始化完成后再次生成代理导致的性能损耗

五、性能优化建议

  1. 缓存命中率监控：通过DebugStringValueResolver等工具分析缓存使用情况
  2. 合理使用作用域：单例Bean优先使用默认缓存策略
  3. 避免过度设计：复杂的依赖关系应通过服务拆分解决
  4. 升级Spring版本：5.3+版本对缓存锁机制进行了优化，减少线程阻塞

六、常见问题排查

  1. 缓存不一致：检查是否手动调用了destroyBean()等破坏生命周期的方法
  2. 内存泄漏：监控earlySingletonObjects中的弱引用回收情况
  3. 代理失效：确保@Bean方法返回的是原始对象而非代理对象

通过三级缓存机制，Spring框架在保持依赖注入灵活性的同时，提供了高效的循环依赖解决方案。理解其底层原理有助于开发者编写出更健壮、更易维护的企业级应用，特别是在高并发场景下能显著提升系统稳定性。对于需要深度定制Bean生命周期的场景，建议结合BeanFactoryPostProcessor等扩展点进行二次开发。

最新文章