Spring为什么要用三级缓存解决循环依赖呢_Java

1.什么是循环依赖

本文为了方便说明，先设置两个业务层对象，命名为aservice和bservice。其中spring是如何把一个bean对象创建出来的，其生命周期如下：

构造方法–> 不同对象 --> 注入依赖 -->初始化前 --> 初始化后–>放入单例池map（一级缓存）—>bean对象

map的数据结构为，key表示单例的名称，而value是一个对象。其中单例池就是所谓的一级缓存。

循环依赖，如aservice中依赖了一个bservice，bservice也依赖了aservice，aservice和bservice相互依赖。这里换出现一个问题，但是spring使用三级缓存给解决了。
首先我们要看的是为什么出现循环？
首先在aservice中引入了@componet注解，那aservice的生命周期会交给spring管理。aservice生命周期如下，本文把该例子定义为示例1。

aservice生命周期
1.实例化 --->aservice的普通对象
2.填充bservice（添加了autowired）-->从单例池中获取bservice(此时单例池中可能还没存放bservice的bean)-->创建bservice
  当单例池中可能还没存放bservice的bean时，触发创建bservice生命周期，步骤和aservice一致。如下所示：
  2.1.实例化--->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池（此时aaservice也在创建中，还没放入单例池，如果创建的话，就会出现循环依赖）
  2.3.填充其他属性
  2.4.其他步骤（包括aop）
  2.5.加入到单例池中
3.填充其他属性
4.其他步骤（包括aop）
5.加入到单例池中

简单解决示例1中的问题

主要是定义个map存放第一步生成的普通对象。map的名称暂且为bozimap<beanname,普通对象>，示例2如下所示：

aservice生命周期
1.实例化 --->aservice的普通对象---->存入bozimap<beanname,aservice的普通对象>
2.填充bservice（添加了autowired）-->从单例池中获取bservice(此时单例池中可能还没存放bservice的bean)-->创建bservice
  当单例池中可能还没存放bservice的bean时，触发创建bservice生命周期，步骤和aservice一致。如下所示：
  2.1.实例化--->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池（此时aaservice也在创建中，还没放入单例池，如果创建的话，就会出现循环依赖）--->bozimap中取aservice对象。
  2.3.填充其他属性
  2.4.其他步骤（包括aop）
  2.5.加入到单例池中
3.填充其他属性
4.其他步骤（包括aop）--> aservice代理对象（aserviceproxy）
5.加入到单例池中

其中aservice对象的代理对象和aservice的代理对象如下所示：

示例2中通过一个bozimap打破了循环创建bean对象，而产生的循环依赖。而在aop过程中，步骤2.2.填充aservice时，应该是把4.其他步骤，aservice代理对象赋值给步骤2.2.填充aservice的普通对象。所以要对示例2进行优化,把aop放到第二步，先判断是否出现循环依赖，在进行aop，再把aservice的代理对象放入bizimap中。得到示例3：

aservice生命周期
0.creatingset[aservice]表示正在创建中的bean。
1.实例化 --->aservice的普通对象
2.填充bservice（添加了autowired）-->从单例池中获取bservice
	(此时单例池中可能还没存放bservice的bean)-->创建bservice
  当单例池中可能还没存放bservice的bean时，触发创建bservice生命周期，步骤和aservice一致。如下所示：
  2.1.实例化--->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池-->creatingset中是否存在aservice-->aop-->aservice的代理对象-->最后赋值给bservice中的属性aservice
  2.3.填充其他属性
  2.4.其他步骤
  2.5.加入到单例池中
3.填充其他属性
4.其他步骤（包括aop）--> aservice代理对象（aserviceproxy）
5.加入到单例池中

此时加大难度，多加一个cservice，c中依赖的a，而a中也依赖了c，根据示例3，会得到如下步骤。把本例子定义为示例4，该例子中，填充bservice和cservice会反复创建代理对象。

aservice生命周期
0.creatingset[aservice]表示正在创建中的bean。
1.实例化 --->aservice的普通对象
2.填充bservice，cservice（添加了autowired）-->从单例池中获取bservice
	(此时单例池中可能还没存放bservice的bean)-->创建bservice
  当单例池中可能还没存放bservice的bean时，触发创建bservice生命周期，步骤和aservice一致。如下所示：
  2.1.实例化--->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池-->creatingset中是否存在aservice-->aop-->aservice的代理对象-->最后赋值给bservice中的属性aservice
  2.3.填充其他属性
  2.4.其他步骤
  2.5.加入到单例池中
  填充cservice，cservice的生命周期
  2.1.实例化-->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->creatingset中是否存在aservice-->aop-->aservice的代理对象-->最后赋值给cservice中的属性aservice
  2.3.填充其他属性
  2.4.其他步骤
  2.5.加入到单例池中
3.填充其他属性
4.其他步骤（包括aop）--> aservice代理对象（aserviceproxy）
5.加入到单例池中

为了解决这个问题，使用二级缓存存放a的代理对象。

aservice生命周期
0.creatingset[aservice]表示正在创建中的bean。
1.实例化 --->aservice的普通对象
2.填充bservice，cservice（添加了autowired）-->从单例池中获取bservice
	(此时单例池中可能还没存放bservice的bean)-->创建bservice
  当单例池中可能还没存放bservice的bean时，触发创建bservice生命周期，步骤和aservice一致。如下所示：
  2.1.实例化--->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池-->creatingset中是否存在aservice-->循环依赖
  --->earlysingletonobjects是否存在aservice的代理对象,存在返回bean即可
  -->aop-->aservice的代理对象-->存入二级缓存，earlysingletonobjects<beanname,aservice的代理对象>-->最后赋值给bservice中的属性aservice
  2.3.填充其他属性
  2.4.其他步骤
  2.5.加入到单例池中
  填充cservice，cservice的生命周期
  2.1.实例化-->bservice的普通对象
  2.2.填充aservice（添加了autowired）-->单例池-->creatingset中是否存在aservice-->earlysingletonobjects
  2.3.填充其他属性
  2.4.其他步骤
  2.5.加入到单例池中
3.填充其他属性
4.其他步骤（包括aop）--> aservice代理对象（aserviceproxy）
5.加入到单例池中

三级缓存

三级缓存为了打破循环，在第一步骤中生成的不同对象，用三级缓存保存起来。三级缓存在spring‘源码中可singletonfactories，是一个map，其中它的value存的是一个lambda表达式，其中的逻辑是，判断是否需要aop，需要则返回一个代理对象，反之则返回service的普通对象。’

小结

一级缓存的作用就是保存经过完整生命周期的bean对象。
二级缓存，早期由于出现循环依赖，保存那些还没完整走完bean生命周期的bean对象，是为了给其他bean填充属性时使用的代理对象赋值。
三级缓存，在出现循环依赖时，如果二级缓存中没有存有对应的bean对象，需要通过三级缓存去判断，是否需要aop，是则需要返回代理对象，否则需要返回普通对象。三级返回的的结果最终还是存在二级缓存中。spring的核心源码实现如下所示。