Spring循环依赖解析：三级缓存与@Lazy注解实战

1. Spring循环依赖问题解析：从现象到本质

在Java开发领域，Spring框架的循环依赖问题一直是面试中的高频考点。作为一名有多年Spring实战经验的开发者，我经常遇到新手对这个问题感到困惑。今天我们就来深入剖析Spring循环依赖的解决机制，特别是三级缓存在其中的关键作用。

1.1 什么是循环依赖？

循环依赖指的是两个或多个Bean相互依赖，形成闭环引用。比如A依赖B，B又依赖A。这种场景在实际开发中并不少见，特别是在分层架构设计中。

Spring默认支持单例Bean的循环依赖解决，但在某些情况下（如构造器注入）会抛出BeanCurrentlyInCreationException异常。理解其背后的原理，对我们设计更优雅的系统架构很有帮助。

1.2 循环依赖的典型场景

根据依赖注入方式的不同，循环依赖主要分为两种类型：

1. 属性注入循环依赖：通过@Autowired注解在字段上直接注入
2. 构造器注入循环依赖：通过构造函数参数注入

Spring对这两种情况的处理方式有所不同，这也是面试官常问的区别点。我们先来看一个简单的属性注入示例：

java复制@Service
public class AService {
    @Autowired
    private BService bService;
}

@Service 
public class BService {
    @Autowired
    private AService aService;
}

这种情况下，Spring能够自动处理循环依赖。但如果改为构造器注入：

java复制@Service
public class AService {
    private final BService bService;
    
    @Autowired
    public AService(BService bService) {
        this.bService = bService;
    }
}

@Service
public class BService {
    private final AService aService;
    
    @Autowired
    public BService(AService aService) {
        this.aService = aService;
    }
}

这时启动应用就会直接报错，因为Spring无法处理构造器注入的循环依赖。理解这个区别很重要。

2. Spring三级缓存机制深度解析

2.1 三级缓存的结构与作用

Spring解决循环依赖的核心在于三级缓存机制。让我们先了解这三个缓存的定义：

在DefaultSingletonBeanRegistry类中，这三个缓存是这样定义的：

java复制/** 一级缓存：存放完全初始化好的单例Bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** 二级缓存：存放提前暴露的Bean引用 */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

/** 三级缓存：存放创建Bean的ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

2.2 Bean创建过程的详细步骤

理解三级缓存的工作机制，需要了解Spring创建Bean的完整流程：

1. 实例化阶段：通过反射调用构造函数创建Bean实例，此时属性还未填充
2. 填充属性阶段：通过反射设置Bean的依赖属性
3. 初始化阶段：执行初始化回调（如@PostConstruct方法）

关键点在于：Spring在实例化后、初始化前，会将Bean的ObjectFactory放入三级缓存。这样当出现循环依赖时，其他Bean就能通过这个ObjectFactory获取到当前Bean的早期引用。

2.3 循环依赖解决流程示例

让我们通过AService和BService的例子，看看三级缓存如何工作：

1. 开始创建AService，实例化后将其ObjectFactory放入三级缓存
2. 填充AService属性时发现需要BService
3. 开始创建BService，实例化后将其ObjectFactory放入三级缓存
4. 填充BService属性时发现需要AService
5. 从三级缓存中获取AService的ObjectFactory，得到AService的早期引用
6. 将AService早期引用放入二级缓存，并从三级缓存移除
7. 完成BService的创建，将其放入一级缓存
8. 回到AService的创建流程，此时可以获取到完整的BService
9. 完成AService的创建，将其放入一级缓存

这个过程中，三级缓存起到了关键的桥梁作用，使得两个Bean能够互相引用对方。

3. @Lazy注解的妙用与原理

3.1 @Lazy注解的基本用法

当Spring默认的循环依赖解决机制不能满足需求时，@Lazy注解是一个有效的解决方案。它可以延迟依赖的初始化，打破循环依赖的死锁。

使用方法很简单，在@Autowired注解旁加上@Lazy即可：

java复制@Service
public class AService {
    @Autowired
    @Lazy
    private BService bService;
}

或者在构造器参数上使用：

java复制@Service
public class AService {
    private final BService bService;
    
    @Autowired
    public AService(@Lazy BService bService) {
        this.bService = bService;
    }
}

3.2 @Lazy背后的代理机制

@Lazy注解的核心原理是Spring会为标记的依赖创建一个代理对象，而不是立即初始化真实的Bean。这个代理对象会在第一次实际使用时才触发真实Bean的初始化。

具体实现上，Spring会使用CGLIB或JDK动态代理（取决于目标类是否有接口）创建一个代理对象。这个代理对象持有一个目标Bean的引用，初始时为null，在第一次方法调用时才会触发真实Bean的创建。

3.3 @Lazy与三级缓存的对比

虽然@Lazy和三级缓存都能解决循环依赖，但它们的适用场景和原理不同：

在实际开发中，优先使用Spring默认的三级缓存机制，只有在无法使用时（如构造器注入）才考虑@Lazy。

4. Spring Boot对循环依赖的特殊处理

4.1 allow-circular-references配置

从Spring Boot 2.6开始，默认禁止了循环依赖，这是为了避免潜在的设计问题。但我们可以通过配置重新启用：

yaml复制spring:
  main:
    allow-circular-references: true

这个配置实际上设置的是AbstractAutowireCapableBeanFactory的allowCircularReferences属性。

4.2 配置背后的实现原理

当allow-circular-references为true时，Spring会走正常的三级缓存流程；当为false时，会在检测到循环依赖时直接抛出异常。

关键代码在AbstractAutowireCapableBeanFactory中：

java复制protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) 
            && !this.singletonsCurrentlyInCreation.add(beanName)) {
        // 当allowCircularReferences为false时抛出异常
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

4.3 是否应该允许循环依赖？

虽然技术上可以解决循环依赖，但从设计角度，循环依赖通常意味着设计有问题。理想情况下，应该：

1. 重新审视设计，看能否通过提取公共逻辑到第三个类中解决
2. 使用事件驱动架构解耦
3. 考虑使用Setter注入代替构造器注入

只有在确实需要且理解潜在风险的情况下，才应该开启循环依赖支持。

5. 循环依赖中的AOP代理问题

5.1 代理对象的特殊处理

当循环依赖的Bean需要被AOP代理时，情况会更加复杂。因为代理对象需要在原始对象创建后才能生成，这就形成了一个时序问题。

Spring通过SmartInstantiationAwareBeanPostProcessor接口解决这个问题，特别是其getEarlyBeanReference方法。

5.2 源码解析：getEarlyBeanReference

在AbstractAutowireCapableBeanFactory的doCreateBean方法中：

java复制addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

这里的lambda表达式会在需要早期引用时被执行。对于需要AOP代理的Bean，这个方法会返回代理对象而不是原始对象。

5.3 为什么需要三级缓存？

很多面试官会问：二级缓存看起来就够了，为什么需要三级缓存？关键原因就在于AOP代理：

1. 三级缓存存储的是ObjectFactory，可以延迟决定返回原始对象还是代理对象
2. 只有在真正发生循环依赖时才会调用ObjectFactory
3. 这样既保证了普通Bean的性能，又解决了代理Bean的循环依赖

如果没有三级缓存，Spring就无法处理需要代理的Bean的循环依赖情况。

6. 实战经验与避坑指南

6.1 常见问题排查技巧

在实际开发中，遇到循环依赖问题时可以按照以下步骤排查：

1. 检查异常堆栈，确定是哪些Bean形成了循环
2. 确认注入方式（构造器/属性）
3. 检查Spring Boot版本和allow-circular-references配置
4. 尝试使用@Lazy注解打破循环
5. 考虑重构设计消除循环

6.2 性能优化建议

循环依赖解决方案虽然强大，但也有性能代价：

1. 三级缓存增加了内存使用
2. 代理对象增加了方法调用开销
3. 复杂的依赖关系会延长启动时间

建议：

• 避免深度嵌套的循环依赖
• 在非必要场景下禁用循环依赖
• 使用@Lazy时要考虑其运行时开销

6.3 设计模式的最佳实践

根据我的经验，遵循这些原则可以避免循环依赖问题：

1. 单一职责原则：每个类只做一件事
2. 依赖倒置原则：依赖抽象而非具体实现
3. 分层清晰：严格定义各层的职责和依赖方向
4. 接口隔离：定义细粒度的接口

当确实需要双向依赖时，考虑使用观察者模式或事件总线来解耦。

7. 面试常见问题解析

7.1 高频面试题及答案

1. Q：Spring如何解决循环依赖？
   A：通过三级缓存机制。一级缓存存放完整Bean，二级缓存存放早期暴露的Bean，三级缓存存放ObjectFactory。当检测到循环依赖时，通过提前暴露对象引用解决。

2. Q：构造器注入为什么不能解决循环依赖？
   A：因为构造器注入需要在实例化阶段就完成依赖注入，而此时Bean还未创建完成，无法放入缓存供其他Bean引用。

3. Q：@Lazy注解是如何工作的？
   A：@Lazy会创建一个代理对象延迟实际Bean的初始化。当第一次调用代理对象的方法时，才会触发真实Bean的创建和初始化。

7.2 源码分析技巧

在面试中展示源码理解能力很有帮助。关键类和方法包括：

1. DefaultSingletonBeanRegistry：定义三级缓存
2. AbstractAutowireCapableBeanFactory.doCreateBean()：Bean创建主流程
3. AbstractAutowireCapableBeanFactory.getEarlyBeanReference()：处理早期引用
4. AutowiredAnnotationBeanPostProcessor：处理@Autowired注入

建议熟记这些类的关键方法签名和作用。

7.3 回答策略建议

回答循环依赖问题时，建议采用这样的结构：

1. 先说明现象和问题本质
2. 解释三级缓存的工作机制
3. 区分不同注入方式的差异
4. 提到@Lazy等解决方案
5. 最后谈设计层面的思考

这样既展示了技术深度，又体现了系统设计能力。

8. 总结与个人实践心得

在实际项目中处理循环依赖，我有以下几点深刻体会：

1. 不要过度依赖解决方案：能通过设计避免的循环依赖就不要用技术手段解决
2. 理解原理很重要：只有深入理解三级缓存机制，才能在复杂问题时快速定位
3. 注意版本差异：不同Spring版本对循环依赖的处理可能有细微差别
4. 性能要有考量：在大规模应用中，循环依赖解决方案可能成为性能瓶颈

最后提醒一点：在面试中，面试官问循环依赖问题，通常不只是想听标准答案，更希望考察你对Spring原理的理解深度和解决实际问题的思路。所以除了记住三级缓存的概念，更要理解其设计初衷和适用场景。