Spring bean 循环依赖

已于 2022-02-09 15:47:01 修改
阅读量568 收藏
点赞数 1
分类专栏： springboot新发现 java 文章标签： spring java 后端
于 2022-02-08 15:09:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37362891/article/details/122823400
版权

在这里插入图片描述

文章目录

循环依赖的产生

  • 首先要明白，bean 的创建要遵循一定的步骤，必须是创建、注入、初始化三步，这些顺序不能乱
    在这里插入图片描述

  • set 方法（包括成员变量）的循环依赖如图所示

    • 可以在「a 创建」和「a set 注入 b」之间加入 b 的整个流程来解决
    • 「b set 注入 a」 时可以成功，因为之前 a 的实例已经创建完毕
    • a 的顺序，及 b 的顺序都能得到保障

在这里插入图片描述

  • 构造方法的循环依赖如图所示，显然无法用前面的方法解决
    在这里插入图片描述

构造循环依赖的解决

思路1

  • a 注入 b 的代理对象，这样能够保证 a 的流程走通
  • 后续需要用到 b 的真实对象时，可以通过代理间接访问
    在这里插入图片描述

思路2

  • a 注入 b 的工厂对象，让 b 的实例创建被推迟，这样能够保证 a 的流程先走通
  • 后续需要用到 b 的真实对象时，再通过 ObjectFactory 工厂间接访问

在这里插入图片描述

示例1：用 @Lazy 为构造方法参数生成代理

public class App60_1 {

    static class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private B b;

        public A(@Lazy B b) {
            log.debug("A(B b) {}", b.getClass());
            this.b = b;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    static class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;

        public B(A a) {
            log.debug("B({})", a);
            this.a = a;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("a", A.class);
        context.registerBean("b", B.class);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
        context.refresh();
        System.out.println();
    }
}

示例2：用 ObjectProvider 延迟依赖对象的创建

public class App60_2 {

    static class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private ObjectProvider<B> b;

        public A(ObjectProvider<B> b) {
            log.debug("A({})", b);
            this.b = b;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    static class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;

        public B(A a) {
            log.debug("B({})", a);
            this.a = a;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("a", A.class);
        context.registerBean("b", B.class);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
        context.refresh();

        System.out.println(context.getBean(A.class).b.getObject());
        System.out.println(context.getBean(B.class));
    }
}

示例3：用 @Scope 产生代理

public class App60_3 {

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context.getDefaultListableBeanFactory());
        scanner.scan("com.itheima.app60.sub");
        context.refresh();
        System.out.println();
    }
}

@Component
class A {
    private static final Logger log = LoggerFactory.getLogger("A");
    private B b;

    public A(B b) {
        log.debug("A(B b) {}", b.getClass());
        this.b = b;
    }

    @PostConstruct
    public void init() {
        log.debug("init()");
    }
}

@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
@Component
class B {
    private static final Logger log = LoggerFactory.getLogger("B");
    private A a;

    public B(A a) {
        log.debug("B({})", a);
        this.a = a;
    }

    @PostConstruct
    public void init() {
        log.debug("init()");
    }
}

示例4：用 Provider 接口解决

  • 原理上与 ObjectProvider 一样，Provider 接口是独立的 jar 包，需要加入依赖
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

public class App60_4 {

    static class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private Provider<B> b;

        public A(Provider<B> b) {
            log.debug("A({}})", b);
            this.b = b;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    static class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;

        public B(A a) {
            log.debug("B({}})", a);
            this.a = a;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("a", A.class);
        context.registerBean("b", B.class);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
        context.refresh();

        System.out.println(context.getBean(A.class).b.get());
        System.out.println(context.getBean(B.class));
    }
}

解决 set 循环依赖的原理

一级缓存

在这里插入图片描述
作用是保证单例对象仅被创建一次

  • 第一次走 getBean("a") 流程后，最后会将成品 a 放入 singletonObjects 一级缓存
  • 后续再走 getBean("a") 流程时，先从一级缓存中找，这时已经有成品 a，就无需再次创建

一级缓存与循环依赖

在这里插入图片描述
一级缓存无法解决循环依赖问题，分析如下

  • 无论是获取 bean a 还是获取 bean b，走的方法都是同一个 getBean 方法，假设先走 getBean("a")
  • 当 a 的实例对象创建，接下来执行 a.setB() 时，需要走 getBean("b") 流程，红色箭头 1
  • 当 b 的实例对象创建，接下来执行 b.setA() 时，又回到了 getBean("a") 的流程，红色箭头 2
  • 但此时 singletonObjects 一级缓存内没有成品的 a，陷入了死循环

二级缓存

在这里插入图片描述

解决思路如下：

  • 再增加一个 singletonFactories 缓存
  • 在依赖注入前，即 a.setB() 以及 b.setA() 将 a 及 b 的半成品对象（未完成依赖注入和初始化）放入此缓存
  • 执行依赖注入时，先看看 singletonFactories 缓存中是否有半成品的对象，如果有拿来注入，顺利走完流程

对于上面的图

  • a = new A() 执行之后就会把这个半成品的 a 放入 singletonFactories 缓存，即 factories.put(a)
  • 接下来执行 a.setB()，走入 getBean("b") 流程，红色箭头 3
  • 这回再执行到 b.setA() 时，需要一个 a 对象，有没有呢？有！
  • factories.get() 在 singletonFactories 缓存中就可以找到，红色箭头 4 和 5
  • b 的流程能够顺利走完，将 b 成品放入 singletonObject 一级缓存，返回到 a 的依赖注入流程，红色箭头 6

二级缓存与创建代理

在这里插入图片描述

二级缓存无法正确处理循环依赖并且包含有代理创建的场景，分析如下

  • spring 默认要求，在 a.init 完成之后才能创建代理 pa = proxy(a)
  • 由于 a 的代理创建时机靠后，在执行 factories.put(a) 向 singletonFactories 中放入的还是原始对象
  • 接下来箭头 3、4、5 这几步 b 对象拿到和注入的都是原始对象

三级缓存

在这里插入图片描述

简单分析的话，只需要将代理的创建时机放在依赖注入之前即可，但 spring 仍然希望代理的创建时机在 init 之后，只有出现循环依赖时，才会将代理的创建时机提前。所以解决思路稍显复杂：

  • 图中 factories.put(fa) 放入的既不是原始对象，也不是代理对象而是工厂对象 fa
  • 当检查出发生循环依赖时，fa 的产品就是代理 pa，没有发生循环依赖，fa 的产品是原始对象 a
  • 假设出现了循环依赖，拿到了 singletonFactories 中的工厂对象，通过在依赖注入前获得了 pa，红色箭头 5
  • 这回 b.setA() 注入的就是代理对象，保证了正确性，红色箭头 7
  • 还需要把 pa 存入新加的 earlySingletonObjects 缓存，红色箭头 6
  • a.init 完成后，无需二次创建代理，从哪儿找到 pa 呢？earlySingletonObjects 已经缓存，蓝色箭头 9

当成品对象产生，放入 singletonObject 后，singletonFactories 和 earlySingletonObjects 就中的对象就没有用处，清除即可

set解决循环依赖代码分析

没有代理情况
public class App60_1 {

    static class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private B b;

        public A() {
            log.debug("A()");
        }

        @Autowired
        public void setB(B b) {
            log.debug("set B({})", b);
            this.b = b;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    static class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;

        public B() {
            log.debug("B()");
        }

        @Autowired
        public void setA(A a) {
            log.debug("setA({})", a);
            this.a = a;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("a", A.class);
        context.registerBean("b", B.class);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
        context.refresh();
        System.out.println();
    }
}

  • 两个地方打断点

    • org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
      在这里插入图片描述
    • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
      在这里插入图片描述

  • 第一次走到getSingleton，这个时候是第一getBean(A)

在这里插入图片描述

  • 放开，我们再来看，这个时候是第二次getBean(A)，分析这个流程

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 测试我们进入getSingleton这个方法里面，测试

在这里插入图片描述
在这里插入图片描述

  • 这里有个问题，什么时机放到三级缓存中的呢？
    在这里插入图片描述

有代理情况

public class App60_2 {

    static class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private B b;

        public A() {
            log.debug("A()");
        }

        @Autowired
        public void setB(B b) {
            log.debug("set B({})", b);
            this.b = b;
        }

        public void foo() {
            System.out.println("foo");
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    @Aspect
    static class MyAspect{
        @Before("execution(* foo())")
        public void before()  {
            System.out.println("before ...");
        }
    }

    static class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;
        public B() {
            log.debug("B()");
        }
        @Autowired
        public void setA(A a) {
            log.debug("setA({})", a.getClass());
            this.a = a;
        }

        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("a", A.class);
        context.registerBean("b", B.class);
        context.registerBean(MyAspect.class);
        context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());

先看下运行结果，这里A对象就是被cglib代理之后的对象。
在这里插入图片描述

  • 跟上次一样，我们看下B在setA的时候，这个时候拿的就是代理对象。
    在这里插入图片描述

  • 这里有两次会触发代理对象创建的地方

it噩梦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring bean循环依赖时序图
09-09
spring bean循环依赖时序图详细的描述了spring的循环依赖关系，帮我们快速了解spring是如何优雅的进行处理的
SpringBean循环依赖
大唐雨夜的博客
04-30 1121
循环依赖 所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。 1、三级缓存解决循环依赖 Spring通过三级缓存的方式来解决循环依赖的问题。DefaultSingletonBeanRegistry类中的三个缓存变量 //一级缓存：单例缓存池，用于保存所有的完整单例bean private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //三级缓存：早期对
SpringBean循环依赖源码分析
念念不忘，必有回响
11-09 607
文章目录什么循环依赖什么循环依赖无法解决解决方式整体处理流程图核心方法为什么使用三级缓存 什么循环依赖 循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A 依赖 B，B 又依赖 A；或者A依赖于B，B依赖于C，C又依赖于A 这里用一个代码来说明 TestA @Component public class TestA { @Autowired private TestB testB; } TestB @Component public cla
Spring Bean循环依赖问题及解决
最新发布
技术博客
11-12 1209
类与类之间的依赖关系形成了闭环，就会导致循环依赖问题的产生。举例来说，假设存在两个服务类A和服务类B，如果A通过依赖注入的方式引用了B，且B通过依赖注入的方式引用了A，那么A和B之间就存在循环依赖。推广来说，如果涉及多个类，也存在这种依赖关系，那么也是循环依赖问题。循环依赖问题比较严重，有时会影响服务启动，有时会导致死循环调用(如果线上环境出现循环调用，会导致程序进入死循环，然后服务崩溃，进而导致用户请求无法响应，造成生产事故)，应引起足够的重视。
Spring bean循环依赖解决方案
a1032722788的博客
02-20 601
Spring bean循环依赖以及源码分析前言产生循环依赖的原因如何解决spring bean循环依赖spring为何引入三级缓存spring 循环依赖的流程图spring 循环依赖源码分析总结 前言 开工了，大家在一个春节过后是否可以快速的适应假期之后的工作呢，小编开工第一天就要加班，想起来苦兮兮。因为还调休了一天导致错过红包，心理感觉错过了一个亿，难受啊，只能化悲愤为动力，写个文章安慰自己一下。 今天小编来说一下spring bean的循环依赖，其实网上这个资料超级多，各位大佬也已经总结的相当清楚，那小
详解Spring Bean的循环依赖解决方案
08-28
主要介绍了详解Spring Bean的循环依赖解决方案,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springbean循环依赖问题，与解决方案。.docx
10-26
Springbean循环依赖问题，与解决方案。.docx
Spring5.0源码深度解析之SpringBean循环依赖问题解决方案.docx
10-26
Spring5.0源码深度解析之SpringBean循环依赖问题解决方案.docx
详解Spring-bean的循环依赖以及解决方式
08-27
主要介绍了详解Spring-bean的循环依赖以及解决方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【Spring Security】Spring Security 解决swagger无法访问
热门推荐
batman
12-14 1万+
由于加上了security，访问swagger就会出现下面这个问题，这是由于对每个到达系统的http请求链接进行校验，有的连接需要暴露出来 1.解决方法 1.1 排除拦截 将swagger的访问路径，给排除掉，这样就解决了。 @Configuration @EnableResourceServer @EnableGlobalMethodSecurity(prePostEnabled = true...
浅谈spring的生命周期
batman
01-31 6728
文章目录前言生命周期 前言 对于一个长期的spring使用者来说，对于spring 的生命周期不是很了解，所以趁着这个疫情比较严重的时候，在家静下心来，看一下这个很久困在心中的一个问题。 生命周期 它大致分为Bean 定义、Bean 的初始化、Bean 的生存期和Bean的销毁4 个部分。其中Bean 定义过程大致如下: Spring 通过我们的配置，如＠ComponentScan定义的扫描路...
springboot 整合 pagehelper + tk-mybatis 多数据源问题
batman
05-25 3770
             闲暇之余，写点最近的收获，写一点心得，便于以后参考方便，另外可以帮助有这样需求的人少走弯路。          整合多个数据源，很多博客会提到springboot整合jdbcTemplete为例子，网上有很多，今天主要推荐的是整合 pagehelper + tk-mybatis 多数据源问题。              其实很简单，我的整合思路分为以下几个步骤。     ...
Spring中event事件执行顺序
batman
08-19 2522
前言 我们自定义监听spring event通常有两种方式，先说下这两种方式，然后从两种方式的差异说明event的顺序。 @Component 实现 使用@Component方式实现如下： @Component @Slf4j public class ApplicationListenerImpl implements ApplicationListener<ApplicationEvent> { public ApplicationListenerImpl() { .
【Spring Security】Spring Security Oauth2登陆提供Controller接口
batman
12-23 1832
上次分享到如何使用postman实现账号密码登陆，显然很复杂，传到的参数太多，一般我们只需要传两个参数即可，即 username和password这样就行了，况且以后做网关的话，也会分流到这个接口，于是这样的接口的开发势在必得。 1. 代码实现 1.1 创建请求类 三个参数，用户名，密码，验证码。 @Data @ToString public class LoginRequest { S...
自定义实现spring cache 整合 guava 、 redis 两级缓存
batman
06-19 1247
参考链接 spring boot + spring cache 实现两级缓存（redis + caffeine
springboot2.1 实现swagger自动化配置
batman
11-02 1136
spring-boot-starter-swagger swagger自动多模块配置 当我们构建分布式系统的时候，虽然我们可以用Swagger来方便为每个服务自动产出API文档页面。但是随着服务数量的增多， 内部服务间的依赖关系的复杂度增加，每个服务开发人员要关心和查阅的文档变得越来越多。由于每个服务的文档地址可能都不一样， 这使得不得不维护一个文档的索引来方便查阅，并且这个索引还需要不断的去维护...
SpringBoot属性绑定Environment和Binder
batman
11-15 916
helloWorld: properties: spring: json: trusted: packages: '*' type: mapping: fast.cloud.nacos.fastbootkafka.domain.TopicATest:fast.cloud.nacos.fastbootkafka.dom.
Spring 之 @Autowired 的理解
batman
11-23 856
前言 在了解@Autowired之前，需要知道先提出几个问题： 1、InstantiationAwareBeanPostProcessor 这个接口是干嘛的，字面上理解是感知Bean实例话的处理器，这篇请看Spring之InstantiationAwareBeanPostProcessor 理解 2、什么是依赖注入？ 依赖注入：Dependency Injection，简称DI，说白了就是利用反射机制为类的属性赋值的操作。 3、什么是注入，注到哪里？ 注入就是为某个对象的外部资源赋值，注入某个对象所需要的.
springbean循环依赖
04-28
Spring中的循环依赖指的是两个或多个Bean之间相互依赖，形成了一个环路。当存在循环依赖时，Spring容器在创建Bean时会出现问题，因为它无法确定哪个Bean应该先被创建。 Spring通过使用三级缓存解决循环依赖问题。当...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值