Spring三级缓存解决循环依赖

最新推荐文章于 2024-04-25 08:41:31 发布
最新推荐文章于 2024-04-25 08:41:31 发布
阅读量9.4k 收藏 70
点赞数 5
分类专栏： 小知识点 文章标签： spring 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44027353/article/details/126252574
版权

有两个Bean对象，A对象中有一个属性的B对象，B对象中有一个属性的A对象，他们都需要依赖注入，但是map单例池中都没有这个对象。正常情况下在进行注入时，如果map单例池中没有需要的Bean对象B就会去创建这个Bean对象B，但如果需要创建的这个Bean对象B又需要依赖注入对象A，这就造成了循环依赖问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wyk4IBXq-1660038093817)(E:\Java笔记\picture\image-20220807101443225.png)]

Spring使用了三级缓存来解决循环依赖。

  • 第一级缓存：单例池 singletonObjects，它用来存放经过完整Bean生命周期过程的单例Bean对象
  • 第二级缓存：earlySingletonObjects，它用来保存哪些没有经过完整Bean生命周期的单例Bean对象，用来保证不完整的bean也是单例
  • 第三级缓存：singletonFactories，它保存的就是一个lambda表达式，它主要的作用就是bean出现循环依赖后，某一个bean到底会不会进行AOP操作

现在有两个Bean，进行循环依赖

@Component
public class AService{
    @Autowired
    BService bService;
    
    public void test(){
        System.out.println(bService);
    }
}

@Component
public class BService{
    @Autowired
    AService aService;
   
}

现在创建Bean的过程如下：

AService 创建的生命周期

  1. 推断构造函数，创建AService的普通对象
  2. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象
  3. 填充其他属性
  4. 初始化前操作 @PostConstruct
  5. 初始化 InitialzingBean接口中的afterPropertiesSet()
  6. 初始化后 AOF
  7. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —> 找不到就创建AService
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

这就造成了循环依赖

可以引入一个map来解决循环依赖问题，在创建AService普通对象的时候，将这个普通对象存入map中，然后在BService创建的生命周期中进行依赖注入时，如果在单例池中没有找到AService对象就去map中找。

AService 创建的生命周期

  1. 推断构造函数，创建AService的普通对象 —> hushangMap<beanName, 普通对象>
  2. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象
  3. 如果有其他属性就填充其他属性
  4. 初始化前操作 @PostConstruct
  5. 初始化 InitialzingBean接口中的afterPropertiesSet()
  6. 初始化后 AOF
  7. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —> 去hushangMap中找，能够找到AService的普通对象，就不用去创建了
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

我们可以发现，到现在为止就使用了两个map，所以明明Spring使用两级缓存就能解决循环依赖为什么最后还要使用三级缓存嘞？肯定是有一些缺陷的。比如，可能AService会进行AOP操作，会创建AServiceProxy代理对象，然后将代理对象放入单例池中，但是BService进行属性赋值 依赖注入的时候是把AService的普通对象进行赋值，所以这里是有问题的，应该是赋值AServiceProxy代理对象。

解决这个问题的思路就是，将AOP的操作提前，如果AService要进行AOP的话，那就就将代理对象放入hushangMap中，而不是放普通对象

AService 创建的生命周期

  1. 推断构造函数，创建AService的普通对象 —> AOP —> hushangMap<beanName, 代理对象>
  2. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象
  3. 如果有其他属性就填充其他属性
  4. 初始化前操作 @PostConstruct
  5. 初始化 InitialzingBean接口中的afterPropertiesSet()
  6. 初始化后 AOF
  7. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —> 去hushangMap中找 —> 得到AService代理对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

现在我们需要在第一步就去判断该对象是否要进行AOP操作，我们不可能所有的Bean在第一步的时候就去进行AOP，因为在Spring中整体的设计是在第5步才会去进行AOP，只有在某种特殊的情况下才需要在第一步去进行AOP。这个特殊情况就是当前Bean出现了循环依赖的情况下才需要提前进行AOP。

AService 创建的生命周期

出现了循环依赖的情况下才需要提前进行AOP。

  1. 推断构造函数，创建AService的普通对象 —> 是否满足循环依赖条件？—> AOP —> hushangMap<beanName, 代理对象>
  2. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象
  3. 如果有其他属性就填充其他属性
  4. 初始化前操作 @PostConstruct
  5. 初始化 InitialzingBean接口中的afterPropertiesSet()
  6. 初始化后 AOF
  7. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —> 去hushangMap中找 —> 得到AService代理对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

我们能够发现，在AService创建中第一步的时候 不太好判断当前Bean是否产生了循环依赖，在BService创建的第二步中才比较好判断是否产生了循环依赖。我们可以再创建AService的时候，将当前创建的Bean的名字存入一个createSet集合中。在BService创建中依赖出入时，如果在单例池中没有找到需要的bean，那就去createSet集合中判断有没有我们需要的Bean，如果有就表示当前需要的Bean对象它自己正在创建中，这也就是循环依赖

AService 创建的生命周期

  1. creatingSet(“AService”)

  2. 推断构造函数，创建AService的普通对象 —> hushangMap<beanName, 普通对象>

  3. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象

  4. 如果有其他属性就填充其他属性

  5. 初始化前操作 @PostConstruct

  6. 初始化 InitialzingBean接口中的afterPropertiesSet()

  7. 初始化后 AOF

  8. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —>createSet找 —> 出现了循环依赖 —>提前AOP 生成AServiceProxy代理对象，如果Bean本来就不需要进行AOP操作这里就还是获取的普通对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

现在还是有问题的，假如现在有三个Bean，进行循环依赖

@Component
public class AService{
    @Autowired
    BService bService;
    
    @Autowired
   	CService cService;
    
    public void test(){
        System.out.println(bService);
    }
}

@Component
public class BService{
    @Autowired
    AService aService;
}

@Component
public class CService{
    @Autowired
    AService aService;
}

那么现在的创建过程如下：

AService 创建的生命周期

  1. creatingSet(“AService”)

  2. 推断构造函数，创建AService的普通对象 —> hushangMap<beanName, 普通对象>

  3. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象

  4. 依赖注入，为cService属性赋值—>去单例池SingletonObjects中找CService —> 如果没有就创建CService的Bean对象

  5. 如果有其他属性就填充其他属性

  6. 初始化前操作 @PostConstruct

  7. 初始化 InitialzingBean接口中的afterPropertiesSet()

  8. 初始化后 AOF

  9. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —>createSet找 —> 出现了循环依赖 —>提前AOP 生成AServiceProxy代理对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

CService 创建的生命周期

  1. 推断构造函数，创建CService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —>createSet找 —> 出现了循环依赖 —>提前AOP 生成AServiceProxy代理对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

可以发现上方创建了两个AServiceProxy代理对象，分别赋值给了BService和CService中的属性，这不符合单例Bean，应该的一个AServiceProxy代理对象放入单例池，并且是这个对象进行依赖注入。

解决这个问题就需要使用第二级缓存 earlySingletonObjects，将创建好的AServiceProxy代理对象放入earlySingletonObjects中，key就是beanName，value就是创建好的代理对象，然后CService就从这里拿。

earlySingletonObjects存放的是还没有经过完整生命周期的单例bean对象。

AService 创建的生命周期

  1. creatingSet(“AService”)

  2. 推断构造函数，创建AService的普通对象 —> hushangMap<beanName, 普通对象>

  3. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象

  4. 依赖注入，为cService属性赋值—>去单例池SingletonObjects中找CService —> 如果没有就创建CService的Bean对象

  5. 如果有其他属性就填充其他属性

  6. 初始化前操作 @PostConstruct

  7. 初始化 InitialzingBean接口中的afterPropertiesSet()

  8. 初始化后 AOF

  9. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —>createSet找 —> 出现了循环依赖 —>从earlySingletonObjects中拿—>没有获取到，就提前AOP 生成AServiceProxy代理对象 —> 存入earlySingletonObjects<AService, AServiceProxy>
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

CService 创建的生命周期

  1. 推断构造函数，创建CService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —>createSet找 —> 出现了循环依赖 —>从earlySingletonObjects中拿，得到AServiceProxy代理对象
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

这里其实是用了三个map，也就是三级缓存，第一个就是单例池singletonObjects用来存放经历了完整Bean生命周期的单例bean，第二个就是earlySingletonObjects存放还没有经过完整Bean生命周期的单例bean，第三个map的用处 就是在BService的第二步中，对AService进行AOP操作是需要AService的普通对象的

Spring里面还是会用到一个map，我们可以暂时理解为前面说的hushangMap，先推断构造函数创建好AService的普通对象后，存入Map中去，key是bean的名字，value中存创建好的bean的名字、普通对象以及beanDefinition，这里有三个对象，value里面如何存放三个对象嘞？Spring是会去定义一个lambda表达式。

AService 创建的生命周期

  1. creatingSet(“AService”)，把当前beanName存入一个set集合中
  2. 推断构造函数，创建AService的普通对象 —> singletonFactories<beanName, lambda(beanName,普通对象,beanDefinition)>
  3. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找BService —> 如果没有就创建BService的Bean对象
  4. 如果有其他属性就填充其他属性
  5. 初始化前操作 @PostConstruct
  6. 初始化 InitialzingBean接口中的afterPropertiesSet()
  7. 初始化后 AOF，假如第2步出现循环依赖已经进行了AOP操作，这里就不用再进行一遍了，如下图所示
  8. 如果出现了循环依赖，从二级缓存earlySingletonObjects中取代理对象/普通对象
  9. 放入单例池

BService 创建的生命周期

  1. 推断构造函数，创建BService的普通对象
  2. 依赖注入，为aService属性赋值—>去单例池中找AService对象 —> createSet找,判断是否出现了循环依赖 —> 出现了循环依赖 —>从earlySingletonObjects中拿—>如果没有获取到 ----> 从三级缓存singletonFactories找，得到lambda表达式，并执行lambda表达式，执行的方法中会去判断这Bean是否需要进行AOP—>AOP 生成AServiceProxy代理对象；如果不要进行AOP操作 lambda表达式就会得到一个普通对象 —> 存入earlySingletonObjects
  3. 初始化前操作 @PostConstruct
  4. 初始化 InitialzingBean接口中的afterPropertiesSet()
  5. 初始化后 AOF
  6. 放入单例池

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0AMSPRe1-1660038093819)(E:\Java笔记\picture\image-20220807153808043.png)]

总结：

最终的步骤如下：

AService 创建生命周期

  1. creatintSet(“AService”)
  2. 推断构造函数，实例化得到普通对象 —> singletonFactories(lombda(beanName,普通对象，beanDefinition))
  3. 依赖注入，为bService属性赋值—>去单例池SingletonObjects中找—>没找到 —> 创建BService的Bean对象
  4. 填充其他属性
  5. 初始化前操作，@PostConstruct
  6. 初始化，实现InitialozingBean接口，afterPropertiesSet()方法
  7. 初始化后，AOP操作，判断是否需要
  8. 将二级缓存earlySingletonObjects中的代理对象/普通对象取出来
  9. 存入单例池中

BService 创建生命周期

  1. 推断构造函数，实例化得到普通对象
  2. 依赖注入，为aService属性赋值 —> 去singletonObjects中找 —> 没找到 —> creatingSet，判断是否循环依赖 —> 二级缓存earlySingletonObjects中找 —> 没找到 —> singletonFactories --> 代理对象/普通对象 —> 存入二级缓存earlySingletonObjects
  3. 初始化前操作，@PostConstruct
  4. 初始化，实现InitialozingBean接口，afterPropertiesSet()方法
  5. 初始化后，AOP操作，判断是否需要
  6. 将二级缓存earlySingletonObjects中的代理对象/普通对象取出来
  7. 存入单例池中
胡尚
关注
  • 5
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
简单了解Spring循环依赖解决过程
08-25
主要介绍了简单了解Spring循环依赖解决过程,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring三级缓存解决循环依赖
qq_41312061的博客
06-08 1929
spring， 三级缓存，循环依赖
【Spring篇 | 补充】三级缓存解决循环依赖
最新发布
踢桃的成长之路
04-25 1424
三级缓存解决循环依赖
spring无法用三级缓存解决循环依赖的问题分析
weixin_48445640的博客
04-17 942
spring无法解决构造器的循环依赖，对上述例子稍微进行改动： @Component("b") public class B { private A a; public B(A a) { this.a = a; } } @Component("a") public class A { private B b; public A(B b) { this.b = b; } // 该方法使用了aop来完成 pubi
Spring三级缓存解决循环依赖问题
trong_ 的烂笔头
10-26 3474
解析理解在互相依赖的 Bean 是单例的、依赖注入的方式不都是构造注入的前提下如何使用三级缓存解决Spring中的循环依赖的问题。
Spring——三级缓存解决循环依赖详解
共勉
11-29 1万+
结合Spring源码分析三级缓存分别是什么？在哪里产生？一张图搞清楚到底是怎么解决循环依赖的？一张图搞清楚二级缓存行不行？
如何通过三级缓存解决 Spring 循环依赖
江南一点雨的专栏
07-17 1415
首先，什么是循环依赖？AService 和 BService 互相依赖：这个应该很好理解。
Spring中的“三级缓存”
热门推荐
weixin_44181671的博客
09-16 2万+
Spring的“三级缓存”基础认识常见问题循环依赖代码示例Spring 中三大循环依赖场景 演示Spring 循环依赖小结“三级缓存”意义Spring 解决循环依赖原理分析Spring 容器的“三级缓存”源码解析 常见问题 循环依赖 循环依赖：就是 N 个类循环（嵌套）使用。 简单来说，就是多个 Bean 之间互相依赖或引用到对方，最终形成了 闭环。循环依赖的关系可以表示成下图 上图中的 A，B，C 代表三个不同的对象，上图表示了三者的引用关系。 循环依赖不仅发生在多个类中，还可能发生在本类中，即 N =
Spring 如何解决循环依赖的问题(三级缓存)
m0_52184592的博客
09-11 690
三级缓存
Spring三级缓存
qq_36363499的博客
08-08 1万+
什么是spring的循环依赖？spring容器的bean互相依赖形成闭环，称为spring的循环依赖。spring循环依赖只能用于set方法和成员变量注入实现，且要求是单例bean，多例（原型bean）是不能实现循环依赖的。构造方法注入是不能实现循环依赖的，会抛出异常(Requested bean is currently in creation: Is there an unresolvable circular reference?...
Spring三级缓存解决循环依赖.pdf
06-22
Spring三级缓存解决循环依赖.pdf
浅谈Spring解决循环依赖的三种方式
08-28
Spring框架提供了三种方式来解决循环依赖问题：构造器参数循环依赖、setter方法循环依赖和使用三级缓存解决循环依赖。 第一种：构造器参数循环依赖 构造器参数循环依赖是指通过构造器注入构成的循环依赖。这种依赖...
探秘Spring框架解决循环依赖的高效策略
12-13
Spring框架在处理循环依赖...总之，Spring通过三级缓存和AOP代理机制，实现了对循环依赖的高效处理，保证了应用的稳定性和性能。这个解决方案不仅体现了Spring的灵活性，也为Java开发者提供了宝贵的设计和架构经验。
3. 循环依赖问题（三级缓存）.xmind
08-29
《spring源码之循环依赖和三级缓存》整理，本人水平有限，从网上找的资料整合之后做的，请辩证的看待其中内容。
Spring的三级缓存
weixin_40133204的博客
12-19 1万+
Spring三级缓存 对象创建的过程 spring的三级缓存分别是 // 从上至下 分表代表这“三级缓存” private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); //
Spring 的三级缓存机制
m0_51431003的博客
02-27 4870
这时，bean B 也需要依赖 bean A，但由于 bean A 的工厂对象已经在三级缓存中，Spring 可以直接从三级缓存中获取到 bean A 的工厂对象，并通过它来创建 bean A 的实例。而对于需要被AOP代理的Bean，singletonFactories中的工厂对象会先创建一个原始的Bean实例，然后通过AOP代理来生成代理对象，并将代理对象放入一级缓存singletonObjects中。：在Spring中，AOP代理是在Bean的初始化阶段完成的，这意味着所有的属性填充和方法调用之后。
【源码+个人总结】Spring 的 三级缓存 解决 循环依赖
Du939的博客
05-07 1058
看三级缓存源码，确认解决循环依赖的过程
Spring使用三级缓存解决循环依赖
xiaomu_a的博客
05-11 1600
循环依赖： @Service public class TestService1 { @Autowired private TestService2 testService2; public void test1() { } } @Service public class TestService2 { @Autowired private TestService1 testService1; public void test2() {
Spring如何通过三级缓存解决循环依赖问题？
2301_77899321的博客
08-02 925
Spring如何通过三级缓存解决循环依赖问题？
spring 三级缓存能不能解决所有的循环依赖问题
07-28
Spring的三级缓存是解决循环依赖问题的一种方式，但并不能解决所有的循环依赖问题。 在Spring中，当两个或多个bean之间存在循环依赖关系时，Spring使用三级缓存来解决这个问题。三级缓存包括early singleton objects缓存、singleton factory object缓存和early prototype objects缓存。通过这种机制，Spring能够在创建bean的过程中解决循环依赖。 然而，三级缓存并不是万能的。它只适用于单例bean和原型bean之间的循环依赖问题，对于其他类型的bean，如请求作用域（request scoped）或会话作用域（session scoped），三级缓存是无法解决的。 此外，如果循环依赖关系过于复杂或设计不合理，三级缓存可能无法解决问题，甚至可能导致死循环或其他运行时异常。因此，在使用Spring时，需要注意避免过多的循环依赖或重新考虑应用程序的设计以消除循环依赖。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值