Spring为啥用三级缓存而不用两级缓存

为什么Spring使用三级缓存而不是两级缓存？

在Spring框架中，三级缓存机制在Bean的创建过程中起着至关重要的作用。它不仅提高了性能，还解决了Bean循环依赖的问题。以下将详细探讨为什么Spring选择三级缓存而不是两级缓存，以及其具体实现和优势。

一、三级缓存的概念

在Spring中，三级缓存包括以下三个部分：

Singleton Objects（一级缓存）：用于存储完全初始化的单例Bean，类型为 Map<String, Object>。
Early Singleton Objects（二级缓存）：用于存储部分初始化但尚未完全初始化的Bean，类型为 Map<String, Object>。
Singleton Factories（三级缓存）：用于存储能够生成Bean实例的Factory对象，类型为 Map<String, ObjectFactory<?>>。

二、三级缓存的作用

1. 解决循环依赖

循环依赖是指在Bean A依赖Bean B的情况下，Bean B又依赖于Bean A。为了打破这种循环依赖，Spring引入了三级缓存。

在创建Bean的过程中，当A依赖B而B又依赖A时，Spring首先会将A的原始对象（尚未完全初始化）存储在三级缓存中。然后，当需要注入A到B时，Spring会从三级缓存中获取A的原始对象，从而打破循环依赖。

2. 提高性能

三级缓存机制还提高了性能，通过分阶段缓存不同状态的Bean，减少了重复创建和初始化的开销。

三、三级缓存的实现

Spring的三级缓存机制在 DefaultSingletonBeanRegistry类中实现，核心代码如下：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

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

    // 二级缓存：提前暴露的单例对象，尚未完全初始化
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

    // 三级缓存：单例工厂，能够生成单例对象
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    // 获取单例Bean
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 从一级缓存中获取
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.singletonObjectsCurrentlyInCreation.contains(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;
    }

    // 注册单例工厂
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
            }
        }
    }
}

四、两级缓存的局限性

如果Spring仅使用两级缓存（如一级缓存和二级缓存），则在处理循环依赖时会面临以下问题：

无法提前暴露部分初始化的Bean：在创建Bean时，如果只能在二级缓存中存储部分初始化的Bean，当依赖项需要注入时，无法从缓存中获取到已部分初始化的Bean，导致循环依赖无法解决。
性能问题：两级缓存无法有效分离不同状态的Bean，可能导致重复初始化和性能下降。

五、三级缓存的优势

解决循环依赖：通过三级缓存，Spring可以提前暴露部分初始化的Bean，从而解决循环依赖的问题。
优化性能：三级缓存机制将不同状态的Bean分开存储和管理，提高了Bean创建和初始化的效率。

六、总结

Spring选择使用三级缓存而不是两级缓存，主要是为了更好地解决循环依赖问题并优化性能。三级缓存通过分阶段缓存不同状态的Bean，实现了灵活高效的Bean管理机制。这种设计不仅提升了Spring的健壮性和可维护性，还为开发者提供了更高效的开发体验。

思维导图

三级缓存在Spring中的作用
│
├── 一级缓存（Singleton Objects）
│   └── 存储完全初始化的单例Bean
│
├── 二级缓存（Early Singleton Objects）
│   └── 存储部分初始化但尚未完全初始化的Bean
│
├── 三级缓存（Singleton Factories）
│   └── 存储能够生成Bean实例的Factory对象
│
├── 三级缓存的实现
│   ├── getSingleton()
│   └── addSingletonFactory()
│
└── 三级缓存的优势
    ├── 解决循环依赖
    └── 优化性能

通过上述分析，我们可以清楚地了解为什么Spring采用三级缓存机制，以及它在解决循环依赖和优化性能方面的优势。