Java框架篇4-SpringBean循环依赖学习笔记

最新推荐文章于 2024-06-15 18:40:38 发布
最新推荐文章于 2024-06-15 18:40:38 发布
阅读量711 收藏
点赞数
分类专栏： Java面试篇 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45498432/article/details/124140412
版权

Java框架篇4-SpringBean循环依赖

1.代理对象

1.1 ProxyFactory代理使用

package day04.bean;

import kotlin.reflect.KClass;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.framework.ProxyFactory;

public class APP {
    public static void main(String[] args) {
        //aspect=通知(advice)+切点(pointcut),一个切面类中可能有一到多个通知
        //advisor=更细粒度的切面，包含一个通知和切点

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(new Target1());//设置目标对象
        //添加通知
        proxyFactory.addAdvice((MethodInterceptor) methodInvocation -> {
            try {
                System.out.println("前置增强");
                return methodInvocation.proceed();//调用目标
            } finally {
                System.out.println("后置增强");
            }
        });
        Target1 proxy = (Target1) proxyFactory.getProxy();//创建代理对象

        proxy.foo();
        proxy.bar();
    }
    interface I1{
        void foo();
        void bar();
    }

    static class Target1 implements I1{

        @Override
        public void foo() {

        }

        @Override
        public void bar() {

        }
    }
}

1.2 ProxyFactory添加切点

package day04.bean;

import kotlin.reflect.KClass;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

public class APP {
    public static void main(String[] args) {
        //aspect=通知(advice)+切点(pointcut),一个切面类中可能有一到多个通知
        //advisor=更细粒度的切面，包含一个通知和切点

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(new Target1());//设置目标对象
//        //添加通知，环绕通知
//        proxyFactory.addAdvice((MethodInterceptor) methodInvocation -> {
//            try {
//                System.out.println("前置增强");
//                return methodInvocation.proceed();//调用目标
//            } finally {
//                System.out.println("后置增强");
//            }
//        });
        
        //切面，foo（）更加增强  bar不增强
        AspectJExpressionPointcut pointcut=new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* foo())");

        proxyFactory.addAdvisor(new DefaultPointcutAdvisor(pointcut,(MethodInterceptor) methodInvocation -> {
            try {
                System.out.println("前置增强");
                return methodInvocation.proceed();//调用目标
            } finally {
                System.out.println("后置增强");
            }
        }));
        
        Target1 proxy = (Target1) proxyFactory.getProxy();//创建代理对象
        proxy.foo();
        proxy.bar();
       
    }

    interface I1{
        void foo();
        void bar();
    }

    static class Target1 implements I1{

        @Override
        public void foo() {

        }

        @Override
        public void bar() {

        }
    }
}

1.3注解方式实现AOP

 @Aspect
 //切面类
 static class Aspect1{
 		//通知方法
     @Around("execution(* foo())")  //一个advisor切面
     public Object around(ProceedingJoinPoint pjp) throws Throwable{
         System.out.println("aspect1 around");
         return pjp.proceed();
     }
 }

1.4 创建代理总结

  • 最基本的切面是Advisor，一个Aspect切面对应一个到多个Advisor
  • 最基本的Advice是MethodInterceptor，其他的Advice最终都将配置为MethodInterceptor
  • 创建代理的方式
    实现了用户自定义接口，采用jdk动态代理
    没有实现用户自定义接口，采用cjlib代理
    设置了setProxyTargetClass（TRUE），统一采用cglib代理
  • 切面、切点、通知等不
    会被代理
  • AnnotationAwareAspectJAutoProxyCreator调用时机：创建阶段，依赖注入阶段，初始化阶段

2.循环依赖

2.1循环依赖的产生

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

请添加图片描述

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

    • 可以在【a 创建】和【a set 注入 b】之间加入 b 的整个流程来解决

    • 【b set 注入 a】 时可以成功，因为之前 a 的实例已经创建完毕

    • a 的顺序，及 b 的顺序都能得到保障
      请添加图片描述

  • 构造方法的循环依赖如图所示，显然无法用前面的方法解决
    请添加图片描述

2.2构造循环依赖的解决

  • 思路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));
    }
}

2.3解决 set 循环依赖的原理

2.3.1一级缓存

请添加图片描述
作用是保证单例对象仅被创建一次

  • 第一次走 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，陷入了死循环

2.3.2二级缓存

请添加图片描述
解决思路如下：

  • 再增加一个 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 对象拿到和注入的都是原始对象

2.3.2三级缓存

请添加图片描述
简单分析的话，只需要将代理的创建时机放在依赖注入之前即可，但 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 就中的对象就没有用处，清除即可

探索者7号
关注
专栏目录
图灵Java高级互联网架构师第6期源码框架专题笔记.zip
09-11
图灵Java高级互联网架构师第6期源码框架专题笔记,内容包含: 01-Spring底层核心原理解析-周瑜 02-手写模拟Spring底层原理-周瑜 03-Spring之底层架构核心概念解析-周瑜 04-Spring之Bean生命周期源码解析上-周瑜 05-...
AOP-AspectJ 切面技术及使用MethodInterceptor实现切面
weixin_45326523的博客
08-07 1146
aop、切面
Spring in Action 入门之面向切面编程AOP
weixin_34008784的博客
11-02 156
注明：这篇文章一是当成学习笔记，二是给大家提供另一个快速理解学习Spring的参考。欢迎留言讨论，持续更新中~ （该部分是Spring的面向切面编程AOP） 第四章 通知Bean 在软件编程中，散布于程序中多个地点的函数被称为“交叉事务”（日志管理、权限控制等）。从概念上来说，它们一般是与程序业务逻辑分开的，但经常却是直接嵌入其中的。把这些交叉事务与业务逻辑分离开正式面向切面编程（AOP）的...
Spring AOP源码分析篇三: Pointcut解析(AspectJExpressionPointcut为例)
weixin_42054506的博客
05-29 1954
在前面文章Spring AOP源码分析篇二：AnnotationAwareAspectJAutoProxyCreator解析并获取advisor、切点pointcut_程序源仔的博客-CSDN博客中有出现很多次pointcut的字眼，今天重点讲解一下这方面，为后续文章打基础1、Pointcut的唯一作用是筛选要拦截的目标方法，换句话说Pointcut只是一种筛选规则2、说到筛选规则，PointCut依赖了（类过滤器）和。
Spring之Bean循环依赖详解
azhou的代码园
05-08 4493
今天要说的是spring中循环依赖的问题，最近有大量粉丝问这个问题，也是高薪面试中经常会被问到的一个问题。 关于循环依赖的问题，来感受一下连环炮，试试自己否可以过关斩将，轻松应对。 什么是循环依赖？ 如何检测是否存在循环依赖？ 如何解决循环依赖？ 多例的情况下，循环依赖问题为什么无法解决？ 单例的情况下，虽然可以解决循环依赖，是否存在其他问题？ 为什么采用三级缓存解决循环依赖？如果直接将早期bean丢到二级缓存可以么？ 前面4个ok的，超越了80
第二章 Spring bean实例化、IOC、循环依赖笔记
hankin的博客
01-01 795
一、Bean的实例化过程 流程图地址：https://www.processon.com/view/link/5df87156e4b0cfc88c3c18c5 org.springframework.context.support.AbstractApplicationContext#refresh方法中 /** 这个方法是spring中最重要的方法，没有之一，所以这个方法一定要理解要具体看...
Spring Boot学习笔记
03-21
总结，Spring Boot学习笔记涵盖了Thymeleaf模板引擎的使用，如何实现国际化，以及如何将MyBatis和JDBC整合到Spring Boot应用中，这些都是在构建现代Java后端应用时不可或缺的技术。通过深入理解并掌握这些知识点，...
Spring2.5_学习笔记.doc.zip
06-02
《Spring2.5 学习笔记》是一份深入解析Spring框架2.5版本的文档，旨在帮助开发者全面理解和掌握这一经典版本的核心特性与应用实践。Spring作为Java领域中最流行的轻量级框架之一，其2.5版本在当时的发布带来了许多...
动力节点老杜最新版Spring6框架教程学习资料分享
07-19
第七点：Bean的循环依赖 第八点：Spring的八大设计模式 第九点：17种注入方案，其他视频讲10种以内。 第十点：Bean的8种Scope，其他视频最多讲4种。 第十一点：Bean生命周期10步讲解法，其他视频最多讲7步。 通过本...
java学习笔记
05-29
### Java学习笔记知识点详解 #### 一、Java基础知识概述 Java是一种广泛使用的面向对象的编程语言，具有简单性、面向对象、健壮性、安全性、平台独立性、可移植性等特点。Java的基本知识包括以下几个方面： 1. **...
SpringBean循环依赖
大唐雨夜的博客
04-30 1364
循环依赖 所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。 1、三级缓存解决循环依赖 Spring通过三级缓存的方式来解决循环依赖的问题。DefaultSingletonBeanRegistry类中的三个缓存变量 //一级缓存：单例缓存池，用于保存所有的完整单例bean private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //三级缓存：早期对
Spring对于循环依赖是如何解决的
常备不懈
04-06 257
随着项目的不断扩大，依赖关系的复杂度也在不断增加。在这种情况下，循环依赖问题就显得尤为突出。Spring框架作为一种广泛使用的Java企业级应用开发框架，为开发者提供了一套优雅的解决方案来应对循环依赖。在本篇文章中，我们将探讨Spring是如何解决循环依赖的。
Spring Bean 循环依赖详解
一醉自救的专栏
02-02 967
时序图帮助理解Spring Bean 循环依赖
Spring AOP之Advisor、PointcutAdvisor、IntroductionAdvisor、IntroductionInterceptor
皮球
02-16 1521
Spring AOP之Advisor、PointcutAdvisor、IntroductionAdvisor、IntroductionInterceptor
Spring-Bean循环依赖
皮皮皮的代码
03-05 2050
1. 介绍 1.1 什么是Bean循环依赖 两个或则两个以上的对象互相依赖对方，最终形成闭环。例如 A 对象依赖 B 对象，B 对象也依赖 A 对象。 1.2 会有什么问题 对象的创建过程会产生死循环，类似如下 1.3 Spring是如何解决的 通过三级缓存提前暴露对象来解决。 一级缓存存的是成品对象(实例化和初始化都完成了的)，我们应用中使用的对象就是一级缓存； 二级缓存中存的是半成品(实例化，但是还未初始化)，用来解决对象创建过程中的循环依赖问题； 三级缓.
Spring-bean的循环依赖
orixixi的博客
04-15 590
Spring的循环依赖是指在Spring管理的Bean之间存在互相引用的情况，即两个或多个Bean相互依赖，形成闭环，陷入无限递归或无法完成初始化的状态。
[Spring3.x源码]AOP（四）切面的执行
woorh的专栏
01-01 1075
1.调用对象的方法后，会执行此代理的对象的invoke。JdkDynamicAopProxy.invoke(Object proxy, Method method, Object[] args): public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { MethodInvocat
Spring 循环依赖详解
最新发布
Java领域优秀创作者
06-15 2307
在Spring框架中，依赖注入（Dependency Injection, DI）是其核心功能之一，它通过配置来管理对象的创建和它们之间的依赖关系。然而，在复杂的应用程序中，开发人员有时会遇到循环依赖的问题，即Bean A依赖于Bean B，而Bean B又依赖于Bean A。如果不加以处理，这种情况会导致应用程序无法启动。在本文中，我们将深入探讨Spring循环依赖的原理、处理机制、最佳实践以及可能遇到的问题。
Spring-Bean的循环依赖
Lucky小黄人的博客
12-18 1516
文章参考： Spring-bean的循环依赖以及解决方式 曹工说Spring Boot源码(29)-- Spring 解决循环依赖为什么使用三级缓存，而不是二级缓存(好文) 一文告诉你Spring是如何利用“三级缓存“巧妙解决Bean的循环依赖问题的【享学Spring】(好文) 面试讲解思路： 什么是循环依赖？ Spring怎么解决循环依赖 Spring对于循环依赖无法解决的场景......
Java Spring框架深度探索：bean的依赖注入解析
"深入解析Java的Spring框架中bean的依赖注入" 在Java的Spring框架中，依赖注入（Dependency Injection，简称DI）是一种设计模式，用于管理对象间的依赖关系，以提高代码的可测试性和可维护性。它使得组件之间解耦，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值