深入理解Spring的三级缓存机制
个人名片
🎓作者简介：java领域优质创作者 🌐个人主页：码农阿豪 📞工作室：新空间代码工作室（提供各种软件服务） 💌个人邮箱：[2435024119@qq.com] 📱个人微信：15279484656 🌐个人导航网站：www.forff.top 💡座右铭：总有人要赢。为什么不能是我呢？
- 专栏导航：
码农阿豪系列专栏导航 面试专栏：收集了java相关高频面试题，面试实战总结🍻🎉🖥️ Spring5系列专栏：整理了Spring5重要知识点与实战演练，有案例可直接使用🚀🔧💻 Redis专栏：Redis从零到一学习分享，经验总结，案例实战💐📝💡 全栈系列专栏：海纳百川有容乃大，可能你想要的东西里面都有🤸🌱🚀
目录
- 深入理解Spring的三级缓存机制
- 什么是三级缓存
- 为什么需要三级缓存
- 示例说明
- 三级缓存的实现原理
- 初始化流程
- 关键代码解析
- 三级缓存的工作流程
- 流程图
- 实际应用
- 源码解析
- `DefaultSingletonBeanRegistry` 类
- `getSingleton` 方法
- 总结
深入理解Spring的三级缓存机制
在Spring的源码中，有一个非常重要但常被忽视的设计——三级缓存。三级缓存是Spring解决循环依赖问题的关键机制之一，它在Spring容器初始化Bean时起到了至关重要的作用。本文将详细介绍Spring的三级缓存机制，探讨其实现原理和应用场景，并结合源码解析进一步理解其工作流程。
什么是三级缓存
在Spring的Bean生命周期中，三级缓存主要用于解决循环依赖问题。三级缓存分为以下三个部分：
- 一级缓存（singletonObjects）：用于存储完全初始化好的单例Bean。
- 二级缓存（earlySingletonObjects）：用于存储提前暴露的单例Bean，主要是为了应对循环依赖问题。
- 三级缓存（singletonFactories）：用于存储ObjectFactory，用于在需要时创建Bean。
这三个缓存共同协作，保证了Spring能够处理复杂的Bean依赖关系。
为什么需要三级缓存
在Spring容器启动过程中，如果两个Bean相互依赖，可能会导致循环依赖问题。假设有两个Bean，A和B，A依赖于B，B又依赖于A。如果没有缓存机制，Spring容器在初始化A和B时，会陷入无限循环，最终导致StackOverflowError。三级缓存的引入正是为了解决这一问题，通过提前暴露Bean引用，保证依赖注入的顺利进行。
示例说明
假设有以下两个类：
public class A {
private B b;
public void setB(B b) {
this.b = b;
}
}
public class B {
private A a;
public void setA(A a) {
this.a = a;
}
}A依赖B，B依赖A，这就是一个典型的循环依赖。在没有缓存机制的情况下，Spring容器会在创建A时发现需要B，但创建B时又需要A，最终陷入死循环。
三级缓存的实现原理
Spring的三级缓存主要在DefaultSingletonBeanRegistry类中实现，该类包含了以下三个关键属性：
singletonObjects: 一级缓存，存储完全初始化好的单例Bean。earlySingletonObjects: 二级缓存，存储提前暴露的单例Bean。singletonFactories: 三级缓存，存储ObjectFactory，用于在需要时创建Bean。
初始化流程
- 创建Bean实例： Spring首先会尝试从一级缓存中获取Bean实例，如果没有找到，则会从二级缓存中获取，如果仍未找到，则会从三级缓存中获取。如果三级缓存中也没有，才会创建新的Bean实例。
- 提前暴露Bean引用： 在创建Bean实例的过程中，Spring会将创建中的Bean实例提前暴露到三级缓存中。这一步是通过将Bean包装成一个ObjectFactory来实现的，该ObjectFactory在需要时可以返回Bean实例。
- 处理依赖注入： 在进行依赖注入时，如果依赖的Bean存在循环引用，Spring会从三级缓存中获取提前暴露的Bean实例，以解决循环依赖问题。
- 完成初始化： 在完成依赖注入和其他初始化操作后，Spring会将完全初始化好的Bean实例从三级缓存中移到二级缓存，再从二级缓存移到一级缓存，确保后续可以直接从一级缓存中获取。
关键代码解析
以下是Spring源码中涉及三级缓存的关键代码片段：
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
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;
}在getSingleton方法中，Spring首先从一级缓存中获取Bean实例，如果没有找到，再尝试从二级缓存中获取，最后从三级缓存中获取ObjectFactory来创建Bean实例。
三级缓存的工作流程
三级缓存的工作流程可以分为以下几个步骤：
- 创建Bean实例： 当Spring容器开始创建一个Bean时，会首先尝试从一级缓存中获取，如果没有找到，则会创建新的Bean实例，并将该实例的ObjectFactory放入三级缓存中。
- 提前暴露Bean引用： 在创建Bean实例的过程中，如果发现Bean依赖其他Bean（包括自身依赖），Spring会将创建中的Bean实例提前暴露到三级缓存中，以便其他Bean可以引用。
- 依赖注入： 当Spring发现Bean依赖其他Bean时，会从三级缓存中获取提前暴露的Bean引用，解决循环依赖问题。
- 完成初始化： 在完成依赖注入和其他初始化操作后，Spring会将完全初始化好的Bean实例从三级缓存中移到二级缓存，再移到一级缓存，以确保后续可以直接从一级缓存中获取。
流程图
以下是三级缓存工作流程的简要图示：
+-------------------------+
| |
| 1. 创建Bean实例 |
| |
+-----------+-------------+
|
v
+-----------+-------------+
| |
| 2. 提前暴露Bean引用 |
| |
+-----------+-------------+
|
v
+-----------+-------------+
| |
| 3. 依赖注入处理 |
| |
+-----------+-------------+
|
v
+-----------+-------------+
| |
| 4. 完成初始化 |
| |
+-------------------------+实际应用
在实际应用中，三级缓存主要用于解决循环依赖问题。例如，在一个复杂的业务场景中，如果多个服务相互依赖，三级缓存可以保证Spring容器能够顺利初始化所有服务，避免循环依赖导致的错误。
源码解析
我们以Spring的源码为例，进一步解析三级缓存的实现。
DefaultSingletonBeanRegistry 类
DefaultSingletonBeanRegistry是三级缓存机制的核心类。以下是该类的部分源码：
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// other methods...
}在DefaultSingletonBeanRegistry类中，singletonObjects是一级缓存，earlySingletonObjects是二级缓存，singletonFactories是三级缓存。
getSingleton 方法
getSingleton方法是获取单例Bean实例的核心方法，以下是该方法的简化版源码：
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
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;
}在getSingleton方法中，Spring首先尝试从一级缓存（singletonObjects）中获取Bean实例。如果没有找到，并且当前Bean正在创建中（循环依赖的情况），则尝试从二级缓存（earlySingletonObjects）中获取。如果二级缓存中也没有找到，并且允许提前引用（allowEarlyReference为true），则从三级缓存（singletonFactories）中获取ObjectFactory并创建Bean实例。
总结
通过本文的详细解析，我们了解了Spring的三级缓存机制及其在解决循环依赖问题中的重要作用。三级缓存包括一级缓存、二级缓存和三级缓存，它们分别用于存储完全初始化好的单例Bean、提前暴露的单例Bean以及ObjectFactory。三级缓存共同协作，保证了Spring容器能够处理复杂的依赖关系，顺利初始化所有Bean。
三级缓存的引入有效解决了循环依赖问题，使得Spring容器在处理复杂的依赖关系时更加灵活和高效。在实际应用中，理解并掌握三级缓存机制，可以帮助我们更好地解决Bean的依赖注入问题，提升Spring应用的稳定性和可维护性。希望本文能够帮助读者深入理解Spring的三级缓存机制，并在实际开发中应用这一强大的工具。
腾讯云开发者
