## Spring循环依赖的解决

### 什么是循环依赖

循环依赖,是依赖关系形成了一个圆环。比如:A对象有一个属性B,那么这时候我们称之为A依赖B,如果这时候B对象里面有一个属性A。那么这时候A和B的依赖关系就形成了一个循环,这就是所谓的循环依赖。如果这时候IOC容器创建A对象的时候,发现B属性,然后创建B对象,发现里面有A属性,然后创建B.....这么无限循环下去。我们先用代码演示一下:

```java
public class A {
private B b=new B();
}

public class B {
private A a=new A();
}

public class Test {
public static void main(String[] args) {
A a = new A();
}
}

```

运行一下结果

![image-20200110220224411](https://img2018.cnblogs.com/blog/668183/202001/668183-20200113210057800-2003961214.png)

那么我们可以看到循环依赖存在的问题了

> 1. 栈内存溢出
> 2. 程序的维护性和扩展性太差

显然这种思路是不正确的。

### 产生循环依赖产生的条件:

> 1. 在容器中创建的对象是单例的
> 2. 对象是循环依赖

### 精简版解决方案

如果我们自己写的话,该如何解决的呢?

```java
public class A {
private B b;
public void setB(B b) {
this.b = b;
}
}
public class B {
private A a;
public void setA(A a) {
this.a = a;
}
}
public class Test {
public static void main(String[] args) {
A a = new A();//创建a对象
B b = new B();//因为a对象依赖B,那么创建B
b.setA(a);//创建B对象的时候,发现依赖A,那么把通过构造方法生成的对象a赋值给B
a.setB(b);//然后把生成的b对象注入到a里面
}
}
```

### Spring解决方案

当使用Spring的 **@Autowired** 注解的时候,其实Spring的实现原理和上面很相似,先通过生成相关的对象,然后再把里面需要依赖的对象设置进去。

我们现在从Spring源码来走一遍。。

我们现贴出最基本的测试代码

```java
@Component
public class A {
@Autowired
B b;
}
@Component
public class B {
@Autowired
A a;
}
public class RecyclerTest {
@Test
public void test() {
ApplicationContext context = new AnnotationConfigApplicationContext("com.kailaisi.demo.recycler");
//getbean得时候才进行IOC容器中的对象的实例化工作
A a = (A) context.getBean("a");
}
}
```

在我们之前发布的[SpringBoot启动流程源码分析](http://www.kailaisii.com//archives/SpringBoot启动流程源码分析)里面,我们提到过bean单例的生成是在Spring容器创建过程中来完成的。经过多层的调用,最终会调用到 **doGetBean** 这个方法里面。

```java
protected T doGetBean(final String name, @Nullable final Class requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
...
Object bean;
//先从缓存中获取是否定义了对应的类,这里的缓存包括了半成品类缓存(只生成了类,但是还没有进行属性注入的类)和成品类缓存(已经完成了属性注入的类)
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
......
//如果符合条件,直接从对饮给的bean单例中获取到对象,然后返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
...
try {
.....
//创建单例bean,解决循环依赖的根本方案
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//调用创建单例的方法
return createBean(beanName, mbd, args);
}
...
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
...
return (T) bean;
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
//进行bean的创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
...
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//bean的包装类
BeanWrapper instanceWrapper = null;
...
if (instanceWrapper == null) {
//创建beanDefinition所对应的的参数的bean实例,这里通过构造方法或者工厂方法或者cglib创建了对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
if (earlySingletonExposure) {
//将对象放到registeredSingletons队列中,并从earlySingletonObjects中移除
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
...
//注入A的依赖,这里面会发现属性,然后从doGetBean()方法开始,生成B对象,然后循环走到这里的时候,在队列里面会同时存在A对象和B对象。然后B对象注入A成功,返回后将生成的B注入到A,此时完成了A和B的对象生成,并解决了循环依赖问题
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
...
}
```

加载过程比较长,其实主要是在加载的过程中将对象的创建过程进行了分类处理,在创建的不同时期,放入到队列来进行区分。

>1. singletonObjects:单例对象列表
>2. singletonFactories:单例工厂队列,对象刚开始创建的时候,会放入到这个队列。
>3. earlySingletonObjects:产生了循环依赖的对象队列,对象在创建之后,进行注入过程中,发现产生了循环依赖,那么会将对象放入到这个队列,并且从singletonFactories中移除掉。
>4. singletonsCurrentlyInCreation:正在创建的对象队列,整个创建过程都存放在这个队列里面,当完成了所有的依赖注入以后,从这个队列里面移除
>5. registeredSingletons:已经创建成功的单例列表。

知道了这几个队列以后,我们可以来整理测试例子中,A和B对象是如何一步步创建,并解决其循环依赖的问题了。

1. 首先,依次从singletonObjects,earlySingletonObjects,singletonFactories队列中去寻找a对象,发现都没有,返回了null。那么这时候就需要创建B对象
2. a的创建的准备:在创建之前,将a放入到singletonsCurrentlyInCreation队列,表明a正在进行创建。
3. 开始创建a:通过反射创建对象a。
4. 进行创建后的处理:创建a对象以后,将a放入到singletonFactories和registeredSingletons队列,并从earlySingletonObjects中移除。然后进行依赖注入工作,发现有依赖B对象。
1. 这时候进入了B对象的注入过程
2. 首先,依次从singletonObjects,earlySingletonObjects,singletonFactories队列中去寻找b对象,发现都没有,返回了null。那么这时候就需要创建B对象
3. b的创建的准备工作:在创建之前,将b放入到singletonsCurrentlyInCreation队列,表明b正在进行创建
4. 开始创建b:通过反射创建对象b。
5. 进行创建后的处理:将b放入到singletonFactories和registeredSingletons队列,并从earlySingletonObjects中移除。然后进行依赖注入工作,发现有依赖 A对象。
1. 这时候进入A的注入过程。。。
2. 从singletonObjects中查找a,发现a不存在但是singletonsCurrentlyInCreation队列中有a,那么这时候说明a是在创建过程中的,此处又需要创建,属于循环依赖了。然后去earlySingletonObjects查找,也没发现。那么这时候去singletonFactories队列中去寻找a对象,找到了。这时候将a对象放入到earlySingletonObjects队列,并从singletonFactories中移除。因为发现了a对象,这里直接返回a,此时完成了b对象对A的依赖注入了
6. b实例化完成,而且依赖也注入完成了,那么进行最后的处理。将b实例从singletonsCurrentlyInCreation队列移除,表明b对象实例化结束。然后将b放入到singletonObjects和registeredSingletons队列,并从singletonFactories和earlySingletonObjects队列移除。最后将b对象注入到a对象中。然后a完成了创建过程。
5. a实例化完成,而且依赖也注入完成了,那么进行最后的处理。将a实例从singletonsCurrentlyInCreation队列移除,表明a对象实例化结束。然后将a放入到singletonObjects和registeredSingletons队列,并从singletonFactories和earlySingletonObjects队列移除。此时完成了a对象的创建。

### 总结

上述就是spring解决循环依赖的整体过程,跟我们之前的那个方法很相似,只是对于各种情况的处理更仔细。而且从这个过程也能理解spring对于对象的创建过程。

> 本文由 [开了肯](http://www.kailaisii.com/) 发布!

Spring循环依赖的解决的更多相关文章

  1. Spring IOC 容器源码分析 - 循环依赖的解决办法

    1. 简介 本文,我们来看一下 Spring 是如何解决循环依赖问题的.在本篇文章中,我会首先向大家介绍一下什么是循环依赖.然后,进入源码分析阶段.为了更好的说明 Spring 解决循环依赖的办法,我 ...

  2. Spring循环依赖原因及如何解决

    浅谈Spring解决循环依赖的三种方式 SpringBoot构造器注入循环依赖及解决 原文:https://www.baeldung.com/circular-dependencies-in-spri ...

  3. Spring循环依赖的三种方式以及解决办法

    一. 什么是循环依赖? 循环依赖其实就是循环引用,也就是两个或者两个以上的bean互相持有对方,最终形成闭环.比如A依赖于B,B依赖于C,C又依赖于A.如下图: 注意,这里不是函数的循环调用,是对象的 ...

  4. Spring 循环依赖的三种方式(三级缓存解决Set循环依赖问题)

    本篇文章解决以下问题: [1] . Spring循环依赖指的是什么? [2] . Spring能解决哪种情况的循环依赖?不能解决哪种情况? [3] . Spring能解决的循环依赖原理(三级缓存) 一 ...

  5. Spring循环依赖解决方式源码解析

    1. 什么是循环依赖? 循环依赖其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环.比如A依赖于B,B依赖于A我们直接上代码 先创建一个类ServiceA依赖于Service ...

  6. spring循环依赖的产生与解决

    1.循环依赖的产生 在spring中对象默认都是单例的 ,意味整个容器中只有一个该类的对象. 如图,B类有一个属性a,A类有一个属性b.当B类创建对象时,要给a属性赋值:当A类创建对象时,要给b属性赋 ...

  7. 解析spring循环依赖策略

    循环依赖 所谓循环依赖就是多个Bean之间依赖关系形成一个闭环,例如A->B->C->...->A 这种情况,当然,最简单的循环依赖就是2个Bean之间互相依赖:A->B ...

  8. Spring循环依赖问题

    什么是循环依赖? 循环依赖就是循环引用,指两个或多个bean互相持有对方,比如说TestA引用TestB.TestB引用TestA,最终形成一个闭环. 注意:循环依赖不是指循环调用. 循环调用:指方法 ...

  9. Spring循环依赖

    Spring-bean的循环依赖以及解决方式 Spring里面Bean的生命周期和循环依赖问题 什么是循环依赖? 循环依赖其实就是循环引用,也就是两个或者两个以上的bean互相持有对方,最终形成闭环. ...

随机推荐

  1. python中使用指定GPU

    import os os.environ["CUDA_VISIBLE_DEVICES"] = "2" # 或 os.environ["CUDA_VIS ...

  2. 洛谷P2146 [NOI2015]软件包管理器 题解 树链剖分+线段树

    题目链接:https://www.luogu.org/problem/P2146 本题涉及算法: 树链剖分: 线段树(区间更新及求和,涉及懒惰标记) 然后对于每次 install x ,需要将 x 到 ...

  3. H3C 帧中继子接口

  4. Group_concat介绍与例子

    进公司做的第一个项目就是做一个订单追踪查询,里里外外连接了十一个表,作为公司菜鸡的我麻了爪. 其中有一个需求就是对于多行的数据在一行显示,原谅我才疏学浅 无奈下找到了项目组长  在那学来了这个利器 ( ...

  5. 微软的可疑更新DhMachineSvc.exe

    最近微软大范围的推出了一个只针对中国的更新,包含了DhMachineSvc.exe,也就是所谓的'微软设备健康助手服务'. 这个更新很神秘,首先这个更新只针对中国区,其次这个更新支持WinXP,第三这 ...

  6. Acegi框架介绍

    开发四年只会写业务代码,分布式高并发都不会还做程序员?->>>        概述     对于任何一个完整的应用系 统,完善的认证和授权机制是必不可少的.Acegi Securit ...

  7. linux模块加载竞争

    到目前, 我们的讨论已来到一个模块加载的重要方面: 竞争情况. 如果你在如何编写你的 初始化函数上不小心, 你可能造成威胁到整个系统的稳定的情形. 我们将在本书稍后讨论 竞争情况; 现在, 快速提几点 ...

  8. 11-28-----vertor和list使用场景

    1.vector拥有一段连续的内存空间,因此支持随机访问,如果需要高效的随机访问,而不子啊胡插入和删除的效率,使用vector, 2.list拥有一段不连续的内存空间,如果需要高效的插入和删除,而不关 ...

  9. tensorflow在文本处理中的使用——Word2Vec预测

    代码来源于:tensorflow机器学习实战指南(曾益强 译,2017年9月)——第七章:自然语言处理 代码地址:https://github.com/nfmcclure/tensorflow-coo ...

  10. ASP.NET MVC 实现页落网资源分享网站+充值管理+后台管理(4)之业务仓储工厂

    在创建业务层之前,我们先来熟悉一下业务仓储工厂Bobo.Repository.dll程序集,后续的业务操作,我们都将通过这个程序集中的方法传递数据库操作,其介于数据库操作与业务层之间,详情可前往< ...