什么是循环依赖？

什么是循环依赖？

循环依赖（Circular Dependency），也称为循环引用，是指两个或多个Bean之间相互依赖，形成一个环状依赖链。例如，Bean A依赖于Bean B，而Bean B又依赖于Bean A，这就形成了一个简单的循环依赖。

在Spring框架中，循环依赖问题主要发生在单例（Singleton）Bean的创建过程中。Spring使用依赖注入（DI）来管理Bean的生命周期，当两个或多个Bean相互依赖时，可能会导致循环依赖问题。具体表现为：在创建Bean A时，需要先创建Bean B，但创建Bean B时又需要先创建Bean A，从而导致无限循环，最终引发BeanCurrentlyInCreationException异常。

Spring如何处理循环依赖？

Spring通过三级缓存机制来解决大多数单例Bean的循环依赖问题。三级缓存分别为：

1. 一级缓存（singletonObjects）：用于存放完全初始化好的单例Bean。
2. 二级缓存（earlySingletonObjects）：用于存放原始的、未完全初始化的单例Bean，解决某些依赖注入的提前曝光问题。
3. 三级缓存（singletonFactories）：用于存放创建Bean的工厂对象，主要用于解决Bean的代理问题。

三级缓存机制的工作原理

1. 创建Bean实例：当Spring容器创建一个Bean实例时，首先会在三级缓存中记录该Bean的创建工厂。
2. 提前曝光原始Bean：如果在创建过程中遇到循环依赖，Spring会从三级缓存中取出相应的创建工厂，并提前曝光该Bean的原始实例，放入二级缓存。
3. 依赖注入：继续完成当前Bean的依赖注入过程，此时可以通过二级缓存获取到提前曝光的原始Bean，解决循环依赖问题。
4. 完成初始化：当Bean的依赖注入和初始化过程完成后，Bean实例会从二级缓存移到一级缓存，最终完成Bean的创建。

示例

以下是一个简单的示例，说明Spring如何处理循环依赖：

@Component
public class A {
    @Autowired
    private B b;
}

@Component
public class B {
    @Autowired
    private A a;
}

在这个示例中，A和B互相依赖。Spring在处理时会：

1. 创建A的实例，并将其工厂放入三级缓存。
2. 创建B的实例时，发现需要A，于是从三级缓存中获取A的工厂，并将A的原始实例放入二级缓存。
3. 完成B的创建，并将B放入一级缓存。
4. 继续完成A的创建，并将A放入一级缓存。

三级缓存与Bean生命周期的联系

1. 实例化阶段

当Spring容器创建一个Bean的实例时，它首先会通过反射机制调用Bean的构造方法进行实例化。在这个阶段，Bean对象还没有被完全初始化，也没有注入其依赖的属性。

2. 暴露早期Bean引用（三级缓存）

为了处理循环依赖，Spring容器会在实例化Bean之后，初始化之前，将这个早期的Bean引用放入三级缓存中。三级缓存使用ObjectFactory延迟创建和暴露Bean的早期引用，这样当其他Bean需要引用这个Bean时，可以从三级缓存中获取到早期引用。

具体过程如下：

1. 实例化Bean对象：首先，Spring通过构造器或无参构造方法实例化Bean对象。
2. 放入三级缓存：将实例化但尚未完全初始化的Bean对象包装成ObjectFactory，并放入三级缓存singletonFactories中。

3. 属性注入阶段

在属性注入阶段，Spring容器会尝试为Bean注入其依赖的属性。如果在注入过程中遇到循环依赖，Spring容器会按照以下步骤操作：

1. 尝试从一级缓存获取：首先，Spring容器会尝试从一级缓存singletonObjects中获取依赖的Bean。
2. 尝试从二级缓存获取：如果一级缓存中没有，Spring容器会尝试从二级缓存earlySingletonObjects中获取依赖的Bean。
3. 尝试从三级缓存获取：如果二级缓存中也没有，Spring容器会尝试从三级缓存singletonFactories中获取ObjectFactory，然后调用ObjectFactory.getObject()方法获取早期暴露的Bean引用，并将其放入二级缓存中。

通过这种机制，Spring容器可以在属性注入阶段解决循环依赖问题。

4. 初始化阶段

在属性注入完成后，Spring容器会调用Bean的初始化方法（如果有），例如实现InitializingBean接口的afterPropertiesSet方法或自定义的init-method方法。

5. 完全初始化

完成初始化后，Spring容器会将完全初始化的Bean对象从二级缓存转移到一级缓存singletonObjects中。此时，Bean对象已经完全准备好，可以被容器管理和使用。

6. 销毁阶段

当Spring容器关闭时，会调用Bean的销毁方法（如果有），例如实现DisposableBean接口的destroy方法或自定义的destroy-method方法。这与三级缓存机制没有直接关系，但也是Bean生命周期的一部分。

什么时候循环依赖无法解决？

虽然Spring可以通过三级缓存机制解决大多数循环依赖问题，但以下情况可能会导致循环依赖无法解决：

1. Prototype作用域的Bean：Spring不支持Prototype作用域的Bean循环依赖，因为Prototype Bean不会被缓存。
2. 构造器注入：如果两个Bean通过构造器相互依赖，Spring无法解决这种循环依赖，因为在构造器完成之前，Bean实例还未创建，无法提前曝光。

源码分析

三级缓存的实现主要在 DefaultSingletonBeanRegistry 类中。以下是三级缓存的主要内容：

1. 一级缓存（单例池）：保存完全初始化好的单例 Bean 实例。

   private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
   

2. 二级缓存（早期单例曝光缓存）：保存实例化但尚未初始化完成的单例 Bean 实例，主要用于解决循环依赖。

   private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
   

3. 三级缓存（单例工厂缓存）：保存创建单例 Bean 实例的工厂。通过工厂方法，可以在需要时创建 Bean 实例，这也是三级缓存的核心。

   private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
   

以下是 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);

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

    // 注册单例对象
    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 实例，并将其存储在三级缓存 singletonFactories 中。
• 属性注入阶段：从三级缓存获取 Bean 实例，并完成属性注入。
• 初始化阶段：完成初始化方法的调用后，将 Bean 实例从三级缓存移到一级缓存 singletonObjects 中。

参考链接

• Spring Framework Documentation
• Circular Dependencies in Spring