Spring框架中的三级缓存机制及其在解决循环依赖问题中的作用

三级缓存的定义与组成

Spring框架中的三级缓存是指Spring IoC容器在创建和管理Bean实例时使用的三个Map缓存结构，它们分别是：

一级缓存（singletonObjects）

• 存储完全初始化好的单例Bean
• Key为Bean的名称，Value为Bean的实例
• 也称为"单例池"
• 当我们通过getBean()方法获取Bean时，首先会在这个缓存中查找

二级缓存（earlySingletonObjects）

• 存储提前暴露的未完全初始化的Bean
• Key为Bean的名称，Value为提前暴露的Bean实例
• 主要用于解决循环依赖问题
• 当一个Bean被提前暴露后，会先放在这个缓存中

三级缓存（singletonFactories）

• 存储Bean工厂对象（ObjectFactory）
• Key为Bean的名称，Value为对应的ObjectFactory
• 当创建Bean实例时，会先将ObjectFactory放入这个缓存
• 如果发生循环依赖，可以通过这个工厂获取提前暴露的Bean

循环依赖问题

循环依赖是指两个或多个Bean相互依赖，例如：

• Bean A依赖于Bean B
• Bean B又依赖于Bean A

如果没有特殊处理，这种循环依赖会导致无限递归，最终引发栈溢出异常。

三级缓存如何解决循环依赖

Spring通过三级缓存机制来解决循环依赖问题，其工作流程如下：

创建Bean A

1. 实例化Bean A（但未进行属性填充和初始化）
2. 将Bean A的工厂对象放入三级缓存（singletonFactories）
3. 将Bean A标记为"正在创建"

填充Bean A的属性

1. 发现Bean A依赖于Bean B
2. 尝试获取Bean B

创建Bean B

1. 实例化Bean B（但未进行属性填充和初始化）
2. 将Bean B的工厂对象放入三级缓存（singletonFactories）
3. 将Bean B标记为"正在创建"

填充Bean B的属性

1. 发现Bean B依赖于Bean A
2. 尝试获取Bean A
3. 发现Bean A正在创建中（在三级缓存中有对应的工厂）
4. 从三级缓存中获取Bean A的工厂，通过工厂创建提前暴露的Bean A
5. 将提前暴露的Bean A放入二级缓存（earlySingletonObjects）
6. 从三级缓存中移除Bean A的工厂
7. 将提前暴露的Bean A注入到Bean B中

完成Bean B的初始化

1. 完成Bean B的属性填充和初始化
2. 将完全初始化的Bean B放入一级缓存（singletonObjects）
3. 从二级缓存中移除Bean B（如果存在）

完成Bean A的初始化

1. 将完全初始化的Bean B注入到Bean A中
2. 完成Bean A的属性填充和初始化
3. 将完全初始化的Bean A放入一级缓存（singletonObjects）
4. 从二级缓存中移除Bean A

通过这种方式，Spring成功解决了循环依赖问题。关键在于提前暴露未完全初始化的Bean实例，使得其他依赖它的Bean可以先获取到它的引用，完成自己的初始化。

三级缓存的代码实现

/** 一级缓存：存储完全初始化好的单例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);

/** 正在创建中的Bean集合 */
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 从一级缓存中获取完全初始化的Bean
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 2. 如果一级缓存中没有，且Bean正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 3. 从二级缓存中获取提前暴露的Bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 4. 从三级缓存中获取Bean工厂
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 5. 通过工厂创建提前暴露的Bean
                    singletonObject = singletonFactory.getObject();
                    // 6. 将提前暴露的Bean放入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 7. 从三级缓存中移除Bean工厂
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            // 将Bean工厂放入三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            // 从二级缓存中移除（如果存在）
            this.earlySingletonObjects.remove(beanName);
        }
    }
}

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 将完全初始化的Bean放入一级缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 从三级缓存中移除
        this.singletonFactories.remove(beanName);
        // 从二级缓存中移除
        this.earlySingletonObjects.remove(beanName);
        // 从正在创建集合中移除
        this.singletonsCurrentlyInCreation.remove(beanName);
    }
}

三级缓存机制的限制

需要注意的是，Spring的三级缓存机制只能解决单例Bean的setter注入方式的循环依赖问题，对于以下情况无法解决：

构造器注入的循环依赖

• 因为构造器注入需要在实例化时就完成依赖注入
• 此时Bean还未创建完成，无法提前暴露

原型Bean的循环依赖

• 原型Bean每次请求都会创建一个新的实例
• Spring不会缓存原型Bean，因此无法解决循环依赖

多例Bean的循环依赖

• 与原型Bean类似，多例Bean也不会被缓存
• 因此无法解决循环依赖

总结

Spring框架中的三级缓存机制是解决循环依赖问题的关键，它通过提前暴露未完全初始化的Bean实例，使得相互依赖的Bean能够完成初始化。三级缓存分别是：

1. 一级缓存（singletonObjects）：存储完全初始化好的单例Bean
2. 二级缓存（earlySingletonObjects）：存储提前暴露的未完全初始化的Bean
3. 三级缓存（singletonFactories）：存储Bean工厂对象，用于生成提前暴露的Bean

通过这种机制，Spring能够有效地解决单例Bean的setter注入方式的循环依赖问题，提高了框架的灵活性和可用性。

参考资料

1. Spring Framework Documentation: The IoC Container
2. Spring源码分析：循环依赖的解决
3. Spring Framework Reference Documentation: Circular Dependencies
4. Spring源码解析 - 循环依赖