【Spring】IOC&DI：循环依赖问题及解决方案

悠悠 2022-11-14 00:58 158阅读 0赞

## 1.什么是循环依赖? ##

所谓的循环依赖就是A依赖B，B依赖A；或者是A依赖B，B依赖C，C依赖A

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

下面来看个实例：

public class InstanceA {
         
        private InstanceB instanceB; 
        // setter...
    } 
    public class InstanceB {
          
        private InstanceA instanceA; 
        // setter...
    }

这里有两个类 A 和 B，A 中有一个成员变量 B，B 中有一个成员变量 A；然后我们在 xml 中通过构造这两个 bean，并通过 setter 来进行依赖注入：

可能存在的问题：

IOC容器在创建Bean的时候，按照顺序，先去实例化instanceA。然后突然发现我的instanceA是依赖我的instanceB的。那么IOC容器接着去实例化intanceB，那么在intanceB的时候发现依赖instanceA。若容器不处理的， 那么IOC将无限的执行上述流程。直到内存异常程序奔溃

解决思路：

当然，Spring 是不会让这种情况发生的。在容器发现 beanB 依赖于 beanA 时，容器会获取 beanA 对象的一个早期的引用（early reference），并把这个早期引用注入到 beanB 中，让 beanB 先完成实例化。beanB 完成实例化，beanA 就可以获取到 beanB 的引用，beanA 随之完成实例化。

这里解释一下上面说的早期引用，实际就是说在 bean 完成初始化之前被引用

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]

> 注：循环依赖在实际应用中也有，但不会太多，简单的应用场景是： controller注入service，service注入mapper，只有复杂的业务，可能service互相引用，有可能出现循环依赖

那循环依赖该怎么解决呢？

## 2.循环依赖解决方案 ##

Spring 在启动过程中，使用到了三个 map，称为三级缓存

// 一级缓存：用于存放 beanName 和初始化好的 bean 对象(属性已经初始化好的)  
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256); 
    
     // 二级缓存：用于存放 beanName 和一个原始 bean 早期 bean(属性未初始化)  
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); 
     
    // 三级缓存：存放 bean 工厂对象，用于解决 AOP 需要代理对象的循环依赖问题
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

一级缓存就不用说了，缓存单例 bean 的。我们下面就来看看二级和三级缓存是如何解决循环依赖的？

首先，我们要清楚的是，在调用 getBean() 后的执行逻辑是

1.  创建 bean 实例 createBeanInstance()
2.  对 bean 进行依赖注入 populateBean()（循环依赖就出现在这里）
3.  对 bean 进行初始化 initializeBean()

### 2.1 二级缓存 ###

所以，我们解决循环依赖的思路可以是，除了单例池（一级缓存）之外，再创建一个半成品池（**二级缓存**，earlySingletonObjects），即对象一创建就添加到半成品池

1.  对象 A 创建之后直接就放入半成品池
2.  对象 B 创建后，直接从半成品池中拿出 A 对象，然后注入到 B 中
3.  将注入后的 B 放入单例池
4.  将单例池中的 B 注入到对象 A 中
5.  将 A 添加到单例池，并移除半成品池中的 A

但是，问题来了如果 A 使用了 AOP，那么 B 要注入的对象就是 A 的代理对象，而不是 A 本身；所以，单例池以及半成品池，应该存放的是 bean 的代理对象，而不是 bean 本身；那该怎么办呢？

### 2.2 三级缓存 ###

首先，我们来看看代理对象的创建的时机。

代理对象在 AbstractAutowireCapableBeanFactory\#doCreateBean() 方法中创建的，具体调用逻辑是 initializeBean() -> BeanPostProcessor\#postProcessAfterInitialization() -> createProxy()。

那么问题来了，入口 initializeBean() 都在依赖注入 populateBean() 之后了，那依赖注入时就根本拿不到代理对象啊…

所以，为了解决循环以依赖的问题，在 doCreateBean() 方法中，createBeanInstance() 之后，populateBean() 之前添加了一个工厂池（**三级缓存**，singletonFactories），这个工厂池里面缓存了许多 bean 的 FactoryBean，这些工厂不仅可以暴露早期 bean 还可以暴露代理 bean

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 2]

1.  对象 A 创建
2.  **由于 B 要提前引用 A**，所以通过工厂池中 A 的 FactoryBean\#getObject 创建 A 的代理对象，并将该代理对象放入半成品池
3.  B 从半成品池中获取到 A 的代理对象，并完成依赖注入
4.  将注入后的 B 放入单例池
5.  将单例池中的 B 注入到对象 A 中
6.  将半成品池中 A 的代理对象移到单例池中
7.  将工厂池中的 A 移除

> 注：此时对于 A 来说，就没要再进行 BeanPostProcessor 后置处理了，因为已经提前创建过代理对象了

可能有同学要问了，既然三级缓存也能够获取到早期 bean，那就已经能解决循环依赖了，为什么还需要一个二级缓存？

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
       // 检查缓存中是否有初始化好的bean 
       Object singletonObject = this.singletonObjects.get(beanName);
       // 判断 beanName 对应的 bean 是否正在创建中 
       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
           // 加锁，防止多线程并发创建 
          synchronized (this.singletonObjects) {
        
             // 从 earlySingletonObjects 中获取提前曝光的 bean 
             singletonObject = this.earlySingletonObjects.get(beanName);
             // 没拿到
             if (singletonObject == null && allowEarlyReference) {
        
                // 获取相应的 bean 工厂 
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
        
                   // 提前曝光 bean 实例（raw bean）也是早期bean ，用于解决循环依赖 
                   singletonObject = singletonFactory.getObject();
                   // 将 singletonObject 放入缓存中，并将 singletonFactory 从缓存中移除 
                   this.earlySingletonObjects.put(beanName, singletonObject);
                   this.singletonFactories.remove(beanName);
                }
             }
          }
       }
       return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

可以从源码中看到，只有当二级缓存 earlySingletonObjects 获取不到提前曝光的 bean 时（主要出现于获取代理对象），才会走到三级缓存 singletonFactories 执行工厂的 getObject() 生成(获取)早期依赖，生成后就将早期对象放入二级缓存，并且删除当前 FactoryBean。

所以，二级缓存 earlySingletonObjects 更注重的是存储，而三级缓存 singletonFactories 更注重的是生产。

> 再放一个很好的视频参考链接（B站）：[https://www.bilibili.com/video/BV1ET4y1N7Sp?p=1][https_www.bilibili.com_video_BV1ET4y1N7Sp_p_1]…

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/32e902253ac346819d5ab7277f65c84d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/9cb74068a97f4934b361059bf7255d41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/3acc0c1dd1fb475aa6189f2133ca05d3.png
[https_www.bilibili.com_video_BV1ET4y1N7Sp_p_1]: https://www.bilibili.com/video/BV1ET4y1N7Sp?p=1