Spring DI - 依赖注入
1.IOC(DI) - 控制反转(依赖注入)
所谓的IOC称之为控制反转，简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不再需要关注对象的创建和生命周期的管理，而是在需要时由Spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对对象的属性进行设置，这个过称之为依赖注入,也即DI。
2.set方法注入
通常的javabean属性都会私有化，而对外暴露setXxx()getXxx()方法，此时spring可以通过这样的setXxx()方法将属性的值注入对象。
a.Spring内置的可直接注入类型的注入：
package cn.tedu.beans; import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set; public class Hero { private int id;
private String name;
private List<String> jobs;
private Set<String> set;
private Map<String,String> map;
private Properties prop;
private Cat cat;
private Dog dog;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getJobs() {
return jobs;
}
public void setJobs(List<String> jobs) {
this.jobs = jobs;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
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;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
@Override
public String toString() {
return "Hero [id=" + id + ", name=" + name + ", jobs=" + jobs
+ ", set=" + set + ", map=" + map + ", prop=" + prop + ", cat="
+ cat + ", dog=" + dog + "]";
} }
<?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-3.2.xsd"
default-lazy-init="true"
> <bean id="hero" class="cn.tedu.beans.Hero">
<property name="id" value="123"></property>
<property name="name" value="亚瑟"></property>
<property name="jobs">
<list>
<value>上单</value>
<value>中弹</value>
<value>辅助</value>
<value>打野</value>
</list>
</property>
<property name="set">
<set>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
<value>ddd</value>
</set>
</property>
<property name="map">
<map>
<entry key="addr" value="王者荣耀"></entry>
<entry key="addr" value="英雄联盟"></entry>
<entry key="skill" value="风火轮"></entry>
<entry key="age" value="19"></entry>
</map>
</property>
<property name="prop">
<props>
<prop key="k1">v1</prop>
<prop key="k2">v1</prop>
<prop key="k3">v1</prop>
<prop key="k4">v1</prop>
</props>
</property> </bean> </beans>
@Test
/**
* SpringDI set方式注入 - Spring内置的可直接注入类型的注入
*/
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Hero hero = (Hero) context.getBean("hero");
System.out.println(hero);
}
Hero [id=123, name=亚瑟, jobs=[上单, 中弹, 辅助, 打野],
set=[aaa, bbb, ccc, ddd],
map={addr=英雄联盟, skill=风火轮, age=19},
prop={k4=v1, k3=v1, k2=v1, k1=v1},
cat=null, dog=null]
b.非Spring内置的可以直接注入类型的注入：
package cn.tedu.beans; import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set; public class Hero { private int id;
private String name;
private List<String> jobs;
private Set<String> set;
private Map<String,String> map;
private Properties prop;
private Cat cat;
private Dog dog;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getJobs() {
return jobs;
}
public void setJobs(List<String> jobs) {
this.jobs = jobs;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
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;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
@Override
public String toString() {
return "Hero [id=" + id + ", name=" + name + ", jobs=" + jobs
+ ", set=" + set + ", map=" + map + ", prop=" + prop + ", cat="
+ cat + ", dog=" + dog + "]";
} }
<?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-3.2.xsd"
default-lazy-init="true"
> <bean id="hero" class="cn.tedu.beans.Hero">
<property name="id" value="123"></property>
<property name="name" value="亚瑟"></property>
<property name="jobs">
<list>
<value>上单</value>
<value>中弹</value>
<value>辅助</value>
<value>打野</value>
</list>
</property>
<property name="set">
<set>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
<value>ddd</value>
</set>
</property>
<property name="map">
<map>
<entry key="addr" value="王者荣耀"></entry>
<entry key="addr" value="英雄联盟"></entry>
<entry key="skill" value="风火轮"></entry>
<entry key="age" value="19"></entry>
</map>
</property>
<property name="prop">
<props>
<prop key="k1">v1</prop>
<prop key="k2">v1</prop>
<prop key="k3">v1</prop>
<prop key="k4">v1</prop>
</props>
</property>
<property name="dog" ref="dog"></property>
<property name="cat" ref="cat"></property>
</bean> <bean id="dog" class="cn.tedu.beans.Dog"></bean>
<bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>
@Test
/**
* SpringDI set方式注入 - 非Spring内置的可以直接注入类型的注入
*/
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Hero hero = (Hero) context.getBean("hero");
System.out.println(hero);
}
结果：
Hero [id=123, name=亚瑟, jobs=[上单, 中弹, 辅助, 打野],
set=[aaa, bbb, ccc, ddd],
map={addr=英雄联盟, skill=风火轮, age=19},
prop={k4=v1, k3=v1, k2=v1, k1=v1},
cat=cn.tedu.beans.Cat@4929b0e1,
dog=cn.tedu.beans.Dog@501ba94d]
3.基于构造方法的注入
对象属性设置的另一种方式是在对象创建的过程中通过构造方法传入并设置对象的属性。
spring也可以通过这样的构造方法实现属性的注入。
package cn.tedu.beans;
public class Student {
private int id;
private String name;
private Dog dog;
public Student(int id, String name, Dog dog) {
super();
this.id = id;
this.name = name;
this.dog = dog;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", dog=" + dog + "]";
}
}
<?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-3.2.xsd"
default-lazy-init="true"
> <bean id="student" class="cn.tedu.beans.Student">
<!--
index:为构造方法的第几个参数 进行配置
name:为构造方法的哪个名字的参数进行配置
**index 和 name 可以配置任何一个或同时配置 但要求一旦配置必须正确
**推荐优先使用index方式配置 防止没有源码造成name无法匹配到对应参数
type:该构造方法参数的类型
value:该构造方法参数的值 ,用来指定基本值
ref:该构造方法参数的值,用来指定引用其他bean的值
-->
<constructor-arg index="0" name="id" value="999"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="张无忌"></constructor-arg>
<constructor-arg name="dog" ref="dog"></constructor-arg>
</bean> <bean id="dog" class="cn.tedu.beans.Dog"></bean>
</beans>
@Test
/**
* SpringDI 构造方法方式属性注入
*/
public void test3(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
}
运行结果：
Student [id=999, name=张无忌, dog=cn.tedu.beans.Dog@249c2715]
4.自动装配
在Spring的set方式实现的注入过程中，支持自动装配机制，所谓自动装配机制，会根据要设置的javabean属性的名字 或 类型 到spring中自动寻找对应id 或 类型的<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-3.2.xsd"
> <!--
autowire设定自动装配：
byName:根据javabean中需要注入的属性的名字 ，在spring容器中找对应id的<bean>将该<bean>的对象复制给 当前的属性
byType:根据javabean中需要注入的属性的类型，在spring容器中找对应class类型的<bean>将该<bean>的对象复制给 当前的属性
**byType方式 根据类型进行匹配，可能匹配到多个<bean>,此时会抛出异常。而byName是通过id来寻找<bean>，id没有重复，不会有这方面的问题，所以推荐使用byName方式
--> <bean id="teacher" class="cn.tedu.beans.Teacher" autowire="byName"></bean>
<bean id="dog" class="cn.tedu.beans.Dog"></bean>
<bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>
为全局配置自动装配：
package cn.tedu.beans;
public class Teacher {
private Dog dog;
private Cat cat;
public void setDog(Dog dog) {
this.dog = dog;
}
public void setCat(Cat cat) {
this.cat = cat;
}
@Override
public String toString() {
return "Teacher [dog=" + dog + ", cat=" + cat + "]";
}
}
<?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-3.2.xsd"
default-autowire="byName"
> <!--
autowire设定自动装配：
byName:根据javabean中需要注入的属性的名字 ，在spring容器中找对应id的<bean>将该<bean>的对象复制给 当前的属性
byType:根据javabean中需要注入的属性的类型，在spring容器中找对应class类型的<bean>将该<bean>的对象复制给 当前的属性
**byType方式 根据类型进行匹配，可能匹配到多个<bean>,此时会抛出异常。而byName是通过id来寻找<bean>，id没有重复，不会有这方面的问题，所以推荐使用byName方式
--> <bean id="teacher" class="cn.tedu.beans.Teacher"></bean>
<bean id="dog" class="cn.tedu.beans.Dog"></bean>
<bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>
@Test
/**
* SpringDI 自动装配
*/
public void test4(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Teacher teacher = (Teacher) context.getBean("teacher");
System.out.println(teacher);
}
运行结果：
Teacher [dog=cn.tedu.beans.Dog@564ac216, cat=cn.tedu.beans.Cat@460c5e9c]
Spring DI - 依赖注入的更多相关文章
- 手写Spring DI依赖注入，嘿，你的益达！
目录 提前实例化单例Bean DI分析 DI的实现 构造参数依赖 一:定义分析 二:定义一个类BeanReference 三:BeanDefinition接口及其实现类 四:DefaultBeanFa ...
- spring Di依赖注入
依赖注入有两种方式 通过 get set 方法 Person.java package cn.itcast.spring.sh.di.set; import java.util.List; imp ...
- 初识Spring框架实现IOC和DI(依赖注入)
学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的, IoC是 ...
- Spring的依赖注入（DI）三种方式
Spring依赖注入(DI)的三种方式,分别为: 1． 接口注入 2． Setter方法注入 3． 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个 ...
- Spring详解（三）------DI依赖注入
上一篇博客我们主要讲解了IOC控制反转,也就是说IOC 让程序员不在关注怎么去创建对象,而是关注与对象创建之后的操作,把对象的创建.初始化.销毁等工作交给spring容器来做.那么创建对象的时候,有可 ...
- Spring：（二）DI依赖注入方式
DI 依赖注入 DI(Dependency Injection)依赖注入,说简单一点就将类里面的属性在创建类的过程中给属性赋值,即将对象依赖属性(简单值,集合,对象)通过配置设值给该对象. 属性注入的 ...
- 一) Spring 介绍、IOC控制反转思想与DI依赖注入
一.spring介绍1.IOC反转控制思想(Inversion of Control)与DI依赖注入(Dependency Injection)2.AOP面向切面的编程思想与动态代理3.作用:项目的粘 ...
- 【Spring】Spring之依赖注入（DI）传递参数的方式
DI依赖注入传入参数的方式,这里介绍了基本数据类型,集合,符合数据类型的传递(String类型比较特殊,其传递值和基本数据类型的方法一致) 注入基本数据类型和String类型 通过setter方法注入 ...
- Spring-初识Spring框架-IOC控制反转（DI依赖注入）
---恢复内容开始--- IOC :控制反转 (DI:依赖注入)使用ioc模式开发 实体类必须有无参构造方法1.搭建Spring环境下载jarhttp://maven.springframework. ...
随机推荐
- Java——多线程常见面试题
body, table{font-family: 微软雅黑} table{border-collapse: collapse; border: solid gray; border-width: 2p ...
- 添加MyEclipse WebSphere Portal Server支持（二）
MyEclipse个人授权 折扣低至冰点!立即开抢>> [MyEclipse最新版下载] 三.支持WebSphere Portal部署 当您为WebSphere Portal 7.0或8. ...
- web.xml的schema文件
2.3和2.4: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE web-app PUBLI ...
- session进行增删改查操作
一般将针对数据库的操作放在事物里面, 开始事物:session.beginTransaction(); 获取事物:session.getTransaction(); 提交事物:transaction. ...
- mysql的字符拼接
在Mysql 数据库中存在两种字符串连接操作.具体操作如下 一. 语法: 1. CONCAT(string1,string2,…) 说明 : string1,string2代表字符串,concat ...
- eclipse集成svn后总是弹出 Password Required问题解决方法
最近在集成svn后,在打开eclipse后总是一遍遍的弹出 Password Required,即使输入正确的用户名以及密码也会弹出,最后发现是eclipse的Network Connections ...
- anu - component
import { extend, isFn, options, clearArray, noop } from "./util"; import { CurrentOwner } ...
- jq 的onchange事件
按商品类型显示:<select onchange="location.href='__ACTION__/type_id/'+this.value;"> <o ...
- WebGL编程指南案例解析之平移和旋转的math库实现
这里说的math库实现,指的是,通过一般的加减乘除(角度计算)来更新坐标值. 因为涉及到坐标的变化,所以这里都是基于对顶点着色器的修改 平移: var vShader = ` attribute ve ...
- CSS 网格布局学习
转自:https://blog.jirengu.com/?p=990 CSS网格布局(又名“网格”)是一个二维的基于网格的布局系统,其目的只在于完全改变我们设计基于网格的用户界面的方式. CSS一直用 ...