Spring循环依赖解析与解决方案-代码聚汇网

Spring循环依赖解析与解决方案

哗啦啦的小流弊·2026-08-05·阅读 24 GEO检测（免费）

Spring循环依赖三级缓存

|难度：普通|阅读约 14 分钟

1. 循环依赖的本质与危害解析

"Relying upon circular references is discouraged and they are prohibited by default." 这句话直指Spring框架中一个经典的设计禁忌——循环依赖。作为Java开发者，在SpringBoot项目中遭遇"BeanCurrentlyInCreationException"异常时，往往会发现控制台赫然打印着这段警告。循环依赖就像代码中的莫比乌斯环，表面看是个完美闭环，实则暗藏致命缺陷。

循环依赖的典型场景是：Bean A依赖Bean B，而Bean B又反过来依赖Bean A。Spring容器在初始化时，会陷入"先有鸡还是先有蛋"的死循环。我曾在一个电商项目中见过更复杂的嵌套案例：订单服务(OrderService)调用支付服务(PaymentService)，支付服务需要库存服务(InventoryService)，而库存服务又回调订单服务检查历史记录——这种三层循环让系统在启动时就崩溃。

警告：即使通过spring.main.allow-circular-references=true强行开启循环依赖，也可能导致以下隐患：

对象初始化状态不一致（A注入给B时，A本身可能还未完成构造）

代理失效（AOP增强可能无法正确应用）

内存泄漏（循环引用阻止GC回收）

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. Spring解决循环依赖的底层机制

Spring默认使用三级缓存策略来尝试解决部分循环依赖问题，但这仅适用于setter注入的单例Bean：

java复制// 伪代码展示Spring三级缓存结构
class DefaultSingletonBeanRegistry {
    // 一级缓存：完整Bean
    Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    // 二级缓存：早期暴露的原始对象（未填充属性）
    Map<String, Object> earlySingletonObjects = new HashMap<>();
    // 三级缓存：ObjectFactory工厂
    Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
}

具体解决流程如下：

创建Bean A实例（通过反射调用构造函数）
将Bean A的ObjectFactory放入三级缓存
开始注入Bean A的依赖——发现需要Bean B
创建Bean B实例时又发现需要Bean A
从三级缓存获取Bean A的早期引用，完成Bean B的创建
最后完成Bean A的属性注入

但要注意：构造器注入的循环依赖无解，因为对象实例化都无法完成。这也是为什么Spring官方文档明确建议："Always use constructor injection for mandatory dependencies".

3. 工程实践中破解循环依赖的6种方案

3.1 架构层面重构

最彻底的解决方案是重新设计模块边界。在我参与的物流系统中，曾将"运单管理"和"费用计算"服务拆分为：

核心领域服务（OrderCoreService）
运费计算器（ShippingFeeCalculator）
增值服务处理器（ValueAddedServiceHandler）

通过引入中间层，将原来的网状依赖变为星型结构。重构后各模块职责更单一，且符合"依赖倒置原则"。

3.2 延迟注入技巧

对于必须保留的交叉依赖，可以使用@Lazy注解：

java复制@Service
public class ServiceA {
    @Lazy  // 延迟初始化
    @Autowired 
    private ServiceB serviceB;
}

这实际上创建了一个代理对象，只有在第一次调用时才会真正触发依赖解析。但要注意：过度使用@Lazy会掩盖架构问题，建议仅作为临时解决方案。

3.3 接口隔离方案

定义公共接口打破直接依赖：

java复制public interface IOrderValidator {
    boolean validate(Order order);
}

@Service 
public class InventoryService implements IOrderValidator {
    // 实现验证逻辑
}

@Service
public class OrderService {
    @Autowired
    private List<IOrderValidator> validators;  // 通过接口解耦
}

3.4 方法注入替代字段注入

使用@Autowired方法而非字段：

java复制@Service
public class ServiceA {
    private ServiceB serviceB;
    
    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

这种方式允许Spring在对象构造完成后才建立依赖关系。

3.5 事件驱动改造

引入Spring事件机制实现解耦：

java复制@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void createOrder(Order order) {
        publisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}

@Component
public class InventoryListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 处理库存扣减
    }
}

3.6 配置白名单方案

在极端情况下确实需要临时开启循环依赖时，必须在application.properties中显式声明：

properties复制spring.main.allow-circular-references=true

但要在代码中添加明显注释说明原因，例如：

java复制// WARNING: Temporary circular reference with PaymentService 
// TODO: Refactor before 2024-Q3 release
@Autowired
private OrderService orderService;

4. 诊断与排查循环依赖的实战技巧

4.1 解读Spring启动日志

当出现循环依赖时，控制台会输出类似：

code复制The dependencies of some of the beans in the application context form a cycle:
┌─────┐
|  orderService defined in file [OrderService.class]
↑     ↓
|  paymentService defined in file [PaymentService.class]
└─────┘

这个ASCII艺术图清晰展示了Bean之间的循环引用路径。

4.2 使用ArchUnit进行架构测试

在单元测试中加入架构约束检查：

java复制@ArchTest
void noCircularDependencies(JavaClasses classes) {
    ArchRule rule = slices()
            .matching("com.ourproject.(*)..")
            .should().beFreeOfCycles();
    rule.check(classes);
}

这能在CI流程中提前发现问题。

4.3 IDEA可视化分析

IntelliJ IDEA的依赖分析工具非常实用：

右键点击项目 → Analyze → Analyze Dependency Matrix
查找红色标记的循环引用
使用"Show Paths"功能查看完整调用链

5. 经典案例：订单-库存-支付三角循环

某电商系统原始设计：

java复制class OrderService {
    @Autowired PaymentService payment;
    @Autowired InventoryService inventory;
}

class PaymentService {
    @Autowired InventoryService inventory;
}

class InventoryService {
    @Autowired OrderService order;  // 需要查询历史订单
}

重构方案：

提取OrderQueryService专门处理订单查询
将历史订单检查改为事件驱动
引入CQRS模式分离读写操作

最终结构：

java复制class OrderService {
    @Autowired OrderEventPublisher publisher;
}

class InventoryService {
    @Autowired OrderQueryService queryService;
}

// 新服务：专门处理只读查询
class OrderQueryService {
    // 仅包含查询方法
}

6. 性能影响与最佳实践

循环依赖会导致：

启动时间增加（Spring需要额外处理依赖解析）
内存占用上升（早期对象需要保持更久）
测试复杂度提高（难以单独mock某个Bean）

建议采用以下工程规范：

在团队代码规范中明确禁止循环依赖
使用SonarQube配置静态检查规则
新项目设置spring.main.allow-circular-references=false
定期运行ArchUnit测试
在CI流程中加入依赖检查步骤

对于遗留系统改造，可以分阶段进行：

先通过@Lazy让系统能启动
添加单元测试保护现有功能
逐步重构各模块接口
最终移除所有@Lazy注解

记住：循环依赖就像代码中的"技术债"，越早偿还利息越少。每次遇到这样的警告，都是改进架构的好机会。