[转]依赖注入(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的依赖注入里大量使用。
看下面代码:

[java] view plain copy
print ?
  1. package com.fusionskye.ezsonar.model.configcenter;  
  2.   
  3. //上面的这个包名和配置文件里面的bean类的class属性对应,要测试的话,自己修改成自己的  
  4.   
  5. import org.springframework.context.ApplicationContext;  
  6. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  7.   
  8. /** 定义Person接口 */  
  9. interface Person {  
  10.     void useAxe();  //Person接口里定义一个使用斧子的方法  
  11. }  
  12.   
  13. /** 定义Axe(斧子英文Axe)接口 */  
  14. interface Axe {  
  15.     String chop(); //Axe接口里有个砍(chop)的方法,原作里面是void,但是这里应该是返回String类型  
  16. }  
  17.   
  18. /** 
  19.  * Person的实现类 
  20.  * Chinese实现Person接口 
  21.  */  
  22. class Chinese implements Person {  
  23.     /** 面向Axe(斧子)接口编程,而不是具体的实现类 */  
  24.     private Axe axe;  
  25.   
  26.     /** 默认的构造器 */  
  27.     public Chinese() { }  
  28.   
  29.     /** 
  30.      * 设值注入所需的setter方法 
  31.      * 在xml配置文件中要用到此属性,所以访问权限要public,不能不写 
  32.      */  
  33.     public void setAxe(Axe axe) { this.axe = axe; }  
  34.   
  35.     /** 实现Person接口的useAxe方法 */  
  36.     public void useAxe() { System.out.println(axe.chop()); }  
  37. }  
  38.   
  39. /** 
  40.  * Axe的第一个实现类 StoneAxe 石斧 
  41.  */  
  42. class StoneAxe implements Axe {  
  43.   
  44.     /** 默认构造器 */  
  45.     StoneAxe() { }  
  46.   
  47.     /** 实现Axe接口的chop方法 */  
  48.     public String chop() { return "石斧砍柴好慢"; }  
  49. }  
  50.   
  51. /** 
  52.  * Axe的第二个实现类 SteelAxe 钢斧 
  53.  */  
  54. class SteelAxe implements Axe{  
  55.     /** 默认构造器 */  
  56.     public SteelAxe() { }  
  57.   
  58.     /** 实现Axe接口的chop方法 */  
  59.     @Override  
  60.     public String chop() {  
  61.         return "钢斧砍柴真快";  
  62.     }  
  63. }  
  64. /** 
  65.  * Created by lxk on 2016/9/14 
  66.  */  
  67. class Cmt {  
  68.     /** 
  69.      * 对上面的有的public权限控制给省略是因为只在一个包下使用,所以就使得权限变成了包内权限,然后就直接不写 
  70.      */  
  71.     public static void main(String[] args) {  
  72.         Chinese chinese = new Chinese();  
  73.         StoneAxe stoneAxe = new StoneAxe();  
  74.         //设值注入是指通过setter方法传入被调用者的实例  
  75.         //如上句的解释:具体的斧子对象不是由人来初始化,而是如上所述的设值注入。  
  76.         chinese.setAxe(stoneAxe);  
  77.   
  78.         //上面的Chinese和石斧都是我们自己new的,要是在Spring容器,就由容器来初始化.  
  79.         chinese.useAxe();  
  80. //这里 示范了两种实现方式,上面的是自己手动的实现设值注入,下面的是spring里面根据配置文件来实现设值注入  
  81.         System.out.println("---------下面是配置文件实现设置注入------------");  
  82.         //因为是独立的应用程序,显式地实例化Spring的上下文。下面是启动spring容器代码:寻找配置文件实例化容器  
  83.         ApplicationContext ctx = new FileSystemXmlApplicationContext("sss.xml");  
  84.         //通过Person bean的id来获取bean实例,面向接口编程,因此  
  85.         //此处强制类型转换为接口类型  
  86.         Person p = (Person) ctx.getBean("chinese");  
  87.         //直接执行Person的userAxe()方法。  
  88.         p.useAxe();  
  89.     }  
  90. }  
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();
    }
}
上面是Java的测试代码,下面是对应的配置文件,sss.xml文件,具体内容如下:

[html] view plain copy
print ?
  1. xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.   
  6.       
  7.     <bean id="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">  
  8.           
  9.           
  10.           
  11.         <property name="axe" ref ="stoneAxe">  
  12.         property>  
  13.     bean>  
  14.       
  15.     <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>  
  16.   
  17.       
  18.     <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>  
  19. beans>  
  20.   
  21.   
  22.   
  23.   



    
    
        
        
        
        
        
    
    
    

    
    




对于上述的配置文件,再有如下的多嘴几句,估计对小白(没有接受过正规Java学习,半路出家做Java的人)还是有用的.
整个配置文件作用:以配置文件的形式把类放入到spring容器中。
这个里面就相当于是整个spring的bean的大包,需要将什么类纳入到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类做简单的修改,修改后的代码如下:

[java] view plain copy
print ?
  1. /** 
  2.  * Person的实现类 
  3.  * Chinese实现Person接口 
  4.  */  
  5. class Chinese implements Person {  
  6.     /** 面向Axe(斧子)接口编程,而不是具体的实现类 */  
  7.     private Axe axe;  
  8.   
  9.     /** 默认的构造器 */  
  10.     public Chinese() { }  
  11.   
  12.     /** 构造注入所需的带参数的构造器 */  
  13.     public Chinese(Axe axe) {  
  14.         this.axe = axe;  
  15.     }  
  16.   
  17.     /** 实现Person接口的useAxe方法 */  
  18.     public void useAxe() { System.out.println(axe.chop()); }  
  19. }  
/**
 * 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()); }
}


此时无须Chinese类里的setAxe方法,构造Person实例时,Spring为Person实例注入所依赖的Axe实例。
构造注入的配置文件也需做简单的修改,修改后的配置文件如下:
[html] view plain copy
print ?
  1. xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  5.   
  6.     <bean id="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">  
  7.           
  8.         <constructor-arg ref="steelAxe"/>  
  9.     bean>  
  10.     <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>  
  11.     <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>  
  12. beans>  



    
		
		
    
	
	


执行效果与使用steelAxe设值注入时的执行效果完全一样。

区别在于:创建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测试环境


你可能感兴趣的:(spring,java,java,spring)