【深入浅出Spring6】第五期——循环依赖和反射机制

最新推荐文章于 2023-07-06 12:49:00 发布
最新推荐文章于 2023-07-06 12:49:00 发布
阅读量270 收藏 1
点赞数 1
分类专栏： Spring 文章标签： java 前端 原型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61323055/article/details/127869459
版权

一、Bean的循环依赖问题

  • 什么是循环依赖？
    • 类似于A依赖B，B又依赖A，这样就构成了依赖闭环
  • 需求：我们创建两个类，彼此内置对方为私有属性，我们查看是否可以正常输出

$ singleton+ setter产生的循环依赖

编写我们的丈夫类和妻子类： Husband、Wife

package com.powernode.spring6.bean;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Husband {
    private String name;
    private Wife wife;

    public void setName(String name) {
        this.name = name;
    }

    public void setWife(Wife wife) {
        this.wife = wife;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Husband{" +
                "name='" + name + '\'' +
                ", wife=" + wife.getName() +
                '}';
    }
}

package com.powernode.spring6.bean;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Wife {
    private String name;
    private Husband husband;

    public void setName(String name) {
        this.name = name;
    }

    public void setHusband(Husband husband) {
        this.husband = husband;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Wife{" +
                "name='" + name + '\'' +
                ", husband=" + husband.getName() +
                '}';
    }
}

编写我们的XML配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--为丈夫类和妻子类分别声明Bean，属性相互调用，作用域采用单例
        Singleton + setter 模式的循环依赖
    -->
    <bean id="husbandBean" class="com.powernode.spring6.bean.Husband" scope="singleton">
        <property name="name" value="唐玄宗" />
        <property name="wife" ref="wifeBean" />
    </bean>

    <bean id="wifeBean" class="com.powernode.spring6.bean.Wife" scope="singleton">
        <property name="name" value="杨玉环" />
        <property name="husband" ref="husbandBean" />
    </bean>
</beans>

编写测试方法：CircularDependencyTest

@Test
    public void testCD(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Husband husbandBean = applicationContext.getBean("husbandBean", Husband.class);
        Wife wifeBean = applicationContext.getBean("wifeBean", Wife.class);
        System.out.println(husbandBean);
        System.out.println(wifeBean);
    }

在这里插入图片描述
我们可以看到，当产生循环依赖，作用域为singleton的时候采用set注入不会产生任何问题

$ prototype+setter产生的循环依赖

  • 需求：我们只需要修改配置文件就可以查看测试结果
  • 将scope的属性值修改为 prototype
<bean id="husbandBean" class="com.powernode.spring6.bean.Husband" scope="prototype">
	<property name="name" value="唐玄宗" />
	<property name="wife" ref="wifeBean" />
</bean>

<bean id="wifeBean" class="com.powernode.spring6.bean.Wife" scope="singleton">
	<property name="name" value="杨玉环" />
	<property name="husband" ref="husbandBean" />
</bean>
  • 当我们采用prototype+setter的模式时，会出现BeanCreationException（正在创建中）异常
  • 因为不会再初始化上下文的时候创建实例，我们调用一个getBean的时候才会去创建，
    • 这就导致我们创建husband时，wife属性赋值要去创建新的Wife的对象，
    • 然后我们创建wife对象的时候， husband属性赋值又要去创建新的Husband的对象
      • 一直处于无限的创建对象的过程中
  • 只要在这个产生循环依赖的几个Bean中，存在一个Bean的scope为singleton就可以解决问题

$ singleton+构造注入产生的循环依赖

  • 我们创建Husband类和Wife类，然后通过构造方法传递参数值，依旧使用默认的scope去测试

编写我们的 Husband 和 Wife 类

package com.powernode.spring6.bean2;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Husband {
    private String name;
    private Wife wife;

    public Husband(String name, Wife wife) {
        this.name = name;
        this.wife = wife;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Husband{" +
                "name='" + name + '\'' +
                ", wife=" + wife.getName() +
                '}';
    }
}

package com.powernode.spring6.bean2;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Wife {
    private String name;
    private Husband husband;

    public Wife(String name, Husband husband) {
        this.name = name;
        this.husband = husband;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Wife{" +
                "name='" + name + '\'' +
                ", husband=" + husband.getName() +
                '}';
    }
}

编写我们的配置文件 spring2.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--采用 singleton + 构造方法注入的模式
        Singleton 是在对象创建完之后曝光，然而构造方法注入是在属性赋值结束之后才算完成对象的创建
        构造注入产生的循环依赖无法解决
    -->
    <bean id="h" class="com.powernode.spring6.bean2.Husband">
        <!--通过构造方法注入-->
        <constructor-arg name="name" value="李隆基" />
        <constructor-arg index="1" ref="w" />
    </bean>
    <bean id="w" class="com.powernode.spring6.bean2.Wife">
        <constructor-arg index="0" value="杨贵妃" />
        <constructor-arg name="husband" ref="h" />
    </bean>
</beans>

编写我们的测试文件 >> Is there an unresolvable circular reference? 【产生的报错信息】

@Test
public void testCD2(){
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring2.xml");
	Husband husband = applicationContext.getBean("h", Husband.class);
	Wife wife = applicationContext.getBean("h", Wife.class);
	System.out.println(husband);
	System.out.println(wife);
}
  • 因为我们利用构造方法注入，只有在参数赋值结束才会创建出对象，所以和prototype的报错类似，第一个创建的Bean一直得不到满足
  • 那么Spring采用Singleton作用域是如何解决循环依赖的呢？

$ Spring 解决循环依赖的原理

  • Spring只能解决setter方法注入的单例bean之间的循环依赖
  • 采用singleton+set注入的方式，可以将“实例化Bean”和“给Bean属性赋值”这两个动作分离开去完成的，【这两步不要求在同一个时间点上完成】
  • Bean都是单例的，我们可以先把所有的单例Bean实例化出来，放到一个集合当中【缓存】
  • 所有的单例Bean全部实例化完成之后，以后我们再慢慢的调用setter方法给属性赋值。这样就解决了循环依赖的问题
  • 在这种模式下，Spring对Bean的管理分为两个阶段：
    • 第一个阶段：Spring容器加载的时候，实例化Bean之后，立即曝光【就是此时已经可以调用这个实例了】
    • 第二个阶段：Bean“曝光"之后，再调用set方法对属性赋值。

在这里插入图片描述

  • 在DefaultSingletonBeanRegistry中定义了三个Map集合 >> 分别对应一、二、三级缓存

    • 单例对象的缓存：key存储bean名称，value存储Bean对象【一级缓存】
    • 早期单例对象的缓存：key存储bean名称，value存储早期的Bean对象【二级缓存】
    • 单例工厂缓存：key存储bean名称，value存储该Bean对应的ObjectFactory对象【三级缓存】

  • 在该类中有这样一个方法addSingletonFactory()，这个方法的作用是：将创建Bean对象的ObjectFactory对象提前曝光
    在这里插入图片描述

  • 大致流程就是先从一级缓存中找，找不到就去二级缓存中找，再找不到就去三级缓存中获取之前曝光的ObjectFactory对象，通过ObjectFactory对象获取Bean实例，这样就解决了循环依赖的问题。

二、回顾反射机制

  • 动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制
  • 因为后续要手写Spring框架，所以我们需要在此处回顾一下反射机制

$ 方法四要素

  • 需求：我们通过一个案例来分析调用一个方法的四要素都包括什么

编写我们的 SomeService 类：包含三个doSome方法

package com.powernode.reflect;

/**
 * @author Bonbons
 * @version 1.0
 */
public class SomeService {
    // 我们提供三个doSome方法
    public void doSome(){
        System.out.println("无参doSome方法执行");
    }
    public String doSome(String s){
        System.out.println("一个参数doSome方法执行");
        return s;
    }
    public String doSome(String s, int n){
        System.out.println("两个参数doSome方法执行");
        return s + n;
    }
}

不采用反射机制，我们编写一个测试类调用我们的方法

package com.powernode.reflect;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 不使用反射机制 >> 创建对象调用这三个方法
        SomeService someService = new SomeService();
        someService.doSome();
        String res = someService.doSome("王维");
        System.out.println(res);
        String res1 = someService.doSome("一刀", 999);
        System.out.println(res1);
        /*
            调用一个方法，我们需要知道四个元素：
                第一，调用哪个对象
                第二，调用对象哪个方法
                第三，方法的参数列表
                第四，方法的返回值情况
         */
    }
}

在这里插入图片描述

得出结论 >> 调用哪个对象的哪个方法，传什么参数，返回什么值 【四要素】

$ 利用反射机制调用方法

  • 需求：通过反射机制创建对象进而调用我们的方法

采用上面的 SomeService 类，只需要再编写一个测试类 Test2

package com.powernode.reflect;

import java.lang.reflect.Method;

/**
 * 我们利用反射机制来调用方法
 * @author Bonbons
 * @version 1.0
 */
public class Test2 {
    public static void main(String[] args) throws Exception{
        // 获取类
        Class<?> clazz = Class.forName("com.powernode.reflect.SomeService");
        /* 获取方法,通过getDeclaredMethods获取的全部方法
           我们通过 getDeclaredMethod获取的是我们指定的方法，参数为方法名和对应的参数列表
         */
        Method doSome = clazz.getDeclaredMethod("doSome", String.class, int.class);
        // 创建类的对象，此处使用的是过时的方法
        Object obj = clazz.newInstance();
        // 通过调用方法四要素来调用我们的方法
        Object retValue = doSome.invoke(obj, "一刀", 999);
        System.out.println(retValue);


    }
}

在这里插入图片描述
总结，使用反射机制的基本步骤 >> 获取类、获取方法、创建对象、调用方法

$ 利用反射机制调用set方法注入参数

  • 需求：根据给出的条件，我们调用方法传递参数，最后输出我们创建的对象，看参数是否传递成功
  • 条件：
    • 类名是：com.powernode.reflect.User
    • 该类中有String类型的name属性和int类型的age属性
    • 另外你也知道该类的设计符合javabean规范

编写我们的User类

package com.powernode.reflect;

/**
 * @author Bonbons
 * @version 1.0
 */
public class User {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

编写我们的测试方法：

package com.powernode.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author Bonbons
 * @version 1.0
 */
public class Test4 {
    /*
    我们要调用set的方法，已知信息如下：
        (1) 全限定类名 className
        (2) 方法名，propertyName
        (3) 方法类型为int
        
     */

    public static void main(String[] args) throws Exception{
    	// 已知类名
        String className = "com.powernode.reflect.User";
        // 已知方法名
        String propertyName = "age";
        // 获取类
        Class<?> clazz = Class.forName(className);
        // 获取set方法名
        String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
        // 根据属性名获取属性类型
        Field field = clazz.getDeclaredField(propertyName);
        // 此处的 int.class >> field.getType()，获取方法
        Method ageMethod = clazz.getDeclaredMethod(setMethodName, field.getType());
        // 创建对象
        Object o = clazz.newInstance();
        // 调用方法
        ageMethod.invoke(o, 20);
        // 输出对象
        System.out.println(o);
    }
}
  • 此处创建对象使用的是过时的方法，我们可以先获得无参构造器，再利用无参构造器创建对象
Constructor<?> con = clazz.getDeclaredConstructor();
Object o = con.newInstance();

在这里插入图片描述

Bow.贾斯汀
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
探秘Spring框架解决循环依赖的高效策略
12-13
Spring框架作为Java企业级应用的核心，其解决循环依赖的能力是其健壮性和灵活性的关键体现。循环依赖，即两个或多个组件相互依赖，常在大型应用中遇见。Spring通过三级缓存和AOP代理机制巧妙处理这一挑战。首先，一...
深入理解Spring中的循环依赖
08-27
Spring在注入bean的时候会做循环依赖检查，下面这篇文章主要给大家介绍了关于Spring中循环依赖的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起看...
【Spring】6.循环依赖
我有故事你有酒？
11-29 151
很简单，就是A对象依赖了B对象，B对象依赖了A对象。比如://A Bclass A{}//B Aclass B{}那么循环依赖是个问题吗?如果不考虑Spring，循环依赖并不是问题，因为对象之间相互依赖是很正常的事情。比如a.b = b;b.a = a;这样，A,B就依赖上了。但是，在Spring中循环依赖就是一个问题了，为什么?
【Spring6】| Bean的循环依赖问题
m0_61933976的博客
03-15 1135
【Spring6】| Bean的循环依赖问题（含源码分析）
【SSM】Spring6(六.Bean的循环依赖)
北极星的博客
04-06 365
Bean都是单例的，我们可以先把所有的单例Bean实例化出来，放到一个集合当中（我们可以称之为缓存），所有的单例Bean全部实例化完成之后，以后我们再慢慢的调用setter方法给属性赋值。原因：主要原因是因为通过构造方法注入导致的：因为构造方法注入会导致实例化对象的过程和对象属性赋值的过程没有分离开，必须在一起完成导致的。（1）在spring容器加载的时候，实例化Bean，只要其中任意一个Bean实例化后，马上进行“曝光”通过构造方法注入产生了循环依赖，并且Spring是无法解决这种循环依赖的。
Spring6 - （10） Bean 的循环依赖问题
chenyouchang的博客
03-27 128
什么是循环依赖？A对象中有B属性。B对象中有A属性，我依赖你，你也依赖我。比如：丈夫类Husband，妻子类Wife。Husband中有Wife的引用。Wife中有Husband的引用。
spring6笔记3（bean的循环依赖，手写spring框架，ioc注解开发，JdbcTemplate）
m0_64589497的博客
01-01 1397
bean的循环依赖，手写spring框架，ioc注解开发，JdbcTemplate
浅谈Spring如何解决循环依赖的问题
08-25
主要介绍了浅谈Spring如何解决循环依赖的问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
浅谈Spring解决循环依赖的三种方式
08-28
本篇文章主要介绍了浅谈Spring循环依赖的三种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
深入浅出学spring
05-21
本视频从基础讲起，对spring初学者的帮助还是比较大的
06 Spring 源码总结 - 循环依赖
刘元雄
06-23 465
06 Spring 源码总结 - 循环依赖
spring6依赖----配置文件
m0_63064861的博客
05-28 201
【代码】spring6依赖。
【深入浅出Spring6】第一期——入门
欢迎来到我的世界
11-10 1074
介绍了OCP、DIP、IoC，以及Spring是干什么的、有哪些优势和特点，编写了第一个spring入门程序，分析了一些使用spring的要点
【spring】06 循环依赖的分析与解决
阿杰
08-09 203
循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A
【Spring（六）】彻底搞懂Spring的依赖注入
hihielite的博客
01-13 1166
在核心容器这一部分bean相关的操作，我们已经学完了，接下来我们就要进入到第二个大的模块，与我们的DI,也就是依赖注入相关知识的学习了，那我们先来学习第一个内容，依赖注入应该怎么去做，也就是依赖注入有哪些方式呢❓❓以上就是我们依赖注入的全部内容，最后，如果有什么错误的话，大家可以私信我📬📬，！！
【深入浅出Spring6】第二期——依赖注入
欢迎来到我的世界
11-14 992
讲述了Spring是如何通过依赖注入实现控制反转的，以及各种set注入是如何实现的，对命名空间优化注入、xml的自动注入、引用外部配置文件也有涉及
Spring循环依赖以及解决方法
weixin_50798782的博客
11-29 1667
什么是循环依赖？ 循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。 Spring中循环依赖场景有： （1）构造器的循环依赖 （2）field属性的循环依赖。 1. filed 属性注入的循环依赖代码 @Service public class A { @Autowired private B b; } @Service public class B { @Autowired private A
Java 中的反射机制（两万字超全详解）
热门推荐
林二月的博客
09-08 1万+
文章目录一、反射概述1. 什么是反射？2. 反射机制原理3. 反射优点和缺点4. 类加载概述5. 类加载各阶段完成的功能5.1 加载阶段5.2 连接阶段——验证5.3 连接阶段——准备5.4 连接阶段——解析5.5 初始化阶段二、Class 类1. 动态加载2. 小结三、访问字段1. 获取字段值2. 设置字段值3. 小结四、调用方法1. 调用方法2. 调用静态方法3. 调用非 public方法4. 多态5. 小结五、调用构造方法六、获取继承方法1. 获取父类的Class2. 获取interface3. 继承
Requested bean is currently in creation: Is there an unresolvable circular reference? 原因之一（java)
最新发布
sinat_37792529的博客
07-06 1万+
正常代码是实现接口后直接重新或者方法名称直调就行不用再次注入直接的接口这种错误的写法。说明 更新新的工作插件，工作空间 启动项目报错。
spring事务传播机制 和 spring bean的生命周期和 循环依赖怎么解决的介绍一下
05-04
1. Spring事务传播机制 事务传播机制是指事务方法被嵌套调用时，如何处理事务，Spring提供了七种事务传播行为： - REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。 - SUPPORTS...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bow.贾斯汀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值