Spring依赖注入 DI

最新推荐文章于 2024-09-20 06:11:57 发布
最新推荐文章于 2024-09-20 06:11:57 发布
阅读量125 收藏
点赞数
分类专栏： # spring 文章标签： spring DI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43472934/article/details/107876790
版权

DI：Dependency Injection（依赖注入）
从字面上分析：
IoC：指将对象的创建权，反转给了Spring容器；
DI ：指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。
IoC和DI其实是同一个概念的不同角度描述，DI相对IoC而言，明确描述了“被注入对象依赖IoC容器配置依赖对象”。

所谓的依赖注入，就是属性不创建对象，通过配置文件的配置将Spring容器里面的对象注入给对应的属性

依赖注入有三种方式
1.setter注入（属性注入）
2.构造器注入
3.p命名空间注入

1、setter注入（属性注入）

setter注入,(也可以称之为属性注入)
使用setter注入：
1，使用bean元素的property子元素设置；
 a，简单类型值，直接使用value赋值；
 b，引用类型，使用ref赋值；
 c，集合类型，直接使用对应的集合类型元素即可。
2，spring通过属性的setter方法注入值；
3，在配置文件中配置的值都是string，spring可以自动的完成类型的转换

a、简单值和非集合普通对象注入

pojo

--Department 
package com.spring.pojo;

public class Department {
	private Integer id;
	private String name;

	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Department(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Department [id=" + id + ", name=" + name + "]";
	}

}

–Employee

package com.spring.pojo;

public class Employee {
	private Integer age;
	private String name;
	private Department dept;

	public Employee() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Employee(Integer age, String name, Department dept) {
		super();
		this.age = age;
		this.name = name;
		this.dept = dept;
	}

	public Integer getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

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

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}

	@Override
	public String toString() {
		return "Employee [age=" + age + ", name=" + name + ", dept=" + dept + "]";
	}
}

applicationContext.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 id="myDept" class="com.spring.pojo.Department">
		<!-- setter方法注入: 属性注入 
			<property name="" value="">
			name : 属性名称
			value : 基本数据类型+String类型的值注入
			ref : 引用类型(对象类型)的注入
			value 和ref 只能二选一
		-->
		<property name="id" value="1001"/>
		<property name="name" value="研发部"/>
	</bean>
	
	<bean id="emp" class="com.spring.pojo.Employee">
		<property name="age" value="12"/>
		<property name="name" value="张三"/>
		<property name="dept" ref="myDept"/>
	</bean>

</beans>

测试代码

	@Test
	public void testName() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Department dept = applicationContext.getBean("myDept", Department.class);
		Employee employee = applicationContext.getBean("emp",Employee.class);
		System.out.println(dept);
		System.out.println(employee);
	}

结果图

在这里插入图片描述

b、集合类型注入

pojo

package com.spring.pojo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class CollectionBean {
	private Set<String> set;
	private List<String> list;
	private String[] array;
	private Map<String, String> map;
	private Properties prop; // 读取本地 xxx.properties文件(本质就是一个Map集合)

	public Set<String> getSet() {
		return set;
	}

	public void setSet(Set<String> set) {
		this.set = set;
	}

	public List<String> getList() {
		return list;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	public String[] getArray() {
		return array;
	}

	public void setArray(String[] array) {
		this.array = array;
	}

	public Map<String, String> getMap() {
		return map;
	}

	public void setMap(Map<String, String> map) {
		this.map = map;
	}

	public Properties getProp() {
		return prop;
	}

	public void setProp(Properties prop) {
		this.prop = prop;
	}

	@Override
	public String toString() {
		return "CollectionBean [set=" + set + ", list=" + list + ", \narray=" + Arrays.toString(array) + ", map=" + map
				+ ", prop=" + prop + "]";
	}

}

applicationContext.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 id="collection" class="com.spring.pojo.CollectionBean">
		<!-- set集合 -->
		<property name="set">
			<set>
				<value>set1</value>
				<value>set1</value>
				<value>set2</value>
			</set>
		</property>
		<!-- list集合 -->
		<property name="list">
			<list>
				<value>list1</value>
				<value>list2</value>
				<value>list3</value>
			</list>
		</property>
		<!-- 数组array -->
		<property name="array">
			<array>
				<value>array1</value>
				<value>array2</value>
				<value>array3</value>
			</array>
		</property>
		<!-- 集合map -->
		<property name="map">
			<map>
				<entry key="name" value="zhangsan"/>
				<entry key="age" value="123"/>
			</map>
		</property>
		<!-- properties对象 -->
		<property name="prop">
			<props>
				<prop key="jdbc.username">root</prop>
				<prop key="jdbc.password">123456</prop>
			</props>
		</property>
	</bean>
</beans>

测试代码

@Test
	public void testName() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		//getBean(clazz);该方法必须保证spring容器中只有一个CollectionBean类型的对象
		CollectionBean bean = applicationContext.getBean(CollectionBean.class);
		System.out.println(bean);
	}

测试结果

在这里插入图片描述

2、构造器类型

pojo

跟上面Department和Employee一致

applicationContext.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 id="my_dept" class="com.spring.pojo.Department">
		<!-- 
		   1.index:在构造器中的参数索引(从0开始)
		   2.type:在构造器中的参数的类型
		   3.name:在构造器中按照构造器的参数名字设置值 
           4.type:参数类型，默认自动匹配
           5.value:值类型注入（String,各种数据类型）
           6.ref:引用类型注入
	 -->
		<constructor-arg index="0" name="id" type="java.lang.Integer" value="1002"/>
		<constructor-arg index="1" name="name" type="java.lang.String" value="策划部"/>
	</bean>

	<bean id="emp" class="com.spring.pojo.Employee">
		<constructor-arg index="0" name="age" type="java.lang.Integer" value="23"/>
		<constructor-arg index="1" name="name" type="java.lang.String" value="王五"/>
		<constructor-arg index="2" name="dept" type="com.spring.pojo.Department" ref="my_dept"/>
	</bean>
</beans>

测试代码

	@Test
	public void testName() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Department dept = applicationContext.getBean("my_dept", Department.class);
		Employee employee = applicationContext.getBean("emp",Employee.class);
		System.out.println(dept);
		System.out.println(employee);
	}

测试结果

在这里插入图片描述

3、p命名空间注入

pojo

跟上面Department和Employee一致

applicationContext.xml

使用p命名空间注入先在约束上面引入 p标签xmlns:p="http://www.springframework.org/schema/p"
底层还是使用set方法注入 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="my_dept" class="com.spring.pojo.Department"
		p:id="1003"
		p:name="销售部"
	/>
	<!--
		使用p命名空间规则：当属性为String或基本数据类型，则使用p:属性名=值
					      当属性为对象时，则使用p:属性名-ref=对象bean的id
	  -->
	<bean id="emp" class="com.spring.pojo.Employee"
		p:age="30"
		p:name="武则天"
		p:dept-ref="my_dept"
	/>
	
</beans>

测试代码

@Test
	public void testName() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Department dept = applicationContext.getBean("my_dept", Department.class);
		Employee employee = applicationContext.getBean("emp",Employee.class);
		System.out.println(dept);
		System.out.println(employee);
	}

测试结果

在这里插入图片描述

搞钱自律
关注
专栏目录
Spring核心功能之依赖注入(DI)
行者无疆的博客
03-20 986
1 Spring DI（依赖注入）之XML配置 我们知道，Spring 的核心功能就是控制反转和依赖注入。前面介绍了控制反转，那依赖注入是什么呢？ 1.1概念介绍 上面是我们之前对于依赖注入的一个通俗解释。这里再着重强调一下 IOC 控制反转与 DI 依赖注入的关系： IOC 控制反转是将对象实例化的动作交由了 Spring 框架， 它的作用是降低了程序的耦合，不需要我们手动的创建对象，但是程序的耦合性还是存在。 对象中肯定会有一些其余对象的引用，那么这种引用就称为对象的依赖，而 DI 依赖注入其实是 I
Spring依赖注入DI.zip
08-08
下面我们将深入探讨Spring依赖注入的概念、工作原理以及如何在实践中应用。 1. **依赖注入概念**： - 依赖：一个类对另一个类的使用称为依赖。 - 注入：将依赖的对象传递给需要它的类，而不是由类自己去创建或...
Spring依赖注入DI
01-11 1133
DI是Dependency Injection的缩写，依赖注入的意思，依赖了Spring容器，进行set注入，这里还是以一个例子进行阐述首先我们创建两个实体类 然后是配置文件，核心 然后就是测试了
Spring--DI依赖注入详解
tq02的博客
03-29 1371
三种详细注入方式，构造注入、Setter注入、属性注入，以及@Autowired和@Resource两者区别
Spring 依赖注入详解
swadian2008的博客
10-25 4807
/ 依赖关系，指的就是对象之间的相互协作关系依赖注入（DI）是一个过程，在这个过程中，对象仅通过构造函数参数、工厂方法的参数或在对象被实例化后通过属性设置来定义它们的依赖项（即与该对象一起工作的其他对象）。然后，容器在创建 bean 时注入这些依赖项。这个过程基本上是与对象直接通过构造类或等机制来控制其依赖项的实例化或位置是相反的，因此得名控制反转。// 对象不直接创建自己，而是通过 Spring 容器创建，那么 Spring 容器是如何创建对象的？
也谈Spring之依赖注入DI/控制反转IOC
春风化雨
11-11 859
首先提问： 什么是 Spring IOC 容器？         Spring 框架的核心是 Spring 容器。容器创建对象，将它们装配在一起，配置它们并管理它们的完整生命周期。Spring 容器使用依赖注入来管理组成应用程序的组件。容器通过读取提供的配置元数据来接收对象进行实例化，配置和组装的指令。该元数据可以通过 XML，Java 注解或 Java 代码提供。 然而，依赖注入到底是什...
Spring DI简介及依赖注入方式和依赖注入类型
qq_53317005的博客
04-30 5530
Spring DI简介及依赖注入方式和依赖注入类型
Spring框架依赖注入DI顺序
weixin_38094135的博客
11-25 2454
Spring 依赖注入的顺序   1. 构造器方法注入   2. 字段注入   3. 属性或普通方法注入 注意：后面的注入会覆盖前面的值 测试代码 package com.jade.spring.context.annotation7; import org.springframework.context.annotation.Bean; import org.springframew...
Spring框架|依赖注入DI
匿名攻城狮
01-27 975
文章目录一、依赖注入介绍二、依赖关系的管理三、能够注入的数据四、注入的三种方式 一、依赖注入介绍 依赖注入(Dependency Injection，简称DI) 是 Spring 框架核心IoC的具体实现。 依赖注入是控制反转最常用的方式，通过控制反转可以减低计算机代码之间的耦合度。 通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依...
Spring 依赖注入
weixin_46598480的博客
04-30 816
Spring 依赖注入 一、依赖注入的概念 依赖注入(DI)与控制反转(IoC)的含义相同，只不过这两个称呼是从两个角度描述的，同一个概念，对于一个Spring的初学者来说，这两种称呼很难理解，下面我们将通过简单的语言来描述这两个概念。 当某个Java对象（调用者）需要调用另一个Java对象（被调用者，即依赖对象）时，在传统模式下，调用者通常会采用"new被调用者"的代码方式来创建对象，这种方式会导致调用者与被调用者之间的耦合性增加，不利于后期项目的升级和维护。 在使用Spring框架之后，对象的思念不再由
深入理解 Spring IoC 与 DI：控制反转与依赖注入解析
weixin_71246590的博客
08-15 930
在接触 Spring 框架之前，通常我们会在 main 方法或其他业务逻辑中手动 new 对象，然后调用这些对象的方法来完成任务。手动创建对象的方式意味着我们自己掌握了对象的控制权。 然而，在 Spring 中，我们不再直接在代码中手动创建对象，而是将对象的创建、管理、依赖注入等职责交给了 Spring 容器。Spring 框架通过 IoC（控制反转）和 DI（依赖注入）来实现这一点。
JavaEE spring 依赖注入DI入门案例
10-13
JavaEE spring 依赖注入DI入门案例
spring依赖注入知识点分享
08-25
Spring 的 DI 依赖注入有两种方式： setter 注入和构造注入。 setter 注入 setter 注入是将属性值赋给对象的 setter 方法。例如： ```xml <bean id="student" class="com.abc.di01.Student"> 张三"/> ``` ...
java Spring DI依赖注入.rar
01-30
在`chapter8`这个文件夹中，可能包含了关于Spring依赖注入的深入讲解，包括如何配置和使用，以及在实际项目中的应用示例。学习这部分内容可以帮助你理解如何利用Spring的DI特性来构建更优雅、更易于维护的Java应用。...
【SpringCloud】Spring Cloud 开发环境搭建与基础工程构建
Hsusan的博客
09-15 1800
Oracle从JDK9开始每半年发布⼀个新版本, 新版本发布后, ⽼版本就不再进⾏维护. 但是会有⼏个⻓期维护的版本.⽬前⻓期维护的版本有: JDK8, JDK11, JDK17, JDK21在 JDK版本的选择上，尽量选择⻓期维护的版本.为什么选择JDK17?
Spring Session
2401_84881237的博客
09-18 453
它把 servlet 容器实现的 httpSession 替换为 spring-session ，Session 信息存储在 Redis 或其它数据库中统一管理，解决了 session 共享的问题。Spring Session 是 Spring 家族中的一个子项目，Spring Session 提供了用于管理用户会话信息的 API 和实现。在 Web 项目开发中，Session 会话管理是一个很重要的部分，用于存储与记录用户的状态或相关的数据。
SpringBoot中基于Mybatis-Plus多表联查（无xml，通过注解实现）
weixin_45653328的博客111
09-19 790
主要是第三个@Result，通过javaType=List.class，many=@Many来指定这个Result的属性（通过CourseMapper中的方法来查询这个list集合）注意：要写方法名的全名称，包名+类名+方法名。@Results注解：有个id属性，可以理解为定义了一个方法，可以通过id引用，引用方式：ResultMap（“”）。首先，外部查询出这个学生对象，在@Results注解内，表示返回的实际结果集，学生id，学生name，课程Course对象的list集合。下面我们就学生来解决。
高级java每日一道面试题-2024年9月19日-框架篇[Mybatis篇]-说一下mybatis的一级缓存和二级缓存?
最新发布
qq_43071699的博客
09-20 1135
一级缓存是默认开启的，基于`SqlSession`级别的缓存，适用于单个`SqlSession`内的多次查询。 二级缓存是基于`namespace`级别的缓存，需要显式开启，可以在多个`SqlSession`之间共享，适用于跨`SqlSession`的查询。在面试中，能够清晰地解释MyBatis的一级缓存和二级缓存的工作原理、配置方式以及各自的优缺点，将有助于展示你对MyBatis框架的理解和技术深度。此外，实际项目经验也是面试官非常看重的部分，因此准备好相关的项目案例来说明你的实践经历也是非常有帮助的。
spring与springmvc整合
Lxn2zh的博客
09-19 848
原文链接http://zhhll.icu/2021/02/12/%E6%A1%86%E6%9E%B6/springmvc/spring%E4%B8%8Espringmvc%E6%95%B4%E5%90%88/ spring与springmvc整合 在项目中使用springmvc的时候，由于spring和springmvc是同源的，有时候大家会把所有的配置都扔到springmvc的配置文件中，而不去区分spring和springmvc的配置，而我习惯于把两个配置拆分开来，spring来配置数据源、事务以及和其
深入理解Spring依赖注入
"本文主要介绍Spring框架中的依赖注入(Dependency Injection, DI)概念，以及如何通过XML配置实现DI的两种方式：设值注入和构造注入。" 在Spring框架中，依赖注入是核心特性之一，它有助于降低组件之间的耦合度，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值