深入理解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的三级缓存机制，并在实际开发中应用这一强大的工具。