循环依赖介绍及场景

什么是循环依赖？

很简单，就是A对象依赖了B，B对象依赖了A
比如：

class Job{
	public Work work;
}

class Work{
	public Job job;
}

那么循环依赖是个问题吗？

如果不考虑Spring，循环依赖并不是问题，因为对象之间相互调用时很正常的事情（因为不管是编译还是运行都是正常的）。

Job job = new Job();
Work work = new Work();

job.work = work;
work.job = job;

这样Job和Work类就依赖上了。

但是，在Spring中循环依赖就是个问题，为什么？
因为在Spring中，一个对象并不是简单new出来的，而是会进过一系列的Bean的生命周期，就是因为Bean的生命周期，所以才出了循环依赖的问题。当然，出现循环依赖的场景很多，有的场景Spring自动帮我们解决了，而有的场景则是需要程序员手动去解决的。

那么我们需要先来了解Spring中Bean的生命周期

Bean的生命周期

Bean的生命周期指的就是：在Spring中，Bean是如何生成的？

为什么Spring要有三级缓存来解决循环依赖？？下面的实例可以帮助了解。

比如有以下两个service实例：

@Component("aService")
public class AService(){
	@Autowired
	private BService bService;
	
	public void xxx(){}
}

@Component("bService")
public class BService(){
	@Autowired
	private AService aService;
	
	public void xxx(){}
}

Spring中的Bean是怎么生成的呢？下面简单介绍下过程

aService Bean的简单生命周期步骤：
（1）实例化…AService对象（相当于new AService）
Spring生成一个Bean,也就是Java对象。
不管Spring多么强大，生成一个Bean，不管怎么样都需要先生成一个对象。
对于aService这个类来说，实例化的目的就是为了得到一个AService的对象

（2）填充bService属性（也就是注入）
由于实例化只是new出的一个对象，调用的是无参的构造方法，这个时候里面属性bService还是空的。
对于Spring来说，紧接着就会给aService中的属性去赋值

（3）填充其他属性（也就是注入）

（4）做其他事情（后面更新介绍）

（5）放入单例池
对于AService 来说，它是单例的，对于单例来说，在Spring中需要把单例对象放入单例池。一个bean对象只有放到单例池中，才能保证单例。

小扩展：
单例Bean和单例模式是一样的吗？
比如AService是一个单例Bean，那么是不是表示在整个Spring容器里面是不是只有一个实例？ 可以有多个，因为当前通过@Component注解，定义了一个AService的Bean，但是也可以在其他类型里面通过@Bean注解来定义很多，只要保证Bean的名字不重复即可。这个和我们所理解的单例模式并不是等价的。
其实单例池（singletonObjects）本质上就是一个ConcurrentHashMap：<beanName,bean对象>（map的key是bean的名字，value是bean对象）
Spring中的单例实际上指的是：通过以下方式获取到的Bean是同一个对象（传入的名字相同，但是为同一个单例Bean）

AnnotationConfigApplicationContext annotationConfigApplicationContext =
				new AnnotationConfigApplicationContext(Appconfig.class); 
AService aService1 = applicationontext.getBean("aService",AService.calss);
AService aService2 = applicationontext.getBean("aService",AService.calss);
AService aService3 = applicationontext.getBean("aService",AService.calss);

那Spring是如何达到这种效果的？这个就是和上面的map保持一致的。

循环依赖的场景

这里着重看下上述生命周期的第二个步骤：填充bService属性。
关键问题是：怎么填充？

@Component("aService")
public class AService(){
	@Autowired
	private BService bService;
	
	public void xxx(){}
}

说白了，现在需要给aService中的bService赋值，要赋什么值呢？肯定是BService类型的对象。
Spring给这个属性赋值，从哪里去找BService的对象呢？
会先从单例池中找BService对应的Bean对象，若这个时候，没有找到，那么Spring就会去创建BService。
相当于要把AService的生命周期再走一遍，两次嵌套一起，简化如下：

1. 实例化…AService对象（new AService()）
2. 填充bService属性—>从单例池中找bService—>找不到—>创建bService
   bService的生命周期
   2.1 实例化…BService对象（new BService()）
   2.2 填充aService属性—>从单例池中找aService—>找不到—>创建aService
   aService的生命周期
   3.1 实例化…AService对象（new AService()）
   …
   …
   …
   2.3 填充他属性
   2.4 做其他事情
   2.5 放入单例池
3. 填充他属性
4. 做其他事情
5. 放入单例池

这个就是我们所说的Spring循环依赖
从上述分析得到，之所以产生依赖主要是：A创建时—>需要B—>B去创建—>需要A，从而产生了循环

更多可点击Spring循环依赖过程解析查看