吐血给女朋友讲解spring循环依赖

妖狐艹你老母 2022-08-28 01:51 146阅读 0赞

**前言**

我们前面说了几遍Spring的文章，了解了比较核心的知识点**IOC和AOP**，还有就是**事务传播**这种，不知道大家听过Spring的循环依赖这个问题吗，而且这个问题是面试经常问的，属于Spring的一个比较重要的话题，也比较典型，比较考验一个人对Spring的研究程度，也算是Spring的一个高阶问题之一了

有的小伙伴内心对于Spring的看法可能是，感觉自己懂了，但是让自己来叙述给一个小白的话，可能部分人就讲不出来了，这一篇呢，主要就是帮你解决这个痛点，让你彻底搞定Spring的循环依赖，也让你下次不再担心，而是张口就来

我当年面试的时候，也是遇到不少面试官问过这个问题，每次都是绝杀面试官

![7bb6791917d9525b5cc2426edb8d2966.png][]

循环依赖问题，本文会通过三个方面来简单介绍

**1、什么是Spring的循环依赖**

**2、多种情况下的循环依赖**

**3、Spring如何解决循环依赖**

**了解Spring循环依赖**

什么是循环依赖

![9a4a64bab7888a9e9f8877b06563fdfc.png][]

@Component
    public class AService {
        // AService中注入了BService
     @Autowired
     private BService bService;
    }
    
    
    @Component
    public class BService {
        // BService中也注入了AService
     @Autowired
     private AService aService;
    }

这是属于比较常见的一种循环依赖，还有就是更多的之间的相互依赖，比如A依赖B，B依赖C，C依赖A，类似于三角恋...

当然也有特殊的，**自己的依赖自己**

// 自己依赖自己
    @Component
    public class AService {
        // A中注入了A
     @Autowired
     private AService aService;
    }

关于上面service的Spring bean的创建，其实本质上也会一个对象的创建，既然是对象，就要明白一个对象需要完成的对象包含两个部分：当前对象的实例化和对象属性的实例化

我们如果用一个常人的思维去考虑，这肯定是做不到的啊，A需要B，B需要A，这不成死循环了，和死锁一个道理了，这就很尴尬了，该怎么解决呢，接着看下去

###  ###

**多种情况下的循环依赖**

Spring的循环依赖也是可能出现多种情况的，比如构造器注入，setter注入等等，那什么情况下Spring可以解决循环依赖，什么情况下又不能解决呢

Spring解决循环依赖的前提条件就是：

**1、出现循环依赖的bean必须是单例的**

**2、依赖注入的方式不能全是构造器注入**

注意不能全是这几个字眼，这里需要强调一点的是，大家可能会看到很多关于Spring解决循环依赖的博客，其中只能解决setter注入的方式这种说法是错误的，只要不全是构造器注入Spring就可以解决

Spring bean的创建，其实本质上也会一个对象的创建，既然是对象，就要明白一个对象需要完成的对象包含两个部分：**当前对象的实例化和对象属性的实例化**，在Spring中，对象的实例化是通过反射实现的，而对象的属性则是在对象实例化之后通过一定的方法设置的，知道了这一点，可以更好的帮助大家去理解

上面说的第一点必须是单例的其实很好理解，你想啊，如果是多个实例，该引入哪个实例就不知道了，Spring框架就蒙圈了，大胆猜测一下，Spring以后可能会尝试解决这个问题，大概率是通过配置的方式来告诉该注入哪个

但是第二点呢，不能全是构造器注入呢，先看代码

@Component
    public class AService {
    // @Autowired
    // private BService bService;
     public AService(BService bService) {
    
    
     }
    }
    
    
    
    
    @Component
    public class BService {
    
    
    // @Autowired
    // private AService aService;
    
    
     public BService(AService aService){
    
    
     }
    }

上面这个例子大家看得懂吧，别告诉我你看不懂，AService中的BService注入是通过构造器，反之也是通过构造器注入，这个时候Spring是无法解决循环依赖问题的，如果项目中出现两个这样的引用，在启动的时候就会直接抛出异常

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

###  ###

**解决循环依赖**

首先呢，Spring解决循环依赖依靠的就是**内部维护的三个Map**，也就是咱们常说的三级缓存，不知道大家听过没有

![4954899aac6f0b1569eab797f934bb3d.png][]

之所以被叫做三级缓存，大概是因为注释上都是用Cache，而起的作用也类似一个缓存的作用

**1、singletonObjects：这个是单例的容器池，缓存创建完成单例Bean的地方**

**2、singletonFactories：用来映射创建Bean的原始工厂**

**3、earlySingletonObjects：用来映射Bean的早起引用的，也就是说在这个Map中的Bean不是完整的，属于半成品，甚至还不能被称为Bean，只是一个Instance**

后面的两个Map其实属于是过程中的消耗品，什么意思呢，就是创建Bean的时候，需要暂时存储在这里，过后完成之后就清除掉了

我们先来看一下这个创建过程，我把这个大致分了四个步骤，看着也比较清晰，大家也比较好理解：

**1、A找B找不到：**

创建AService的过程中发现需要BService，于是AService将去寻找BService，发现找不到，寻找的路径是一级缓存、二级缓存、三级缓存，于是AService把自己放到了三级缓存中

**2、B找A找到了：**

实例化BService，实例化过程中发现需要AService，于是也是按照上述路径去寻找，在三级缓存中找到了AService

**3、B创建完成：**

然后就把三级缓存中的AService拿出来，放到了二级缓存中，并删除三级缓存中的AService，此时BService可以成功引用，顺利初始化完毕，把自己放到了一级缓存中了（而此时BService中的AService依然是创建中的状态

**4、A创建完成：**

继续完善AService，此时再去寻找BService，拿出来直接引用就好了，把自己放入到一级缓存中，删除二级缓存，删除在创建的状态信息

**问题的本质和two sum的本质有些类似，这个是leetcode上序号为1 的题目，问题的内容是：**

给定nums = \[2,7,11,15\] , target = 9，那么要返回\[0,1\] ，因为2 + 7 = 9

这道题的解题思路就是通过Map，先去Map中找到需要的数字，没有就把当前数字放进去，有的话就直接拿到并一起返回

和三级缓存的本质类似，先去缓存中找到需要的Bean，找到了万事大吉，直接创建完成返回，找不到就把自己放进去

**来一起简单的分析一波源码，不看太多，不用发愁**

**![f78f06b037c8e7e5ee6db70eed52ce4c.png][]**

单例模式下，第一次获取Bean时由于Bean示例还未实例化，因此会先创建Bean然后放入缓存中，以后再次调用获取Bean方法将直接从缓存中获取，不再重新创建。

缓存添加过程主要发生在创建Bean也就是**doCreateBean()**过程中。

![b8227227cb2c68860e8cc9b10a2e1f0d.png][]

从代码中可以看到在这里将beanName放入**三级缓存**中，并且从二级缓存中移除。这里的addSingletonFactory发生在createBeanInstance之后，此时已经有了实例对象，但是还没创建完成便放入三级缓存当中。

在doCreateBean()方法执行完成之后，Bean实例创建完成，因此在第二个getSingleton()中的finally块中如果是新的单例对象则会调用addSingleton()方法

![5998012a6f428a79808614eeab5686f8.png][]

可以看到此时将加入一级缓存中，并且从二级、三级缓存中移除。

缓存的获取是通过getSingleton(String beanName)方法获取的，其源码如下：

![56e502c0841ed626d4b8e10b3aebce9a.png][]

在代码中，首先从一级缓存singletonObjects中获取Bean；如果获取不到并且获取的Bean被标记为正在创建中，则从二级缓存earlySingletonObjects中获取

如果二级缓存中依然获取不到Bean，并且允许从三级换从中获取Bean，则从三级缓存中获取Bean，此时如果获取到了Bean，则将该Bean从三级缓存中移除，然后添加进二级缓存（缓存升级），否则返回null。

> **最后问一个灵魂的问题，为什么不用二级缓存，而用三级缓存呢？**

如果创建的Bean有对应的代理，那其他对象注入时，注入的应该是对应的代理对象；但是Spring无法提前知道这个对象是不是有循环依赖的情况，而正常情况下（没有循环依赖情况），Spring都是在创建好完成品Bean之后才创建对应的代理。这时候Spring有两个选择：

不管有没有循环依赖，都提前创建好代理对象，并将代理对象放入缓存，出现循环依赖时，其他对象直接就可以取到代理对象并注入。

不提前创建好代理对象，在出现循环依赖被其他对象注入时，才实时生成代理对象。这样在没有循环依赖的情况下，Bean就可以按着Spring设计原则的步骤来创建。

**Spring选择了第二种方式，那怎么做到提前曝光对象而又不生成代理呢？**

Spring就是在对象外面包一层ObjectFactory，提前曝光的是ObjectFactory对象，在被注入时才在ObjectFactory.getObject方式内实时生成代理对象，并将生成好的代理对象放入到第二级缓存Map<String, Object> earlySingletonObjects。

有道无术，术可成；有术无道，止于术

欢迎大家关注**Java之道**公众号

![2c32525196084334b394f475d150fbb3.png][]

好文章，我在看❤️

[7bb6791917d9525b5cc2426edb8d2966.png]: /images/20220828/2898dd11d45e4d0f9a82c8b1d0983457.png
[9a4a64bab7888a9e9f8877b06563fdfc.png]: /images/20220828/bedd28ef5a374057983ae9c9a323d885.png
[4954899aac6f0b1569eab797f934bb3d.png]: /images/20220828/8707119367994bb690e024f39a72067b.png
[f78f06b037c8e7e5ee6db70eed52ce4c.png]: /images/20220828/21b3aa83997841e0b235ba49d037c090.png
[b8227227cb2c68860e8cc9b10a2e1f0d.png]: /images/20220828/7f1bfa38a5db4fdfaf1602119823aa4e.png
[5998012a6f428a79808614eeab5686f8.png]: /images/20220828/45066b50364a4f8e8acbc182d294cb4c.png
[56e502c0841ed626d4b8e10b3aebce9a.png]: /images/20220828/e609df2c0c434b909cd8c33aa8906981.png
[2c32525196084334b394f475d150fbb3.png]: /images/20220828/09ba5ad70dd5400f968f718dc15ee767.png