Spring--循环依赖以及三级缓存详解

一、什么是循环依赖

循环依赖是指两个或多个Bean之间相互依赖，形成一个闭环。例如：

Bean A 依赖 Bean B
Bean B 依赖 Bean A

示意图如下：

在大型应用中，还可能出现更复杂的循环依赖：

Bean A 依赖 Bean B
Bean B 依赖 Bean C
Bean C 依赖 Bean A

二、为什么循环依赖是个问题

在普通的对象创建过程中，循环依赖会导致类似"鸡生蛋，蛋生鸡"的问题：

创建A时，发现依赖B，转而去创建B
创建B时，发现依赖A，但A还未创建完成
系统陷入死循环

在没有特殊处理的情况下，这将导致应用启动失败。

三、Spring如何解决循环依赖

Spring通过巧妙的设计，采用了三级缓存 机制来解决循环依赖问题。这一机制主要针对单例作用域(singleton scope)的Bean。

注意：Spring无法解决以下循环依赖场景：

构造器注入的循环依赖:

实例化与初始化顺序问题：Spring解决循环依赖的关键在于先实例化对象，再进行属性注入。但构造器注入是在实例化阶段就需要依赖对象，这导致了"鸡蛋-鸡"的悖论。

三级缓存机制失效：三级缓存机制依赖于先创建实例再暴露早期引用，但构造器注入需要在实例创建时就提供依赖，此时还没有可暴露的早期引用。

原型模式(prototype)的循环依赖：

缓存机制不适用：三级缓存机制只应用于单例Bean。原型Bean每次获取都会创建新实例，不会被缓存。

生命周期管理差异：单例Bean由容器全程管理，而原型Bean创建后由调用者管理，Spring无法跟踪其完整生命周期。

作用域为request、session等的循环依赖：

生命周期绑定：这些作用域的Bean生命周期与HTTP请求或会话绑定，不是应用级别的单例。

延迟创建特性：这些作用域的Bean通常使用代理模式延迟创建，真正的Bean实例是在请求或会话开始时才创建。

缓存隔离：每个请求/会话有自己的Bean实例，不同请求/会话间的Bean无法共享，三级缓存在这种情况下无法正常工作。

四、三级缓存详解

Spring的三级缓存定义在DefaultSingletonBeanRegistry类中：

java 复制代码

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

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

/** 三级缓存：单例工厂对象，用于创建Bean并进行AOP处理 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

各级缓存的作用

一级缓存(singletonObjects)
- 存放完全初始化好的Bean
- Bean已经完成属性注入和初始化方法(如initMethod)的调用
- 可以直接使用
二级缓存(earlySingletonObjects)
- 存放原始Bean对象，尚未完成属性注入和初始化
- 用于解决循环依赖场景下的对象引用问题
三级缓存(singletonFactories)
- 存放Bean的工厂对象
- 主要作用是处理AOP代理对象的创建
- 如果没有AOP，三级缓存可以被二级缓存替代

五、循环依赖解决流程

以A、B两个Bean循环依赖为例，Spring解决流程如下：

创建A的过程：
- 实例化A对象(此时尚未属性注入)
- 将A的创建工厂放入三级缓存
- 进行属性注入，发现依赖B
创建B的过程：
- 实例化B对象
- 将B的创建工厂放入三级缓存
- 进行属性注入，发现依赖A
- 尝试从一级缓存获取A，失败
- 尝试从二级缓存获取A，失败
- 从三级缓存获取A的工厂，并使用工厂创建A的早期引用
- 将A的早期引用从三级缓存升级到二级缓存
- B完成属性注入(注入A的早期引用)
- B完成初始化，放入一级缓存
完成A的创建：
- 继续A的属性注入(注入已创建完成的B)
- A完成初始化，放入一级缓存

六、源码解析

获取Bean的主要流程

Spring在AbstractBeanFactory.doGetBean()方法中获取Bean：

java 复制代码

protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
    // 尝试从缓存获取
    Object sharedInstance = getSingleton(beanName);
    // 如果缓存中没有，则创建Bean
    if (sharedInstance == null) {
        // 创建Bean的过程
        sharedInstance = getSingleton(beanName, () -> {
            try {
                return createBean(beanName, mbd, args);
            } catch (BeansException ex) {
                // ...
            }
        });
    }
    // ...
}

三级缓存的核心实现

DefaultSingletonBeanRegistry.getSingleton()方法展示了三级缓存的使用：

java 复制代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 一级缓存查找
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 如果一级缓存没有，且当前Bean正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 二级缓存查找
        singletonObject = this.earlySingletonObjects.get(beanName);
        
        // 如果二级缓存没有，且允许早期引用
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 三级缓存查找
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 使用工厂创建对象
                    singletonObject = singletonFactory.getObject();
                    // 放入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级缓存移除
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    
    return singletonObject;
}

添加到三级缓存的关键代码

在AbstractAutowireCapableBeanFactory.doCreateBean()方法中:

java 复制代码

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 实例化Bean
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    final Object bean = instanceWrapper.getWrappedInstance();
    
    // 是否需要提前暴露（解决循环依赖）
    boolean earlySingletonExposure = (mbd.isSingleton() 
            && this.allowCircularReferences 
            && isSingletonCurrentlyInCreation(beanName));
    
    if (earlySingletonExposure) {
        // 添加到三级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    
    // 属性注入和初始化
    populateBean(beanName, mbd, instanceWrapper);
    Object exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    // ...
}

七、为什么需要三级缓存？

很多人疑惑：如果只是解决循环依赖，为什么需要三级缓存？二级缓存不够吗？

答案与Spring的AOP机制有关：

没有AOP时：二级缓存足够解决循环依赖
- 一级缓存存完整Bean
- 二级缓存存早期Bean
有AOP时：需要三级缓存
- Spring不确定哪些Bean需要代理，只能在Bean生命周期后期才能确定
- 三级缓存中的ObjectFactory提供了一个延迟处理的机制
- 当出现循环依赖时，通过ObjectFactory.getObject()提前进行AOP代理
- 确保注入的始终是符合预期的对象（原始对象或代理对象）

示例分析

假设有两个类：

java 复制代码

@Component
public class A {
    @Autowired
    private B b;
    
    public void methodA() {
        System.out.println("Method A");
    }
}

@Component
public class B {
    @Autowired
    private A a;
    
    public void methodB() {
        System.out.println("Method B");
    }
}

循环依赖解决过程：

Spring扫描注册Bean定义
实例化Bean A
A实例放入三级缓存
给A注入属性B，发现B未创建
转而实例化B
B实例放入三级缓存
给B注入属性A，从三级缓存获取A，升级到二级缓存
B完成初始化，放入一级缓存
继续A的注入和初始化，放入一级缓存
循环依赖解决

八、总结

Spring的三级缓存机制是一个精巧的设计，它不仅解决了循环依赖问题，还保证了AOP代理对象的正确创建与注入。三级缓存各司其职：

一级缓存：存储完全初始化的Bean
二级缓存：存储早期暴露的Bean
三级缓存：处理AOP代理对象的创建

通过这种机制，Spring成功解决了单例Bean的循环依赖问题，为构建复杂应用提供了支持。

需要注意的是，Spring并不能解决所有循环依赖场景，如构造器注入的循环依赖和prototype作用域的循环依赖，这些情况下仍需要开发者通过调整设计来避免循环依赖。