上1篇博文中，我们学习了springIOC,又称spring控制反转，行将对象的创建烧毁等操作交给spring容器来处理，今天学习spring的依赖注入，那末甚么是依赖注入，说的通俗1点，就是对属性赋值，也就是说我们利用spring来为我们的类中包括的属性来进行赋值，想一想之前我们是通过这样的方式来编写代码的：接口
对象 = new 接口实现类(); 再看看我们之前是怎样给属性赋值的
1.通过set方法
2.通过构造方法
今天我们来实现通过spring依赖注入来为类中的变量赋值。首先我新建1个Student.java和1个Teacher.java类，并且提供get和set方法
package com.test.di;
public class Student {
private String name;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
package com.test.di;
public class Teacher {
private String teacherName;
private Student student;
public String getTeacherName() {
return teacherName;
}
public void setTeacherName(String teacherName) {
this.teacherName = teacherName;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
然后，我们在spring配置文件中来为这些属性赋值：
<?xml version="1.0" encoding="UTF⑻"?>
<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⑵.5.xsd">
<bean id="student" class="com.test.di.Student">
<property name="name" value="haha"></property>
<property name="id" value="12"></property>
</bean>
<bean id="teacher" class="com.test.di.Teacher">
<property name="teacherName" value="teacherWang"></property>
<property name="student" ref="student"></property>
</bean>
</beans>
根据配置文件，我们可以发现，在bean中有个property的配置，其中name就是我要为那个属性赋值，对属性的值，这里有两种情况：
1.如果是基本类型，直接在value中写上需要赋的值便可
2.如果是援用类型，那末需要使用ref来援用对应的类，对这个栗子，即student这里ref所援用的student就是第1个student的bean中配置的id。
接下来，我编写1个测试类，来测试是不是成功的为属性注入对应的值DiTest.java
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/test/di/applicationContext.xml");
Teacher teacher = (Teacher) applicationContext.getBean("teacher");
Student student = teacher.getStudent();
System.out.println(teacher.getTeacherName());
System.out.println("studentName :"+student.getName()+"==studentId :"+student.getId());
此时打印结果以下:
teacherWang
studentName :haha==studentId :12
发现这个时候spring容器已为我们的属性赋值成功了。但是我们却并没有像之前那样调用set方法，或是构造方法，这里有1点需要说明，就是我们虽然没有自己调用set方法来为属性赋值，但是spring还是会掉用set方法，所以我们如果想对某1个属性进行依赖注入的话，那末我们就需要对该属性写上set方法。
下面我们为teacher注入1些集合，首先需要做的就是在Teacher.java中声明list,set,map这3个属性，然后为这些属性生成set方法，新增属性以下：
private List<String>lists;
private Set<Integer>sets;
private Map<Integer,String>maps;
然后再spring的配置文件中这样为其赋值：
<bean id="teacher" class="com.test.di.Teacher">
<property name="teacherName" value="teacherWang"></property>
<property name="student" ref="student"></property>
<property name="lists">
<list>
<value>one</value>
<value>two</value>
<value>three</value>
</list>
</property>
<property name="maps">
<map>
<entry key="1" value="firstMap"></entry>
<entry key="2" value="secondMap"></entry>
<entry key="3" value="thirdMap"></entry>
</map>
</property>
<property name="sets">
<set>
<value>111</value>
<value>222</value>
<value>333</value>
</set>
</property>
</bean>
可以发现这个配置文件写起来和普通的集合对象的情势是很相似的，这里我们都是用的基本的类型来作为集合的泛型，如果使用的是援用类型，这里的配置都有ref对应的属性，只需要将所需要援用的类对象的id写入到ref的值当中便可，举个栗子：
对list和set如果泛型是援用类型，那末可以这样写：
<ref bean=""/>
而对map如果类型是援用类型，可以这样写：
<entry key-ref="" value-ref=""></entry>
好了，是时候验证是不是赋值成功了。IocTest.java
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/test/di/applicationContext.xml");
Teacher teacher = (Teacher) applicationContext.getBean("teacher");
Student student = teacher.getStudent();
System.out.println(teacher.getTeacherName());
System.out.println("studentName :"+student.getName()+"==studentId :"+student.getId());
List<String> lists = teacher.getLists();
for (String string : lists) {
System.out.println(string);
}
Map<Integer,String>maps = teacher.getMaps();
for(Entry<Integer,String>entry :maps.entrySet()) {
System.out.println(maps.get(entry.getKey()));
}
Set<Integer>sets = teacher.getSets();
for (Integer integer : sets) {
System.out.println(integer);
}
此时打印的结果以下：
teacherWang
studentName :haha==studentId :12
one
two
three
firstMap
secondMap
thirdMap
111
222
333
可以发现这个时候spring成功为所有的写了set方法的属性成功赋值了。好了上边的都是利用set方法来为属性赋值的，下面我们来利用构造方法来为属性赋值，我们写1个ClassInfo.java类：
package com.test.di;
public class ClassInfo {
private String className;
private Student student;
public ClassInfo(String className, Student student) {
super();
this.className = className;
this.student = student;
}
public String getClassName() {
return className;
}
public Student getStudent() {
return student;
}
}
可以看到此时我们声明了两个属性，1个基本类型的，1个援用类型的，并且书写了构造方法，这时候我们就能够在spring配置文件中，利用构造方法来为属性赋值了，在bean的配置中有这样1个配置
<constructor-arg index="" type="" ref="" value=""></constructor-arg>
顾名思义就是根据构造函数来为属性赋值的，说明1下这4个参数的意思：
index：该参数在构造方法中的位置，默许从0开始
type：该参数的类型
ref： 如果该参数是援用类型时候的援用id
value：如果该参数是基本类型时候的值
知道了每一个参数的意思，写起来就很简单了，我的ClassInfo.java对应的bean以下：
<bean id="classInfo" class="com.test.di.ClassInfo">
<constructor-arg index="0" type="java.lang.String" value="testConstructor"></constructor-arg>
<constructor-arg index="1" type="com.test.di.Student" ref="student"></constructor-arg>
</bean>
编写测试代码：
ClassInfo classInfo = (ClassInfo) applicationContext.getBean("classInfo");
System.out.println("classInfo.getClassName():"+classInfo.getClassName());
System.out.println("studentId:"+classInfo.getStudent().getId()+"==studentName"+classInfo.getStudent().getName());
此时会正确的答应出我们设置的信息，以下：
classInfo.getClassName():testConstructor
studentId:12==studentNamehaha
现在我们已学会了如何在spring中为属性赋值，如之前所属，我们并没有调用set或构造方法，却能成功为属性赋值，其实我们是把set方法的调用交给spring来处理了，那末依赖注入又有甚么用呢？我们为何要学习依赖注入？还记得我在该篇最开始写了这样1句话：接口 对象 = new 接口实现类(); 这类方式是我们之前创建对象的方法。现在我举个栗子：
我新建1个借口BookRead然后建俩个类实现该接口：
package com.test.why.di;
public interface BookRead {
public void readBook();
}
package com.test.why.di;
public class KindleRead implements BookRead {
@Override
public void readBook() {
System.out.println("use kindle read");
}
}
package com.test.why.di;
public class PhoneRead implements BookRead {
@Override
public void readBook() {
System.out.println("use phone read");
}
}
package com.test.why.di;
public class ReadBy {
private BookRead bookRead;
public ReadBy(BookRead bookRead) {
this.bookRead = bookRead;
}
public void read() {
bookRead.readBook();
}
}
如果我现在需要先用kindle来读书怎样办呢？依照之前的写法：
BookRead bookRead = new KindleRead();
ReadBy readBy = new ReadBy(bookRead);
readBy.read();
那末问题来了，如果我现在需要利用Phone来读书，那末我是否是需要重新new1个PhoneRead呢。这样做其实不是我们要的面向接口编程。接下来我们使用spring的依赖注入来为其优化：
首先将两种读书方式的类，在spring容器中进行配置：
<bean id="kindleRead" class="com.test.why.di.KindleRead">
</bean>
<bean id="phoneRead" class="com.test.why.di.PhoneRead">
</bean>
然后配置ReadBy对应的bean：
<bean id="readBy" class="com.test.why.di.ReadBy">
<property name="bookRead" ref="kindleRead"></property>
</bean>
测试：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/test/di/applicationContext.xml");
ReadBy readBy = (ReadBy) applicationContext.getBean("readBy");
readBy.read();
这里我为readBy注入的是kindleRead，因此这时候候我调用readBy.read();方法应当是运行的kindleRead的readBook，其实这里已做到了面向接口编程，就是我的readBy.read();不需要知道bookRead是甚么类型，我只需要调用在read方法中调用bookRead.readBook();方法就能够了，具体以哪一种方式来读书，我只需要在spring容器当中进行配置便可，这样做也使得代码更加容易保护。
好了，今天的springDi就学习到这里了。
源码下载