Spring 中的循环依赖问题：解决方案与三级缓存机制-优快云博客

本文链接：https://blog.youkuaiyun.com/u010702254/article/details/147159992

Spring 中的循环依赖问题：解决方案与三级缓存机制

在现代企业级应用中，Spring 是最常用的 Java 框架之一，它通过 IoC（控制反转）容器 实现了依赖注入（DI）和解耦的机制。然而，在某些复杂的 Bean 依赖关系中，我们经常会遇到 循环依赖 问题。本文将深入解析 Spring 中的循环依赖问题，探讨其原理、常见的解决方案，并结合实际案例提供最佳实践。此外，我们还将介绍 Spring 如何通过 三级缓存机制 解决循环依赖的问题，帮助开发者更好地理解和应用这一机制。

什么是循环依赖？

循环依赖的定义

在 Spring 中，循环依赖 是指两个或多个 Bean 之间相互依赖，形成一个闭环。例如，Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A。这样一来，Spring 容器就无法确定应该先实例化哪个 Bean，从而导致死锁，无法完成 Bean 的初始化。

循环依赖的举例

假设有两个 Bean A 和 B，它们之间形成了相互依赖的关系：

@Component
public class A {
    private B b;

    @Autowired
    public A(B b) {
        this.b = b;
    }
}

@Component
public class B {
    private A a;

    @Autowired
    public B(A a) {
        this.a = a;
    }
}

在这个例子中，A 依赖 B，而 B 又依赖 A，形成了一个循环依赖的闭环。

Spring 中的循环依赖类型

Spring 框架中的循环依赖主要有三种形式，分别是 构造器注入、Setter 注入 和 字段注入（@Autowired）。

1. 构造器注入引发的循环依赖

构造器注入需要在实例化 Bean 时就注入其依赖，而 Spring 并不能在实例化过程中获取到还未完全初始化的 Bean。因此，如果两个 Bean 互相依赖，Spring 无法解决循环依赖问题。

@Component
public class A {
    private B b;

    @Autowired
    public A(B b) {
        this.b = b;
    }
}

@Component
public class B {
    private A a;

    @Autowired
    public B(A a) {
        this.a = a;
    }
}

如上所示，A 依赖 B，B 又依赖 A，Spring 在尝试实例化 A 时，需要先实例化 B，但是 B 又依赖于 A，这就形成了一个闭环。

2. Setter 注入引发的循环依赖

Setter 注入相对于构造器注入，在解决循环依赖时更为灵活。Spring 会先创建 A 和 B 的实例，再通过 Setter 方法注入依赖关系，因此不会出现构造器注入时的循环依赖问题。

@Component
public class A {
    private B b;

    @Autowired
    public void setB(B b) {
        this.b = b;
    }
}

@Component
public class B {
    private A a;

    @Autowired
    public void setA(A a) {
        this.a = a;
    }
}

在这种情况下，Spring 会先实例化 A 和 B，然后通过 Setter 方法注入依赖，从而避免了循环依赖的问题。

3. 字段注入（@Autowired）引发的循环依赖

字段注入通过 @Autowired 注解直接注入依赖，Spring 通过反射机制自动为字段赋值。如果存在循环依赖，Spring 仍然能够处理，但前提是你使用的是 单例 Bean 和 懒加载，否则会导致初始化失败。

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

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

在这种情况下，Spring 会先实例化 A 和 B 的代理对象，并将实际的 Bean 注入到其中，解决了循环依赖的问题。

Spring 如何处理循环依赖

Spring 的三级缓存机制

为了避免循环依赖，Spring 使用了 三级缓存机制 来处理单例 Bean 的创建。具体来说，Spring 会通过以下三种缓存来管理 Bean 的生命周期和依赖关系：

一级缓存（singletonObjects）：存储已经完全初始化的 Bean 对象。
二级缓存（earlySingletonObjects）：存储正在创建中的 Bean 的早期引用，帮助避免循环依赖。
三级缓存（singletonFactories）：存储 ObjectFactory，用于延迟生成 Bean 实例。

Spring 三级缓存的工作流程

从一级缓存获取 Bean：
- 如果该 Bean 已经创建并存在于一级缓存中，直接返回 Bean 实例。
创建 Bean 时：
- 如果 Bean 不在一级缓存中，Spring 开始实例化该 Bean。
- 如果该 Bean 在创建过程中，Spring 会将其早期引用放入 二级缓存 中，避免循环依赖问题。
代理工厂的使用：
- 如果存在循环依赖，Spring 会将创建 Bean 的工厂放入 三级缓存 中，这样在依赖注入过程中返回代理对象。
依赖注入完成后：
- 完成依赖注入和初始化后，真实的 Bean 会替换掉代理对象，并放入 一级缓存。

三级缓存图示

在这里插入图片描述

Spring 的三级缓存机制的配置与实现

Spring 的三级缓存机制默认启用，开发者不需要手动配置即可使用这一机制。它是 Spring 内部实现的一部分，位于 DefaultListableBeanFactory 类中。三级缓存通过 singletonObjects、earlySingletonObjects 和 singletonFactories 属性来管理 Bean 的生命周期。

不过，如果你需要对缓存进行优化或定制，可以通过自定义 BeanFactory 或 BeanPostProcessor 来实现。例如，使用 setAllowCircularReferences(true) 允许 Spring 处理循环依赖。

@Configuration
public class BeanFactoryConfig {
    
    @Bean
    public BeanFactoryCustomizer<DefaultListableBeanFactory> beanFactoryCustomizer() {
        return beanFactory -> {
            // 设置自定义的 BeanFactory 配置
            beanFactory.setAllowCircularReferences(true);
        };
    }
}

解决循环依赖的实战案例

使用构造器注入时的循环依赖

@Component
public class A {
    private B b;

    @Autowired
    public A(B b) {
        this.b = b;
    }
}

@Component
public class B {
    private A a;

    @Autowired
    public B(A a) {
        this.a = a;
    }
}

解决方案：使用 Setter 注入

@Component
public class A {
    private B b;

    @Autowired
    public void setB(B b) {
        this.b = b;
    }
}

@Component
public class B {
    private A a;

    @Autowired
    public void setA(A a) {
        this.a = a;
    }
}