Spring依赖注入的三种方式

最新推荐文章于 2020-12-07 12:46:01 发布
最新推荐文章于 2020-12-07 12:46:01 发布
阅读量472 收藏 4
点赞数
分类专栏： Spring 文章标签： Spring 依赖注入方式 Spring依赖注入方式 Spring依赖注入方法 依赖注入方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37805065/article/details/102577282
版权

第一种 使用构造器注入

使用构造器注入时，类必须要有构造方法，成员变量的setter方法不需要。

User类

public class User {
	private String name;
	private Integer age;
	//构造方法
	public User() {
	}
	public User(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
}

beans.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" default-lazy-init="true">
 	<!-- 使用构造方法注入 -->
 	<bean id="user" class="demo.User">
 		<constructor-arg index="0" value="Jack"></constructor-arg>
 		<constructor-arg index="1" value="20"></constructor-arg>
 	</bean>
 </beans>

Test类测试

public class Test {
	public static void main(String[] args) {
		//1 实例化Spring工厂
		ApplicationContext act=new ClassPathXmlApplicationContext("beans3.xml");
		//获取User对象
		User user=(User) act.getBean("user");
		System.out.println(user.toString());
	}
}

测试结果

十月 15, 2019 11:49:06 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7eda2dbb: startup date [Tue Oct 15 23:49:06 CST 2019]; root of context hierarchy
十月 15, 2019 11:49:06 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans3.xml]
User [name=Jack, age=20]

 

第二种 使用属性setter方法注入

使用属性setter方法注入时，类的成员变量必须要有setter方法。

Demo类

public class Demo {
	private String str;//基本类型
	private Integer num;
	private String[] strs;//数组
	private Integer[] nums;
	private Double db;
	private User user;//引用类型
	private List<String> list;//List
	private Map<String,Integer> map;//Map
	private Set<String> set;//Set
	private Properties properties;//Properties
	public void setStr(String str) {
		this.str = str;
	}
	public void setNum(Integer num) {
		this.num = num;
	}
	public void setStrs(String[] strs) {
		this.strs = strs;
	}
	public void setNums(Integer[] nums) {
		this.nums = nums;
	}
	public void setDb(Double db) {
		this.db = db;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public void setList(List<String> list) {
		this.list = list;
	}
	public void setMap(Map<String, Integer> map) {
		this.map = map;
	}
	public void setSet(Set<String> set) {
		this.set = set;
	}
	public void setProperties(Properties properties) {
		this.properties = properties;
	}
	@Override
	public String toString() {
		return "Demo [str=" + str + ", num=" + num + ", strs=" + Arrays.toString(strs) + ", nums=" + nums + ", db=" + db
				+ ", user=" + user + ", list=" + list + ", map=" + map + ", set=" + set + ", properties=" + properties
				+ "]";
	}
}

beans.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" default-lazy-init="true">
 	<!-- 使用构造方法注入 -->
 	<bean id="user" class="demo.User">
 		<constructor-arg index="0" value="Jack"></constructor-arg>
 		<constructor-arg index="1" value="20"></constructor-arg>
 	</bean>
 	
 	<!-- 使用属性setter方法注入 -->
 	<bean id="demo" class="demo.Demo">
 		<property name="str" value="字符串"></property>
 		<property name="num" value="123"></property>
 		<!-- 数组依赖注入 -->
 		<property name="strs">
 			<array>
 				<value>字符串数组元素1</value>
 				<value>字符串数组元素2</value>
 				<value>字符串数组元素3</value>
 			</array>
 		</property>
 		<property name="nums">
 			<array>
 				<value>10</value>
 				<value>20</value>
 				<value>30</value>
 			</array>
 		</property>
 		<property name="db" value="123.3"></property>
 		<!-- 这里的user注入依赖构造器的user -->
 		<property name="user" ref="user"></property>
 		<!-- 对List注入注意的地方 -->
 		<property name="list">
 			<list>
 				<value>list1</value>
 				<value>list2</value>
 			</list>
 		</property>
 		<!-- 对Map注入注意的地方 -->
 		<property name="map">
 			<map>
 				<entry key="map1" value="1"></entry>
 				<entry key="map2" value="2"></entry>
 				<entry key="map3" value="3"></entry>
 			</map>
 		</property>
 		<!-- 对Set注入注意的地方 -->
 		<property name="set">
 			<set>
 				<value>set1</value>
 				<value>set2</value>
 				<value>set3</value>
 			</set>
 		</property>
 		<!-- 对Properties注入注意的地方 -->
 		<property name="properties">
 			<props>
 				<prop key="key1">prop1</prop>
 				<prop key="key2">prop2</prop>
 			</props>
 		</property>
 	</bean>
 </beans>

Test类测试

public class Test {
	public static void main(String[] args) {
		//1 实例化Spring工厂
		ApplicationContext act=new ClassPathXmlApplicationContext("beans3.xml");
		//获取Demo对象
		Demo demo=(Demo) act.getBean("demo");
		System.out.println(demo.toString());
	}
}

测试结果

十月 16, 2019 12:22:00 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7eda2dbb: startup date [Wed Oct 16 00:22:00 CST 2019]; root of context hierarchy
十月 16, 2019 12:22:00 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans3.xml]
Demo [str=字符串, num=123, strs=[字符串数组元素1, 字符串数组元素2, 字符串数组元素3], nums=[Ljava.lang.Integer;@20398b7c, db=123.3, user=User [name=Jack, age=20], list=[list1, list2], map={map1=1, map2=2, map3=3}, set=[set1, set2, set3], properties={key2=prop2, key1=prop1}]

 

第三种 使用Field注入（用于注解方式）

使用Field注入时，需要导入spring-aop-4.1.7.RELEASE.jar包，一定要喝咖啡（add to Build path）。

beans.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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 	<!-- 开启自动扫描 -->
 	<context:component-scan base-package="com"></context:component-scan>
 	<!-- 这里指对com下的包的类进行扫描 -->
 </beans>

beanx.xml配置与前两个依赖注入的方式不一样。

四个类注解方式

@Service用于标注业务层组件

@Controller用于标注控制层组件（如struts中的 action）

@Repository用于标注数据访问组件，即DAO组件

@Component泛 指组件，当组件不好归类的时候，可以使用这个注解进行标注

两个类的成员注解方式

@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存 在，如果允许null值，可以设置它required属性为false。 如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。

如下： @Autowired @Qualifier("personDaoBean")

            private PersonDao personDao;

@Resource注解和@Autowired一样，也可以标注在字段或属性的 setter方法上，但它默认按名称装配。 名称可以通过@Resource的name属性指定，如果没有指定name属性， 当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对 象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称 寻找依赖对象。

@Resource(name=“personDaoBean”)

private PersonDao personDao;//用于字段上

注意：如果没有指定name属性，并且按照默认的名称仍然找不到依赖 对象时， @Resource注解会回退到按类型装配。但一旦指定了name属 性，就只能按名称装配了。

@Autowired使用比较多

1 @Autowired可以允许非空

2 @Resource来源于Jdk下的javax.annotation包，不属于Spring，@Autowired解耦合。

 

对UserDao注解

package com.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
	public UserDao() {
		System.out.println("UserDao()......");
	}

	public void testDao() {
		System.out.println("执行testDao()方法。。。。。。");
	}
}

对UserService注解

package com.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.dao.UserDao;
@Service
public class UserService {
	@Autowired(required = false)//允许位null
	private UserDao userdao;
	public UserService() {
		System.out.println("UserService()......");
	}
	public void testService() {
		System.out.println("执行testService()方法。。。。。。");
		userdao.testDao();
	}
}

对UserServlet注解

package com.servlet;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.service.UserService;
@Controller
public class UserServlet {
	@Autowired(required = false)//允许位null
	private UserService userService;
	public UserServlet() {
		System.out.println("UserServlet()......");
	}
	public void testServlet() {
		System.out.println("执行testServlet()方法。。。。。。");
		userService.testService();
	}
}

Test类测试

public class Test {

	public static void main(String[] args) {
		//实例化Spring工厂
		ApplicationContext act=new ClassPathXmlApplicationContext("beans4.xml");
		UserServlet servlet=(UserServlet) act.getBean("userServlet");
		servlet.testServlet();
	}

}

测试结果

十月 16, 2019 12:56:55 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@76fb509a: startup date [Wed Oct 16 00:56:55 CST 2019]; root of context hierarchy
十月 16, 2019 12:56:55 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans4.xml]
UserDao()......
UserService()......
UserServlet()......
执行testServlet()方法。。。。。。
执行testService()方法。。。。。。
执行testDao()方法。。。。。。

通过注解方式进行依赖注入，可以省去写beans.xml的bean标签，大大提高开发效率以及减少创建和编辑beans.xml文件的时间。

 

 

 

噩先生
关注
专栏目录
Spring依赖注入的三种方法
yezongzhen的博客
05-15 230
Spring 管理java bean主要以依赖注入(控制反转IOC)的方式进行管理。其中有三种方式：属性注入、构造函数、工厂方法(非静态和静态，主要是以方法是否静态进行注入) People类： package com.xiaowu.entity; public class People { int id; String name; int age; public People() { super(); // TODO Auto-generated constructor
spring依赖注入三种方式 测试源码
05-06
通过阅读和理解这些源码，你可以更深入地了解Spring依赖注入的工作原理及其在项目中的具体使用。 在进行依赖注入时，Spring使用BeanFactory或ApplicationContext作为容器，负责创建、管理和装配Bean。容器读取配置...
Spring系列之依赖注入的三种方式
热门推荐
ZHAOJING1234567的博客
05-22 1万+
目录 一、依赖注入方式 1.使用属性的setXXX方法注入 2.构造函数注入 （1）按类型匹配入参type （2）按索引匹配入参index （3）联合使用类型和索引匹配入参[type和index一起使用] 有时需要联合使用type和index才能确定匹配项和构造函数入参的对应关系，看下面的代码。 二、依赖注入的本质就是装配——自动装配：spring可以使用xml和注解来进行...
spring 依赖注入的三种方式
qq_33732195的博客
12-07 2197
@Autowired：构造器，参数，方法，属性；都是从容器中获取参数组件的值； 1）、set方法注入； 2）、构造器注入； 3）、作为Bean方法的参数注入； 例子：Boss 注入Car类 第一种、set方式注入 //Car类 package com.spring.bean; @Component public class Car { public Car() { System.out.println("car...constructor"); } } //Boss类 package com.sp
Spring依赖注入的三种方式小结
08-29
Spring依赖注入的三种方式小结 Spring框架是当今最流行的JavaEE开发框架之一，它提供了强大的依赖注入（Dependency Injection，简称DI）功能。依赖注入是Spring框架的核心特性之一，它使得应用程序更加灵活、可维护...
Spring 依赖注入的几种方式详解
08-31
在Spring中，依赖注入可以通过XML配置文件实现，本文将重点介绍两种常见的注入方式：Set注入和构造器注入。 1. Set注入 Set注入是最常见的注入方式，适用于对象没有默认构造函数或构造函数不接受参数的情况。首先，...
Spring依赖注入的两种方式（根据实例详解）
08-30
Spring依赖注入的两种方式详解 在Spring框架中，依赖注入（Dependency Injection）是指框架为对象提供依赖项，而不是由对象创建它们的依赖项。这种技术使得对象之间的耦合度降低，提高了系统的灵活性和可维护性。...
Spring 依赖注入3种方式
cc1763122710的博客
03-19 193
Spring 依赖注入3种方式 set注入：通过setXxx（）赋值，默认使用的是set方法；依赖注入底层是通过反射实现的。 2.构造器注入：通过构造方法赋值 <constructor-arg value="java" index="0" name="courseName" type="String"> 需要注意：如果<constructor-arg>和构造方法不一致...
Spring框架依赖注入实战：三种方式详解
以上就是Spring框架中的三种依赖注入方式。每种方式都有其适用场景，开发者可以根据实际情况选择合适的方法。理解并熟练掌握这些注入方式，能帮助你更好地利用Spring框架构建可扩展和可维护的系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值