[转]依赖注入(IOC)的详细讲解,附带实例和测试结果(大师兄亲测)
原文链接：http://blog.csdn.net/qq_27093465/article/details/52547290
版权声明：觉得此文有用的，不嫌麻烦的，就留个言呐，或者点个赞呐(额，就是文章底部的“顶”啦)，要是嫌弃麻烦呢，也麻烦点个赞嘛，要是实在不想点赞呢，也不是不可以。 但是，你要是想踩一脚呢，那还是赶紧，马上，快快的闪人。 小心我手里三十米长的大刀。 哼哼。想想都怕 ！！！
此篇文章，参考其他文章，亲自测试，并附上测试代码和测试结果图，详详细细，明明白白的讲解什么叫依赖注入，什么叫IOC，绝对能给你看完之后，就知道的清清楚楚，明明白白，在以后都不会忘记这个概念，当然你要是愿意拿我的代码亲自测试一下的话，效果会更好。毕竟我不是复制粘贴党。
Spring 能有效地组织J2EE应用各层的对象。不管是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，
都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对
象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改
写量将大大减少。
上面所说的一切都得宜于Spring的核心机制，依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬
编码的方式耦合在一起。理解依赖注入。
依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。
具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，
在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，
因此，称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。
spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器 控制对象的生命周期。
不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互
相透明。在理解依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实
例，被调用者)。
(1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序
里的调用者自己创建被调用者。
(2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购
买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。
(3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。
对应Spring的依赖注入。
第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者
之间的松耦合。
第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代
码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工
厂耦合在一起。
第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调
用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。
所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。
Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:
(哎，POJO知道是啥吗？不知道的话，看链接，如下：POJO是什么，怎么理解，大师兄查了，看看吧。点我。)
·设值注入。
·构造注入。
一、设值注入。
设值注入是指通过setter方法传入被调用者的实例。这种注入方式简单、直观，因而在Spring的依赖注入里大量使用。
看下面代码：
- package com.fusionskye.ezsonar.model.configcenter;
- //上面的这个包名和配置文件里面的bean类的class属性对应,要测试的话，自己修改成自己的
- import org.springframework.context.ApplicationContext;
- import org.springframework.context.support.FileSystemXmlApplicationContext;
- /** 定义Person接口 */
- interface Person {
- void useAxe(); //Person接口里定义一个使用斧子的方法
- }
- /** 定义Axe(斧子英文Axe)接口 */
- interface Axe {
- String chop(); //Axe接口里有个砍(chop)的方法,原作里面是void，但是这里应该是返回String类型
- }
- /**
- * Person的实现类
- * Chinese实现Person接口
- */
- class Chinese implements Person {
- /** 面向Axe(斧子)接口编程，而不是具体的实现类 */
- private Axe axe;
- /** 默认的构造器 */
- public Chinese() { }
- /**
- * 设值注入所需的setter方法
- * 在xml配置文件中要用到此属性，所以访问权限要public，不能不写
- */
- public void setAxe(Axe axe) { this.axe = axe; }
- /** 实现Person接口的useAxe方法 */
- public void useAxe() { System.out.println(axe.chop()); }
- }
- /**
- * Axe的第一个实现类 StoneAxe 石斧
- */
- class StoneAxe implements Axe {
- /** 默认构造器 */
- StoneAxe() { }
- /** 实现Axe接口的chop方法 */
- public String chop() { return "石斧砍柴好慢"; }
- }
- /**
- * Axe的第二个实现类 SteelAxe 钢斧
- */
- class SteelAxe implements Axe{
- /** 默认构造器 */
- public SteelAxe() { }
- /** 实现Axe接口的chop方法 */
- @Override
- public String chop() {
- return "钢斧砍柴真快";
- }
- }
- /**
- * Created by lxk on 2016/9/14
- */
- class Cmt {
- /**
- * 对上面的有的public权限控制给省略是因为只在一个包下使用，所以就使得权限变成了包内权限，然后就直接不写
- */
- public static void main(String[] args) {
- Chinese chinese = new Chinese();
- StoneAxe stoneAxe = new StoneAxe();
- //设值注入是指通过setter方法传入被调用者的实例
- //如上句的解释：具体的斧子对象不是由人来初始化,而是如上所述的设值注入。
- chinese.setAxe(stoneAxe);
- //上面的Chinese和石斧都是我们自己new的，要是在Spring容器，就由容器来初始化.
- chinese.useAxe();
- //这里 示范了两种实现方式，上面的是自己手动的实现设值注入，下面的是spring里面根据配置文件来实现设值注入
- System.out.println("---------下面是配置文件实现设置注入------------");
- //因为是独立的应用程序，显式地实例化Spring的上下文。下面是启动spring容器代码：寻找配置文件实例化容器
- ApplicationContext ctx = new FileSystemXmlApplicationContext("sss.xml");
- //通过Person bean的id来获取bean实例，面向接口编程，因此
- //此处强制类型转换为接口类型
- Person p = (Person) ctx.getBean("chinese");
- //直接执行Person的userAxe()方法。
- p.useAxe();
- }
- }
package com.fusionskye.ezsonar.model.configcenter;
//上面的这个包名和配置文件里面的bean类的class属性对应,要测试的话，自己修改成自己的
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
/** 定义Person接口 */
interface Person {
void useAxe(); //Person接口里定义一个使用斧子的方法
}
/** 定义Axe(斧子英文Axe)接口 */
interface Axe {
String chop(); //Axe接口里有个砍(chop)的方法,原作里面是void，但是这里应该是返回String类型
}
/**
* Person的实现类
* Chinese实现Person接口
*/
class Chinese implements Person {
/** 面向Axe(斧子)接口编程，而不是具体的实现类 */
private Axe axe;
/** 默认的构造器 */
public Chinese() { }
/**
* 设值注入所需的setter方法
* 在xml配置文件中要用到此属性，所以访问权限要public，不能不写
*/
public void setAxe(Axe axe) { this.axe = axe; }
/** 实现Person接口的useAxe方法 */
public void useAxe() { System.out.println(axe.chop()); }
}
/**
* Axe的第一个实现类 StoneAxe 石斧
*/
class StoneAxe implements Axe {
/** 默认构造器 */
StoneAxe() { }
/** 实现Axe接口的chop方法 */
public String chop() { return "石斧砍柴好慢"; }
}
/**
* Axe的第二个实现类 SteelAxe 钢斧
*/
class SteelAxe implements Axe{
/** 默认构造器 */
public SteelAxe() { }
/** 实现Axe接口的chop方法 */
@Override
public String chop() {
return "钢斧砍柴真快";
}
}
/**
* Created by lxk on 2016/9/14
*/
class Cmt {
/**
* 对上面的有的public权限控制给省略是因为只在一个包下使用，所以就使得权限变成了包内权限，然后就直接不写
*/
public static void main(String[] args) {
Chinese chinese = new Chinese();
StoneAxe stoneAxe = new StoneAxe();
//设值注入是指通过setter方法传入被调用者的实例
//如上句的解释：具体的斧子对象不是由人来初始化,而是如上所述的设值注入。
chinese.setAxe(stoneAxe);
//上面的Chinese和石斧都是我们自己new的，要是在Spring容器，就由容器来初始化.
chinese.useAxe();
//这里 示范了两种实现方式，上面的是自己手动的实现设值注入，下面的是spring里面根据配置文件来实现设值注入
System.out.println("---------下面是配置文件实现设置注入------------");
//因为是独立的应用程序，显式地实例化Spring的上下文。下面是启动spring容器代码：寻找配置文件实例化容器
ApplicationContext ctx = new FileSystemXmlApplicationContext("sss.xml");
//通过Person bean的id来获取bean实例，面向接口编程，因此
//此处强制类型转换为接口类型
Person p = (Person) ctx.getBean("chinese");
//直接执行Person的userAxe()方法。
p.useAxe();
}
}
- 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="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">
- <property name="axe" ref ="stoneAxe">
- property>
- bean>
- <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>
- <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>
- beans>
对于上述的配置文件，再有如下的多嘴几句，估计对小白(没有接受过正规Java学习,半路出家做Java的人)还是有用的.
整个配置文件作用：以配置文件的形式把类放入到spring容器中。
在
上面就是声明了三个类到这个spring容器里面，
正规的项目的配置文件叫：ApplicationContext.xml 是个图标带羽毛状的文件。
关于id和class的正规写法；
id 是：类的第一个字母变成小写，其余不变。
class 是：类的全名。
我觉得本大师兄的注释写的以及非常详细啦吧。
从配置文件中，可以看到Spring管理bean的灵巧性。bean与bean之间的依赖关系放在配置文件里组织，而不是写在代码里。通过配置
文件的 指定，Spring能精确地为每个bean注入属性。因此，配置文件里的bean的class元素，不能仅仅是接口，而必须是真正的实现类。
Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应
的setter方法为程序注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的注入。
每个bean的id属性是该bean的惟一标识，程序通过id属性访问bean，bean与bean的依赖关系也通过id属性完成。
下面上测试的结果，如下：
第一张图是，配置文件里面用的是石斧，代码里面自己new Chinese和stoneAxe的对象测试设置注入的结果。
第二张图, 测试的结果，配置文件里面修改 使用钢斧bean，上面的没修改的执行结果，如下：
Person与Axe之间没有任何代码耦合关系，bean与bean之间的依赖关系由Spring管理。采用setter方法为目标bean注入属性的方式，称为设值注入。
业务对象的更换变得相当简单，对象与对象之间的依赖关系从代码里分离出来，通过配置文件动态管理。
二、 构造注入
所谓构造注入，指通过构造函数来完成依赖关系的设定，而不是通过setter方法。对前面代码Chinese类做简单的修改，修改后的代码如下:
- /**
- * Person的实现类
- * Chinese实现Person接口
- */
- class Chinese implements Person {
- /** 面向Axe(斧子)接口编程，而不是具体的实现类 */
- private Axe axe;
- /** 默认的构造器 */
- public Chinese() { }
- /** 构造注入所需的带参数的构造器 */
- public Chinese(Axe axe) {
- this.axe = axe;
- }
- /** 实现Person接口的useAxe方法 */
- public void useAxe() { System.out.println(axe.chop()); }
- }
/**
* Person的实现类
* Chinese实现Person接口
*/
class Chinese implements Person {
/** 面向Axe(斧子)接口编程，而不是具体的实现类 */
private Axe axe;
/** 默认的构造器 */
public Chinese() { }
/** 构造注入所需的带参数的构造器 */
public Chinese(Axe axe) {
this.axe = axe;
}
/** 实现Person接口的useAxe方法 */
public void useAxe() { System.out.println(axe.chop()); }
}
构造注入的配置文件也需做简单的修改，修改后的配置文件如下:
- 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="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">
- <constructor-arg ref="steelAxe"/>
- bean>
- <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>
- <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>
- beans>
区别在于:创建Person实例中Axe属性的时机不同——设值注入是先创建一个默认的bean实例，
然后调用对应的构造方法注入依赖关系。而构造注入则在创建bean实例时，已经完成了依赖关系的
参考链接：http://tech.techweb.com.cn/thread-214490-1-1.html
(不吹不黑，原文好多错误，估计也是复制粘贴党，而且还是07年时候的，还有个更是复制粘贴党，也是csdn的,点击都特么六万多，哎，我就不上他的链接啦，免得又给他涨点击；自己不搞一下，都复制粘贴的话，这不就跟流言一样吗---------流言止于智者，估计说的就是大师兄我拉。哈哈哈哈哈)
对于上面的xml配置文件中的各个属性什么时候用ref，什么时候value等等，不才的大师兄，做了如下的测试，简单的示例一下 ，平时都是怎么用的，链接如下：
spring xml配置文件里面bean的配置都是如何进行的
测试环境的配置，我给出如下参考链接：
IntelliJ IDEA 中构建spring测试环境