Spring中的三级缓存及其原因

最新推荐文章于 2025-04-29 12:36:02 发布
最新推荐文章于 2025-04-29 12:36:02 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46741750/article/details/119579315
版权
本文详细介绍了Spring中解决循环依赖的三级缓存机制：singletonObjects（一级缓存），singletonFactories（二级缓存）和earlySingletonObjects（三级缓存）。通过分析不使用AOP时的二级缓存处理流程和使用AOP时引入三级缓存的原因，阐述了三级缓存在处理循环依赖和确保对象正确代理的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

首先看下Spring创建一个bean的基本流程：

创建该实例的原始对象 --> 进行自动装配 --> AOP代理处理 --> 完成bean的创建并加入单例池(即一级缓存)

但是当有循环依赖的时候，Spring是如何解决的呢？

主要原理是利用三级缓存机制：
在这里插入图片描述

singletonObjects： 一级缓存，也就是我们平常理解的单例池。
singletonFactories： 二级缓存，存储的是单例工厂。
earlySingletonObjects： 三级缓存，存储正在创建中的单例对象。
为什么要设立三级缓存呢？

其实当不需要实现AOP的时候，解决循环依赖不用三级缓存机制，也不用单例工厂，二级缓存就足以实现。

第一级：singletonObjects
第二级：earlySingletonObjects

不需要实现AOP时Spring解决循环依赖基本流程：

假设单例一与单例二相互依赖对方并且此时都没有加入到单例池
1 创建单例一
2 将单例一加入earlySingletonObjects缓存
3 自动装配单例二
4 判断单例二在earlySingletonObjects缓存是否存在
5 不存在则创建单例二
6 将单例二并且加入earlySingletonObjects缓存
7 自动装配单例一
8 判断单例一在earlySingletonObjects缓存是否存在
9 明显第2步已经加入earlySingletonObje

最低0.47元/天 解锁文章
spring三级缓存
Addison艾迪生博客
07-16 962
在Spring框架中，三级缓存机制是其解决循环依赖问题的关键设计之一，特别是在处理单例bean的循环依赖时。Bean的定义信息完全初始化完毕Bean被创建但尚未完成其全部初始化。
Spring的三级缓存及其原因
Mr_Gu的博客
02-27 8992
首先看下Spring创建一个bean的基本流程： 创建该实例的原始对象 --> 进行自动装配 --> AOP代理处理 --> 完成bean的创建并加入单例池(即一级缓存) 但是当有循环依赖的时候，Spring是如何解决的呢？ 主要原理是利用三级缓存机制： singletonObjects： 一级缓存，也就是我们平常理解的单例池。 singletonFactories： 二级缓存，存储的是单例工厂。 earlySingletonObjects： 三级缓存，存储正在创建中的单例对象。
Spring的Bean加载和三级缓存解决循环依赖
花未央D8023的博客
10-31 1506
转载来源:https://www.cnblogs.com/semi-sub/p/13548479.html 前言 在使用spring框架的日常开发中，bean之间的循环依赖太频繁了，spring已经帮我们去解决循环依赖问题，对我们开发者来说是无感知的，下面具体分析一下spring是如何解决bean之间循环依赖，为什么要使用到三级缓存，而不是二级缓存 bean生命周期 首先大家需要了解一下bean在spring中的生命周期，bean在spring的加载流程，才能够更加清晰知道sp...
Spring为什么使用三级缓存解决循环依赖
最新发布
weixin_37518202的博客
04-29 908
循环依赖是指两个或多个Bean之间相互依赖对方，形成了一个闭环的依赖关系。Bean A依赖Bean BBean B又依赖Bean A@Component@Autowired@Component@Autowired这就像是"鸡生蛋、蛋生鸡"的问题：Spring在创建Bean A时，发现需要先注入Bean B，于是去创建Bean B，但创建Bean B时又发现需要注入Bean A，这样就陷入了死循环。循环依赖是指两个或多个Bean之间相互依赖，形成闭环。Spring的三级缓存。
Spring系列第56篇：一文搞懂spring到底为什么要用三级缓存？？
路人甲Java
02-22 1万+
今天来聊一个面试中经常会被问到的问题，咱们一起必须把这个问题搞懂。问题：spring 中为什么需要用三级缓存来解决这个问题？用二级缓存可以么？我先给出答案：不可用。这里先声明下：本文未指明...
Spring 三级缓存的原理
lyzchengxuyuan的博客
05-14 1729
如果需要获取该单例对象实例，会首先从该缓存中查找。当完成单例对象实例的扫描后，Spring会将所有扫描到的单例对象实例放入singletonFactories缓存中。总之，Spring框架的三级缓存通过将单例对象实例和工厂类实例分别存放在不同的缓存中，实现了对单例对象的高效管理。同时，通过使用三级缓存，可以避免重复创建单例对象实例和工厂类实例，提高了应用程序的性能和效率。当需要获取单例对象实例并且在第二级缓存中没有找到时，Spring会继续查找，直到找到或者遍历完所有的单例对象实例为止。
Spring的三级缓存
热门推荐
weixin_40133204的博客
12-19 1万+
Spring三级缓存 对象创建的过程 spring的三级缓存分别是 // 从上至下 分表代表这“三级缓存” private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); //
java——Spring 中循环依赖 三级缓存
oopxiajun博客专栏
11-05 1280
直接循环依赖：两个Bean互相依赖，例如Bean A依赖于Bean B，同时Bean B也依赖于Bean A。间接循环依赖：通过多个Bean形成一个依赖链，最终回到起点，形成一个闭环。一级缓存（singletonObjects）：存储已经完全初始化和实例化的Bean对象。这个缓存的目的是确保Bean只初始化一次（是单例的），避免多次实例化相同的Bean对象，提高性能。二级缓存（earlySingletonObjects）：存储尚未完成属性注入和初始化的“半成品”Bean对象。
2、spring源码分析-三级缓存
LiMianDeRen的博客
01-17 523
大家对spring源码有过研究的同学，都知道spring的源码的核心是AbstractApplicationContext得refresh方法，该方法是整个spring容器的生命周期核心主线，当所有类的bean定义处理完成后，会调用AbstractApplicationContext#finishBeanFactoryInitialization()方法进行bean对象实例初始化。在获取bean中，会调用doGetBean方法进行获取，在这个方法中，会根据bean的作用域进行分别处理；
spring为什么需要三级缓存
xw0105的博客
03-16 545
这里你不用担心，如果这里获取的是代理对象，那么最后完全创建好的对象也是代理对象，ObjectFactory获取的对象和最终完全创建好的还是同一个，不是同一个肯定会报错，所以上面的理论依然符合，这里只是更加的细节化。但是这样的话，就和spring的aop的设计原则相驳，aop的实现需要与bean的正常生命周期的创建分离；第一级缓存，也就是缓存完全创建好的Bean的缓存，这个缓存肯定是需要的，因为单例的Bean只能创建一次，那么肯定需要第一级缓存存储这些对象，如果有需要，直接从第一级缓存返回。
Spring三级缓存原理
JavaSupeMan的博客
08-11 1433
lambda表达式:作用是判断该对象是否AOP，存储普通对象还是代理对象。二级缓存:作用在于，不会多次创建出普通对象或者代理对象。
Spring--三级缓存机制
gghhb12的博客
08-25 6095
/ 一级缓存Map 存放完整的Bean（流程跑完的）// 二级缓存Map 存放不完整的Bean（只实例化完，还没属性赋值、初始化）// 三级缓存Map 存放一个Bean的lambda表达式（也是刚实例化完）用来解决什么问题？这个大家应该熟知了，就是循环依赖什么是循环依赖?就像下面这样，AService 中注入了BService ，而BService 中又注入了AService ，这就是循环依赖@Service@Resource@Service@Resource。
为什么spring要使用三级缓存？
weixin_43696693的博客
04-12 853
一级缓存：代理过 & 属性赋值 完成的Bean二级缓存：提前代理好了 & 属性未完全赋值三级缓存：对象工厂，包含提前代理的逻辑能否把二三级合并？每次都提前判断是否代理再放到二级缓存中？可以，但是这样做彻底违背了Spring初衷，因为这样做的话，所有代理都提前到了初始化阶段前面做。能否全部合并？每次都代理好放入一级缓存中？
spring的三级缓存
风过于前的博客
04-01 376
Spring的循环引用有时候我们可能会涉及到两个bean对象互相引用的情况，通过对bean的实例化过程的了解，我们知道spring会先将这个bean对象所有的实例属性填充完毕，才会将这个bean实例化。于是这样便会产生一个死锁问题。对于这种情况，spring内部采用了三级缓存机制来解决上述问题。举个例子</</</</
spring 的三级缓存
艾斯比
11-09 281
spring 三级缓存 一级缓存: 已初始化完成的 bean 二级缓存: 早期暴露的不完整的 bean, 刚刚实例化对象, 没有依赖注入 三级缓存: 有循环引用的代理对象 二级和三级都是为了解决循环引用问题
Spring源码之bean的加载(二)获取单例bean
owen_william的博客
03-23 1328
我们知道，单例bean在系统的加载只加载一次，后期如果想用到对应的bean的话，那么就应该去缓存中获取。当然，首先是尝试去缓存中加载，然后再尝试从singletonFactories中加载。  通过上面的时序图，我们可以找到对应的源码，首先我们看到的是AbstractBeanFactory中的getBean()的函数，之后，又会去调用doGetBean()，其次就到到DefaultSin
spring采用三级缓存
04-13
<think>好的，我现在需要详细分析Spring框架中的三级缓存机制，包括它的实现机制和作用原理。首先，我需要回忆一下用户提供的引用内容，特别是引用[1]、[3]中的信息，这些提到了三级缓存用于解决循环依赖和支持AOP。 首先，三级缓存是什么？根据引用[1]和[3]，Spring的三级缓存包括三个不同的缓存层，可能分别是singletonObjects、earlySingletonObjects和singletonFactories。每个缓存的作用是什么呢？ 接下来，我需要理解Bean的创建过程。根据引用[3]，Bean的生命周期包括实例化、属性填充、初始化等阶段。在解决循环依赖时，当Bean A依赖Bean B，而Bean B又依赖Bean A时，Spring需要确保两者都能正确创建。这时，三级缓存中的机制可能是在Bean实例化后，提前暴露一个对象引用，避免无限循环。 然后，三级缓存的具体实现机制。根据引用[3]，一级缓存singletonObjects存放完全初始化的Bean，二级缓存earlySingletonObjects存放早期暴露的对象，三级缓存singletonFactories存放生成早期对象的工厂。当创建Bean时，Spring首先检查一级缓存，如果没有，则检查二级缓存，再没有的话，使用三级缓存中的工厂创建早期对象，并将其放入二级缓存。这样，当其他Bean需要依赖当前Bean时，可以获取到早期的引用，完成属性注入，从而解决循环依赖。 此外，三级缓存如何支持AOP？可能是在创建代理对象时，需要确保代理的一致性。如果Bean被AOP代理，那么提前暴露的应该是代理对象而不是原始对象。通过三级缓存中的工厂，Spring可以在需要时生成代理对象，保证在循环依赖中注入的是最终的代理对象，而不是原始对象，从而避免不一致的问题。 现在需要验证这些理解是否正确。根据引用[1]，三级缓存用于处理实例化和依赖注入，确保循环依赖下正确创建Bean。引用[3]指出三级缓存解决了循环依赖和AOP的支持。因此，我的理解应该是正确的。 最后，总结三级缓存的工作流程：创建Bean时，先实例化，然后放入三级缓存；当需要注入依赖时，从三级缓存获取工厂生成早期对象，并将其升级到二级缓存；完成属性填充和初始化后，放入一级缓存，并清理下级缓存。这样既解决了循环依赖，又处理了AOP代理的问题。</think>### Spring框架三级缓存实现机制及作用原理 #### 一、三级缓存的定义与作用 Spring框架通过**三级缓存**解决**循环依赖**问题，并支持**AOP代理对象**的一致性。三级缓存具体分为： 1. **一级缓存（`singletonObjects`）** 存储**完全初始化**的单例Bean，可直接使用。 2. **二级缓存（`earlySingletonObjects`）** 存储**早期暴露的Bean实例**（已实例化但未完成属性注入和初始化）。 3. **三级缓存（`singletonFactories`）** 存储**Bean工厂对象**（`ObjectFactory`），用于生成早期Bean的引用。 #### 二、实现机制与流程 以Bean A和Bean B相互依赖为例： 1. **创建Bean A** - **实例化**：调用构造器创建Bean A的原始对象`a`。 - **提前暴露引用**：将`a`的工厂（`ObjectFactory`）存入**三级缓存**。 $$ \text{三级缓存：A → ObjectFactory(a)} $$ 2. **填充Bean A的属性** - 发现依赖Bean B，触发**Bean B的创建**。 3. **创建Bean B** - 实例化Bean B的原始对象`b`，将其工厂存入三级缓存。 - 填充Bean B的属性时，发现依赖Bean A，尝试从**一级缓存**获取A。 - 未找到A，从**三级缓存**获取A的工厂，生成早期对象`a'`，将`a'`升级到**二级缓存**并清理三级缓存。 $$ \text{二级缓存：A → a'} $$ - Bean B完成初始化后存入一级缓存。 4. **继续初始化Bean A** - 从二级缓存获取`a'`，完成属性注入和初始化。 - 将Bean A存入一级缓存，清理二级缓存。 #### 三、关键设计点 1. **循环依赖的解决** - 通过**提前暴露半成品Bean**（三级缓存工厂）打破循环链。 2. **AOP代理的支持** - 若Bean需要代理，三级缓存的工厂会返回**代理对象**而非原始对象，确保依赖注入的一致性[^3]。 - 例如，若Bean A需代理，则工厂生成的`a'`是代理对象，避免后续流程出现原始对象与代理对象混合的问题。 #### 四、流程图解 ```plaintext 创建Bean A → 实例化 → 存入三级缓存 → 填充属性（发现依赖B） ↓ 创建Bean B → 实例化 → 存入三级缓存 → 填充属性（发现依赖A） ↓ 从三级缓存获取A的工厂 → 生成A的早期对象 → 存入二级缓存 ↓ Bean B完成初始化 → 存入一级缓存 ↓ 继续初始化Bean A → 从二级缓存获取 → 完成 → 存入一级缓存 ``` #### 五、典型问题场景 1. **仅两级缓存能否解决循环依赖？** - 无法处理AOP代理场景，可能导致注入原始对象而非代理对象。 2. **为什么三级缓存使用`ObjectFactory`？** - 延迟生成代理对象，仅在需要时通过工厂创建，避免重复生成[^3]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值