动力节点B站Spring6学习笔记——Spring对IoC的实现

最新推荐文章于 2024-05-31 11:42:39 发布
最新推荐文章于 2024-05-31 11:42:39 发布
阅读量164 收藏
点赞数
文章标签： spring 学习 笔记 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76637757/article/details/130645212
版权

根据B站动力节点老杜讲的Spring6教程整理了学习笔记，分享给大家，共同学习进步~

这套Spring教程基于Spring6讲解，Spring6是下一个十年的新开端。

四、Spring对IoC的实现

4.1 IoC 控制反转

  • 控制反转是一种思想。
  • 控制反转是为了降低程序耦合度，提高程序扩展力，达到OCP原则，达到DIP原则。
  • 控制反转，反转的是什么？
    • 将对象的创建权利交出去，交给第三方容器负责。
    • 将对象和对象之间关系的维护权交出去，交给第三方容器负责。
  • 控制反转这种思想如何实现呢？
    • DI（Dependency Injection）：依赖注入

4.2 依赖注入

依赖注入实现了控制反转的思想。
Spring通过依赖注入的方式来完成Bean管理的。
Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。
依赖注入：

  • 依赖指的是对象和对象之间的关联关系。
  • 注入指的是一种数据传递行为，通过注入行为来让对象和对象产生关系。

依赖注入常见的实现方式包括两种：

  • 第一种：set注入
  • 第二种：构造注入

新建模块：spring6-002-dependency-injection

4.2.1 set注入

set注入，基于set方法实现的，底层会通过反射机制调用属性对应的set方法然后给属性赋值。这种方式要求属性必须对外提供set方法。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.powernode</groupId>
    <artifactId>spring6-002-dependency-injection</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

</project>

package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserDao
 * @since 1.0
 **/
public class UserDao {
   

    public void insert(){
   
        System.out.println("正在保存用户数据。");
    }
}


package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserService
 * @since 1.0
 **/
public class UserService {
   

    private UserDao userDao;

    // 使用set方式注入，必须提供set方法。
    // 反射机制要调用这个方法给属性赋值的。
    public void setUserDao(UserDao userDao) {
   
        this.userDao = userDao;
    }

    public void save(){
   
        userDao.insert();
    }
}


<?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 id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>

</beans>

package com.powernode.spring6.test;

import com.powernode.spring6.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 动力节点
 * @version 1.0
 * @className DITest
 * @since 1.0
 **/
public class DITest {
   

    @Test
    public void testSetDI(){
   
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = applicationContext.getBean("userServiceBean", UserService.class);
        userService.save();
    }
}

运行结果：
image.png
重点内容是，什么原理：

<?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 id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>

</beans>

实现原理：
通过property标签获取到属性名：userDao
通过属性名推断出set方法名：setUserDao
通过反射机制调用setUserDao()方法给属性赋值
property标签的name是属性名。
property标签的ref是要注入的bean对象的id。(通过ref属性来完成bean的装配，这是bean最简单的一种装配方式。装配指的是：创建系统组件之间关联的动作)
可以把set方法注释掉，再测试一下：
image.png
通过测试得知，底层实际上调用了setUserDao()方法。所以需要确保这个方法的存在。
我们现在把属性名修改一下，但方法名还是setUserDao()，我们来测试一下：

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserService
 * @since 1.0
 **/
public class UserService {
   

    private UserDao aaa;

    // 使用set方式注入，必须提供set方法。
    // 反射机制要调用这个方法给属性赋值的。
    public void setUserDao(UserDao userDao) {
   
        this.aaa = userDao;
    }

    public void save(){
   
        aaa.insert();
    }
}

运行测试程序：
image.png
通过测试看到程序仍然可以正常执行，说明property标签的name是：setUserDao()方法名演变得到的。演变的规律是：

  • setUsername() 演变为 username
  • setPassword() 演变为 password
  • setUserDao() 演变为 userDao
  • setUserService() 演变为 userService

另外，对于property标签来说，ref属性也可以采用标签的方式，但使用ref属性是多数的：

<bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
  <property name="userDao">
    <ref bean="userDaoBean"/>
  </property>
</bean>

总结：set注入的核心实现原理：通过反射机制调用set方法来给属性赋值，让两个对象之间产生关系。

4.2.2 构造注入

核心原理：通过调用构造方法来给属性赋值。

package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderDao
 * @since 1.0
 **/
public class OrderDao {
   
    public void deleteById(){
   
        System.out.println("正在删除订单。。。");
    }
}

package com.powernode.spring6.service;

import com.powernode.spring6.dao.OrderDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderService
 * @since 1.0
 **/
public class OrderService {
   
    private OrderDao orderDao;

    // 通过反射机制调用构造方法给属性赋值
    public OrderService(OrderDao orderDao) {
   
        this.orderDao = orderDao;
    }

    public void delete(){
   
        orderDao.deleteById();
    }
}

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>
<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--index="0"表示构造方法的第一个参数，将orderDaoBean对象传递给构造方法的第一个参数。-->
  <constructor-arg index="0" ref="orderDaoBean"/>
</bean>

@Test
public void testConstructorDI(){
   
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    OrderService orderServiceBean = applicationContext.getBean("orderServiceBean", OrderService.class);
    orderServiceBean.delete();
}

运行结果如下：
image.png
如果构造方法有两个参数：

package com.powernode.spring6.service;

import com.powernode.spring6.dao.OrderDao;
import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderService
 * @since 1.0
 **/
public class OrderService {
   
    private OrderDao orderDao;
    private UserDao userDao;

    // 通过反射机制调用构造方法给属性赋值
    public OrderService(OrderDao orderDao, UserDao userDao) {
   
        this.orderDao = orderDao;
        this.userDao = userDao;
    }

    public void delete(){
   
        orderDao.deleteById();
        userDao.insert();
    }
}

spring配置文件：

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>

<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--第一个参数下标是0-->
  <constructor-arg index="0" ref="orderDaoBean"/>
  <!--第二个参数下标是1-->
  <constructor-arg index="1" ref="userDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

执行测试程序：
image.png
不使用参数下标，使用参数的名字可以吗？

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>

<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--这里使用了构造方法上参数的名字-->
  <constructor-arg name="orderDao" ref="orderDaoBean"/>
  <constructor-arg name="userDao" ref="userDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

执行测试程序：
image.png
不指定参数下标，不指定参数名字，可以吗？

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>
<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--没有指定下标，也没有指定参数名字-->
  <constructor-arg ref="orderDaoBean"/>
  <constructor-arg ref="userDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

执行测试程序：
image.png
配置文件中构造方法参数的类型顺序和构造方法参数的类型顺序不一致呢？

<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>

<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--顺序已经和构造方法的参数顺序不同了-->
  <constructor-arg ref="userDaoBean"/>
  <constructor-arg ref="orderDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

执行测试程序：
image.png
通过测试得知，通过构造方法注入的时候：

  • 可以通过下标
  • 可以通过参数名
  • 也可以不指定下标和参数名，可以类型自动推断。

Spring在装配方面做的还是比较健壮的。

4.3 set注入专题

4.3.1 注入外部Bean

在之前4.2.1中使用的案例就是注入外部Bean的方式。

<?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 id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>

</beans>

外部Bean的特点：bean定义到外面，在property标签中使用ref属性进行注入。通常这种方式是常用。

4.3.2 注入内部Bean

内部Bean的方式：在bean标签中嵌套bean标签。

<?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 id="userServiceBean" class<
最低0.47元/天 解锁文章
可乐得加冰啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
动力节点老杜Spring6教程，深入剖析原理手撕源码
qaswedpl的博客
08-10 131
机遇，杜老师新作《破解Spring6》,本书率先将Spring6所有知识点进行了归纳总结，采用生活案例+实战项目相结合，即便是零基础小白也可以很快速沉浸其中，通过学习让你不仅会使用Spring框架，还会让你精通框架底层原理，不论实际开发还是跳槽面试，皆大有裨益。通过本套教程的学习，可以让你不仅会使用Spring框架，还会让你精通框架底层原理。Spring6是下一个十年的新开端，动力节点老杜精心打造全新升级版Spring6教程，手把手教学，带大家从。第十点：Bean的8种Scope，其他视频最多讲4种。
SpringIOC+SpringMVC学习笔记
02-21
个人学习spring框架时记录的笔记，纯手敲，SpringIOC+SpringMVC学习笔记，有兴趣的可以参考
动力节点老杜Spring6，配套笔记PDF文件
02-08
动力节点老杜Spring6，配套笔记PDF文件 源自https://www.yuque.com/dujubin/ltckqu/kipzgd?singleDoc#Kp2MS
[Java]Spring6学习笔记(动力节点老杜)【完结】
emmmm.....
02-05 5852
🥽 Spring启示录 🌊 OCP开闭原则 🌊 依赖倒置原则（DIP原则） 🌊 控制反转 🌊 Spring框架 🌊 依赖注入 🥽 Spring概述 🌊 Spring简介 🌊 Spring8大模块 🌊 Spring特点 🥽 Spring的入门程序 🌊 Spring5的下载 🌊 Spring6的下载 🌊 Spring的jar文件 🌊 第一个Spring程序 🌊 第一个Spring程序剖析 🌊 Spring6启用Log4j2日志框架 🥽 Spring对IoC的实现 🌊 IoC
[记录学习]自学动力节点老杜Spring6笔记_01
sls1223074612的博客
01-05 2565
动力节点老杜Spring6自学笔记
Spring6老杜【上】
Wolf__king的博客
02-25 411
spring6动力节点老杜
spring学习笔记（1）——B站动力节点
m0_52041525的博客
07-15 381
spring
Spring 学习笔记1 —— IOC容器 I （IOC容器、DI依赖注入）
2401_84152126的博客
05-04 756
在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！大家看完有什么不懂的可以在下方留言讨论也可以关注。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！水浒传在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例。
Spring 学习笔记1 —— IOC容器 I （IOC容器、DI依赖注入）(2)
2401_84152109的博客
05-04 611
终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！ail">下面的例子来自Kuangshen.终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化[外链图片转存中…(img-Ufvtvy6H-1714752772021)]《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
Spring动力节点老杜课程学习笔记
m0_48038376的博客
01-01 1384
Spring动力节点老杜课程笔记
动力节点Spring学习笔记
qq_59748240的博客
02-26 1069
上 不依赖 下，就是符合控制反转：IOC轻量控制反转面向切面容器框架。
Spring.NET学习笔记-实现一个简易的IoC框架
02-23
在我们使用Spring.NET框架的时候，首先需要实例化Spring.NET容器, 然后调用IoC容器IObjectFactory接口中GetObject方法获取容器中的对象。通过这一点就可以告诉我们制作IoC容器需要写一个获取XML文件内容的方法和申明...
Spring_IoC入门笔记.md
05-29
依赖注入：Dependency Injection IOC的作用：降低程序间的偶合（依赖关系） 依赖关系的管理：以后都交给spring来维护 ... ref:用于指定其他bean类型数据，它所指的是在spring的IOC容器中出现的bean
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
主要介绍了Spring学习笔记1之IOC详解尽量使用注解以及java代码 的相关资料,需要的朋友可以参考下
MVC使用Spring.Net应用IOC（依赖倒置）学习笔记3
10-21
主要为大家详细介绍了MVC使用Spring.Net应用IOC（依赖倒置）,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
springboot mqtt收发消息
最新发布
qq_34874784的博客
05-31 259
​在Spring Boot中，可以使用MQTT协议来收发消息。这样，就可以使用Spring Boot和MQTT协议来收发消息了。5. 使用MQTT消息接收和发送服务。3. 创建MQTT消息接收服务。4. 创建MQTT消息发送服务。2. 配置MQTT连接工厂。
SpringBoot集成腾讯COS流程
weixin_67727883的博客
05-30 198
SpringBoot集成腾讯COS流程
SpringBoot 异步编程
凤凰的博客
05-29 654
使用@Async注解，在默认情况下用的是线程池，该线程池不是真正意义上的线程池。使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发= null?//判断是否开启限流，默认为否//执行前置操作，进行限流} else {//未限流的情况，执行线程任务//不断创建线程= null?//创建线程//指定线程名，task-1，task-2...
SpringBoot 的 Java 代码配置（二）
xiaotu的博客
05-29 1100
因此，如果使用 HikariCP 只用声明你要用它就行，而声明要使用 Druid，你需要自己指定所使用的版本。上面的 DruidDataSource ，我们为其属性赋值时，它的四个属性都是简单类型属性，因此十分容易处理。但是，在 Spring 的容器中，Java Bean 可能会存在引用。在上面的 Druid 的配置中，数据库连接的四大属性值是在代码中『写死』的。而在 Java 代码配置中，通过 @Bean 方法的入参来表达 Bean 之间的引用关系。，所以，我们可以直接将自定义的配置项写在。
动力节点spring6笔记
10-16
动力节点Spring6是一门关于Spring框架的课程。在这门课程中，我们学习了Spring框架的基本原理、核心特性以及应用。 首先，我们学习了Spring框架的概述和起源。了解了Spring框架的由来，它的目标是简化企业级应用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值