Spring中循环依赖问题的解决机制总结

news2025/6/8 9:10:48

一、解决机制

1. 什么是循环依赖

循环依赖是指两个或多个Bean之间相互依赖对方，形成一个闭环的依赖关系。最常见的情况是当Bean A依赖Bean B，而Bean B又依赖Bean A时，就形成了循环依赖。在Spring容器初始化过程中，如果不加以特殊处理，这种循环依赖会导致Bean的创建过程陷入死循环，最终导致应用启动失败。

例如以下代码展示了一个典型的循环依赖场景：

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

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

2. Spring三级缓存机制概述

Spring框架通过巧妙的"三级缓存"机制解决了循环依赖问题。这三级缓存在Spring源码中是通过三个Map集合实现的：

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

// 二级缓存：存放原始的Bean对象（尚未填充属性），用于解决循环依赖
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

// 三级缓存：存放Bean工厂对象，用于解决循环依赖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

这三级缓存的作用分别是：

  • 一级缓存（singletonObjects）：用于存储完全初始化好的Bean，即已经完成实例化、属性填充和初始化的Bean，可以直接被其他对象使用。

  • 二级缓存（earlySingletonObjects）：用于存储早期曝光的Bean对象，这些Bean已经完成实例化但还未完成属性填充和初始化。当出现循环依赖时，其他Bean可以引用这个未完全初始化的Bean。

  • 三级缓存（singletonFactories）：用于存储Bean的工厂对象，主要用于处理需要AOP代理的Bean的循环依赖问题。它存储的是一个Lambda表达式，这个表达式会返回Bean的早期引用，并在需要时将其放入二级缓存。

3. 三级缓存的查找顺序

当Spring需要获取一个单例Bean时，会按照以下顺序查找：

  1. 首先从一级缓存（singletonObjects）中查找，如果找到直接返回
  2. 如果一级缓存没有，再从二级缓存（earlySingletonObjects）中查找
  3. 如果二级缓存也没有，则从三级缓存（singletonFactories）中查找对应的工厂，如果找到则通过工厂获取对象，并将其放入二级缓存，同时从三级缓存中移除

这种层级查找的机制确保了在循环依赖的情况下，Bean能够被正确地创建和注入。

4. Spring解决循环依赖的详细流程

以A、B两个类相互依赖为例，Spring解决循环依赖的流程如下：

  1. 创建Bean A：

    • Spring首先创建Bean A的实例（仅完成实例化，未进行属性填充）
    • 将A的创建工厂放入三级缓存singletonFactories中
    • 开始给A填充属性，发现依赖了B

  2. 创建Bean B：

    • Spring开始创建B（因为A依赖B）
    • 实例化B，并将B的创建工厂放入三级缓存
    • 开始给B填充属性，发现依赖了A

  3. 处理循环依赖：

    • 此时需要注入A，但A正在创建中
    • Spring尝试从一级缓存查找A，未找到
    • 继续从二级缓存查找A，未找到
    • 最后从三级缓存中找到A的工厂对象
    • 通过工厂获取A的早期引用（可能是原始对象，也可能是代理对象）
    • 将A的早期引用放入二级缓存，并从三级缓存中移除A的工厂
    • 将A的早期引用注入到B中

  4. 完成Bean创建：

    • B完成属性填充和初始化，放入一级缓存
    • 返回到A的属性填充流程，将B注入到A中
    • A完成属性填充和初始化，放入一级缓存

通过这个流程，Spring成功解决了循环依赖问题，关键在于提前暴露了Bean的早期引用。

5. 为什么需要三级缓存

很多人会疑惑，为什么需要三级缓存？二级缓存不能解决循环依赖问题吗？

实际上，在不考虑AOP的情况下，二级缓存确实可以解决循环依赖问题。但Spring设计三级缓存的主要目的是为了处理AOP代理的情况。

在Spring中，AOP代理是在Bean生命周期的最后阶段（初始化后）创建的。但如果出现循环依赖，就需要提前创建代理对象。三级缓存中的工厂对象可以在需要时（即真正出现循环依赖时）才创建代理对象，而不是对所有Bean都提前创建代理。

这种设计有以下优势：

  1. 延迟代理对象的创建：只有在真正需要时才创建代理对象，避免了不必要的性能开销
  2. 保持Bean生命周期的一致性：尽可能地保持Bean的标准生命周期流程
  3. 灵活处理各种代理场景：适应不同的AOP实现和代理方式

6. 三级缓存的局限性

虽然三级缓存机制能够解决大多数循环依赖问题，但它仍有一些局限性：

  1. 不能解决构造器注入的循环依赖：因为构造器注入发生在实例化阶段，此时Bean还未被放入三级缓存，所以无法解决

  2. 不能解决prototype作用域的循环依赖：三级缓存机制只对单例Bean有效，对于prototype作用域的Bean，Spring不会缓存其实例，因此无法解决其循环依赖

  3. 不能解决多例Bean之间的循环依赖：原因同上，Spring不会缓存非单例Bean

7. 源码分析

Spring解决循环依赖的核心源码主要在DefaultSingletonBeanRegistry类中，关键方法包括：

  1. getSingleton(String beanName)：按照一级、二级、三级缓存的顺序查找Bean
  2. addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)：将Bean的工厂对象放入三级缓存
  3. doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)：获取Bean的主要逻辑

在AbstractAutowireCapableBeanFactory的doCreateBean方法中，会在Bean实例化后立即将其工厂对象放入三级缓存，为解决循环依赖做准备。

8. 总结

Spring通过三级缓存机制巧妙地解决了循环依赖问题，其核心思想是将Bean的实例化和初始化分离，提前暴露实例化但未完全初始化的对象。三级缓存的设计不仅解决了基本的循环依赖问题，还优雅地处理了AOP代理场景下的循环依赖。

这种机制体现了Spring框架设计的精妙之处，通过缓存分层和提前暴露对象的方式，在不影响Bean正常生命周期的前提下解决了看似棘手的循环依赖问题。

二、实际示例与解析

为了更直观地理解Spring如何通过三级缓存解决循环依赖问题，我们来看一个具体的示例，并详细分析整个过程。

1. 示例代码

首先，我们创建两个相互依赖的Service类：

@Service
public class UserService {
    @Autowired
    private OrderService orderService;
    
    public void findUserOrders(Long userId) {
        System.out.println("查询用户订单");
        orderService.getOrdersByUserId(userId);
    }
}

@Service
public class OrderService {
    @Autowired
    private UserService userService;
    
    public List<Order> getOrdersByUserId(Long userId) {
        System.out.println("获取用户订单");
        return new ArrayList<>();
    }
    
    public void notifyUser(Long orderId) {
        System.out.println("通知用户订单状态");
        userService.findUserOrders(1L); // 调用UserService的方法
    }
}

在这个示例中，UserService依赖OrderService，而OrderService又依赖UserService，形成了典型的循环依赖。

2. 详细解析Spring处理流程

让我们详细分析Spring如何处理这个循环依赖：

2.1 创建UserService

当Spring容器启动时，会按照Bean定义顺序开始创建Bean。假设先创建UserService：

1. 实例化UserService对象（仅调用构造函数，此时内部属性尚未赋值）
2. 将UserService实例的创建工厂添加到三级缓存（singletonFactories）中
   singletonFactories.put("userService", () -> getEarlyBeanReference(beanName, mbd, userService实例))
3. 开始填充UserService的属性，发现需要注入OrderService

2.2 创建OrderService

由于UserService依赖OrderService，Spring开始创建OrderService：

1. 实例化OrderService对象（仅调用构造函数）
2. 将OrderService实例的创建工厂添加到三级缓存中
   singletonFactories.put("orderService", () -> getEarlyBeanReference(beanName, mbd, orderService实例))
3. 开始填充OrderService的属性，发现需要注入UserService

2.3 处理循环依赖

此时出现了关键的循环依赖处理步骤：

1. OrderService需要注入UserService，但UserService正在创建中
2. Spring尝试从一级缓存(singletonObjects)查找UserService，未找到
3. 继续从二级缓存(earlySingletonObjects)查找UserService，未找到
4. 最后从三级缓存(singletonFactories)中找到UserService的工厂对象
5. 调用工厂对象的getObject()方法获取UserService的早期引用
   - 如果UserService需要被代理（如有@Transactional注解），此时会创建代理对象
   - 如果不需要代理，则返回原始对象
6. 将获取到的UserService早期引用放入二级缓存，同时从三级缓存中移除
   earlySingletonObjects.put("userService", userService早期引用)
   singletonFactories.remove("userService")
7. 将UserService的早期引用注入到OrderService中

2.4 完成Bean创建

接下来完成两个Bean的创建过程：

1. OrderService完成属性填充（已注入UserService的早期引用）
2. OrderService完成初始化（调用各种初始化方法）
3. 如果OrderService需要被代理，创建代理对象（AOP）
4. 将完全初始化好的OrderService放入一级缓存
   singletonObjects.put("orderService", 完全初始化的orderService)
5. 返回到UserService的属性填充流程，将完全初始化好的OrderService注入到UserService中
6. UserService完成初始化
7. 如果UserService需要被代理且之前没有提前创建代理，创建代理对象
8. 将完全初始化好的UserService放入一级缓存
   singletonObjects.put("userService", 完全初始化的userService)

3. 关键源码执行分析

让我们看一下在这个过程中涉及的关键源码执行流程：

3.1 从getSingleton方法开始

当Spring尝试获取一个Bean时，首先会调用getSingleton方法：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 首先从一级缓存查找
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 如果一级缓存没有，且该Bean正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 从二级缓存查找
        singletonObject = this.earlySingletonObjects.get(beanName);
        
        // 如果二级缓存也没有，且允许早期引用
        if (singletonObject == null && allowEarlyReference) {
            // 从三级缓存获取工厂
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                // 通过工厂获取早期引用
                singletonObject = singletonFactory.getObject();
                // 放入二级缓存
                this.earlySingletonObjects.put(beanName, singletonObject);
                // 从三级缓存移除
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

3.2 添加Bean到三级缓存

在Bean实例化后，Spring会将其添加到三级缓存中：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 如果一级缓存中不存在
        if (!this.singletonObjects.containsKey(beanName)) {
            // 添加到三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            // 确保二级缓存中不存在
            this.earlySingletonObjects.remove(beanName);
            // 记录注册的单例
            this.registeredSingletons.add(beanName);
        }
    }
}

3.3 创建早期引用

当需要处理循环依赖时，Spring会通过getEarlyBeanReference方法获取早期引用：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = 
                    (SmartInstantiationAwareBeanPostProcessor) bp;
                // 这里可能创建代理对象
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

4. AOP场景下的循环依赖

特别值得注意的是，当涉及到AOP代理时，循环依赖的处理会更加复杂。例如，如果我们的示例中添加了事务注解：

@Service
@Transactional
public class UserService {
    // ...
}

@Service
@Transactional
public class OrderService {
    // ...
}

在这种情况下：

  1. 当从三级缓存获取UserService的早期引用时，会通过AbstractAutoProxyCreator.getEarlyBeanReference方法创建代理对象
  2. 这个代理对象会被放入二级缓存，并最终注入到OrderService中
  3. 这就确保了OrderService依赖的是UserService的代理对象，而不是原始对象

这也解释了为什么需要三级缓存而不是二级缓存：三级缓存中存储的工厂可以在需要时（出现循环依赖时）才创建代理对象，而不是对所有Bean都提前创建代理。

5. 总结

通过这个实际示例，我们可以清晰地看到Spring如何通过三级缓存机制解决循环依赖问题：

  1. 实例化Bean后立即将其工厂对象放入三级缓存
  2. 当出现循环依赖时，通过三级缓存获取早期引用（可能是代理对象）
  3. 将早期引用放入二级缓存，并从三级缓存中移除
  4. 使用早期引用完成依赖注入
  5. 最终将完全初始化的Bean放入一级缓存

这种机制既解决了循环依赖问题，又保持了Spring Bean生命周期的完整性，同时还能灵活处理AOP代理场景，体现了Spring框架设计的精妙之处。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2403960.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

微软PowerBI考试 PL300-使用适用于 Power BI 的 Copilot 创建交互式报表

微软PowerBI考试 PL300-使用适用于 Power BI 的 Copilot 创建交互式报表

微软PowerBI考试 PL300-使用适用于 Power BI 的 Copilot 创建交互式报表 Microsoft Power BI 可帮助您通过交互式报表准备数据并对数据进行可视化。 如果您是 Power BI 的新用户&#xff0c;可能很难知道从哪里开始&#xff0c;并且创建报表可能很耗时。 通过适用于 Power BI …
阅读更多...
Prompt提示工程指南#Kontext图像到图像

Prompt提示工程指南#Kontext图像到图像

重要提示&#xff1a;单个prompt的最大token数为512 # 核心能力 Kontext图像编辑系统能够&#xff1a; 理解图像上下文语义实现精准的局部修改保持原始图像风格一致性支持复杂的多步迭代编辑 # 基础对象修改 示例场景&#xff1a;改变汽车颜色 Prompt设计&#xff1a; Change …
阅读更多...
产品经理课程（十一）

产品经理课程（十一）

&#xff08;一&#xff09;复习 1、用户需求不等于产品需求&#xff0c;挖掘用户的本质需求 2、功能设计的前提&#xff1a;不违背我们的产品的基础定位&#xff08;用一句话阐述我们的产品&#xff1a;工具&#xff1a;产品画布&#xff09; 3、判断设计好坏的标准&#xf…
阅读更多...
Moldflow充填分析设置

Moldflow充填分析设置

1. 如何选择注塑机&#xff1a; 注塑机初选按注射量来选择&#xff1a; 点网格统计;选择三角形, 三角形体积就是产品的体积 47.7304 cm^3 点网格统计;选择柱体, 柱体的体积就是浇注系统的体积2.69 cm^3 所以总体积产品体积浇注系统体积 47.732.69 cm^3 材料的熔体密度与固体…
阅读更多...
Imprompter: Tricking LLM Agents into Improper Tool Use

Imprompter: Tricking LLM Agents into Improper Tool Use

原文&#xff1a;Imprompter: Tricking LLM Agents into Improper Tool Use 代码&#xff1a;Reapor-Yurnero/imprompter: Codebase of https://arxiv.org/abs/2410.14923 实机演示&#xff1a;Imprompter 摘要&#xff1a; 新兴发展的Agent可以将LLM与外部资源工具相结合&a…
阅读更多...
【大模型:知识图谱】--3.py2neo连接图数据库neo4j

【大模型:知识图谱】--3.py2neo连接图数据库neo4j

【图数据库】--Neo4j 安装_neo4j安装-CSDN博客 需要打开图数据库Neo4j&#xff0c; neo4j console 目录 1.图数据库--连接 2.图数据库--操作 2.1.创建节点 2.2.删除节点 2.3.增改属性 2.4.建立关系 2.5.查询节点 2.6.查询关系 3.图数据库--实例 1.图数据库--连接 fr…
阅读更多...
如何理解机器人课程的技术壁垒~壁垒和赚钱是两件不同的事情

如何理解机器人课程的技术壁垒~壁垒和赚钱是两件不同的事情

答疑&#xff1a; 有部分朋友私聊说博客内容&#xff0c;越来越不适合人类阅读习惯…… 可以做这种理解&#xff0c;我从23年之后&#xff0c;博客会不会就是写给机器看的。 或者说我在以黑盒方式测试AI推荐的风格。 主观-客观-主观螺旋式发展过程。 2015最早的一篇博客重…
阅读更多...
selinux firewalld

selinux firewalld

一、selinux 1.说明 SELinux 是 Security-Enhanced Linux 的缩写&#xff0c;意思是安全强化的 linux&#xff1b; SELinux 主要由美国国家安全局&#xff08;NSA&#xff09;开发&#xff0c;当初开发的目的是为了避免资源的误用 DAC&#xff08;Discretionary Access Cont…
阅读更多...
408第一季 - 数据结构 - 字符串和KMP算法

408第一季 - 数据结构 - 字符串和KMP算法

闲聊 这章属于难点但考频低 3个名词记一下&#xff1a;模式匹配&#xff0c;主串&#xff0c;字串&#xff08;模式串&#xff09; 举个例子 主串 aabaaaabaab 字串 aabaab 模式匹配 从主串找到字串 暴力解法 也是不多说 很暴力就是了 KMP算法 next数组 它只和字串有关 先…
阅读更多...
如何查看自己电脑安装的Java——JDK

如何查看自己电脑安装的Java——JDK

开始->运行->然后输入cmd进入dos界面 &#xff08;快捷键windows->输入cmd&#xff09; 输入java -version&#xff0c;回车 出现了一下信息就是安装了jdk 输入java -verbose&#xff0c;回车 查看安装目录
阅读更多...
电力系统时间同步系统之三

电力系统时间同步系统之三

2.6 电力系统时间同步装置 时间同步装置主要完成时间信号和时间信息的同步传递&#xff0c;并提供相应的时间格式和物理接口。时间同步装置主要由三大部分组成&#xff1a;时间输入、内部时钟和时间输出&#xff0c;如图 2-25 所示。输入装置的时间信号和时间信息的精度必须不…
阅读更多...
火语言RPA--界面应用详解

火语言RPA--界面应用详解

新建一个界面应用后&#xff0c;软件将自动弹出一个界面设计器&#xff0c;本篇将介绍下流程设计器中各部分的功能。 UI控件列表 显示软件中自带的所有UI控件流程库 流程是颗粒组件的容器&#xff0c;可在建立的流程中添加颗粒组件编写成规则流程。 流程编辑好后再绑定UI控件…
阅读更多...
基于Spring Boot的云音乐平台设计与实现

基于Spring Boot的云音乐平台设计与实现

基于Spring Boot的云音乐平台设计与实现——集成协同过滤推荐算法的全栈项目实战 &#x1f4d6; 文章目录 项目概述技术选型与架构设计数据库设计后端核心功能实现推荐算法设计与实现前端交互设计系统优化与性能提升项目部署与测试总结与展望 项目概述 &#x1f3af; 项目背…
阅读更多...
Neovim - 打造一款属于自己的编辑器（一）

Neovim - 打造一款属于自己的编辑器（一）

文章目录 前言&#xff08;劝退&#xff09;neovim 安装neovim 配置配置文件位置第一个 hello world 代码拆分 neovim 配置正式配置 neovim基础配置自定义键位Lazy 插件管理器配置tokyonight 插件配置BufferLine 插件配置自动补全括号 / 引号 插件配置 前言&#xff08;劝退&am…
阅读更多...
RAG检索系统的两大核心利器——Embedding模型和Rerank模型

RAG检索系统的两大核心利器——Embedding模型和Rerank模型

在RAG系统中&#xff0c;有两个非常重要的模型一个是Embedding模型&#xff0c;另一个则是Rerank模型&#xff1b;这两个模型在RAG中扮演着重要角色。 Embedding模型的作用是把数据向量化&#xff0c;通过降维的方式&#xff0c;使得可以通过欧式距离&#xff0c;余弦函数等计算…
阅读更多...
CLion社区免费后，使用CLion开发STM32相关工具资源汇总与入门教程

CLion社区免费后，使用CLion开发STM32相关工具资源汇总与入门教程

Clion下载与配置 Clion推出社区免费&#xff0c;就是需要注册一个账号使用&#xff0c;大家就不用去找破解版版本了&#xff0c;jetbrains家的IDEA用过的都说好&#xff0c;这里嵌入式领域也推荐使用。 CLion官网下载地址 安装没有什么特别&#xff0c;下一步就好。 启动登录…
阅读更多...
第21讲、Odoo 18 配置机制详解

第21讲、Odoo 18 配置机制详解

Odoo 18 配置机制详解&#xff1a;res.config.settings 与 ir.config_parameter 原理与实战指南 在现代企业信息化系统中&#xff0c;灵活且可维护的系统参数配置是模块开发的核心能力之一。Odoo 作为一款高度模块化的企业管理软件&#xff0c;其参数配置机制主要依赖于两个关…
阅读更多...
【计算机网络】Linux下简单的TCP服务器（超详细）

【计算机网络】Linux下简单的TCP服务器（超详细）

服务端 创建套接字 &#x1f4bb;我们将TCP服务器封装成一个类&#xff0c;当我们定义出一个服务器对象后需要马上对服务器进行初始化&#xff0c;而初始化TCP服务器要做的第一件事就是创建套接字。 TCP服务器在调用socket函数创建套接字时&#xff0c;参数设置如下&#xff1…
阅读更多...
最新Spring Security实战教程（十七）企业级安全方案设计 - 多因素认证（MFA）实现

最新Spring Security实战教程（十七）企业级安全方案设计 - 多因素认证（MFA）实现

&#x1f337; 古之立大事者&#xff0c;不惟有超世之才&#xff0c;亦必有坚忍不拔之志 &#x1f390; 个人CSND主页——Micro麦可乐的博客 &#x1f425;《Docker实操教程》专栏以最新的Centos版本为基础进行Docker实操教程&#xff0c;入门到实战 &#x1f33a;《RabbitMQ》…
阅读更多...
html+css+js趣味小游戏~Cookie Clicker放置休闲（附源码）

html+css+js趣味小游戏~Cookie Clicker放置休闲（附源码）

下面是一个简单的记忆卡片配对游戏的完整代码&#xff0c;使用HTML、CSS和JavaScript实现&#xff1a; html <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"wid…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023