[转]依赖注入(IOC)的详细讲解,附带实例和测试结果(大师兄亲测)

最新推荐文章于 2022-07-06 15:26:26 发布

hephil

最新推荐文章于 2022-07-06 15:26:26 发布

阅读量228

点赞数 1

分类专栏： spring java 文章标签： java spring

java 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

spring

2 篇文章 0 订阅

订阅专栏

原文链接：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 ?

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();
    }
}

上面是Java的测试代码，下面是对应的配置文件，sss.xml文件，具体内容如下：

[html] view plain copy

print ?

<?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>

<?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，该bean的id是chinese, class指定该bean实例的实现类 -->
    <bean id="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">
        <!-- property元素用来指定需要容器注入的属性，axe属性需要容器注入，因此Chinese类必须拥有setAxe方法 -->
        <!-- 此处将另一个bean的引用注入给chinese bean -->
        <!-- 想注入什么斧子，就修改ref的值就可以啦，对应的是下面的bean的id(如下面的steelAxe)那么运行结果就是钢斧的结果-->
        <property name="axe" ref ="stoneAxe">
        </property>
    </bean>
    <!-- 定义stoneAxe bean -->
    <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>

    <!-- 定义steelAxe bean -->
    <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>
</beans>
<!-- 在 Spring 容器中将 StoneAxe 声明为 Bean，并注入到 Chinese Bean 中，上面的就是使用传统 XML 完成这个工作的配置文件     -->
<!-- 现在就不是这么一个个的配置的啦，具体怎么详细配置的，还没有细细研究过，但是spring mvc 里面的注解的实现应该和这个有点关系-->
<!-- 只是现在技术有限，等啥时候研究到啦，再回解释这个吧。-->
<!-- 运行的时候，把这些个汉字都删掉，不然会报错，具体就不解释啦。-->

对于上述的配置文件，再有如下的多嘴几句，估计对小白(没有接受过正规Java学习,半路出家做Java的人)还是有用的.
整个配置文件作用：以配置文件的形式把类放入到spring容器中。
在<beans></beans>这个里面就相当于是整个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 ?

/**
* 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()); }
}

此时无须Chinese类里的setAxe方法，构造Person实例时，Spring为Person实例注入所依赖的Axe实例。
构造注入的配置文件也需做简单的修改，修改后的配置文件如下:

[html] view plain copy

print ?

<?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>

<?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>

执行效果与使用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测试环境

hephil

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[转]依赖注入(IOC)的详细讲解,附带实例和测试结果(大师兄亲测)

原文链接：http://blog.csdn.net/qq_27093465/article/details/52547290版权声明：觉得此文有用的，不嫌麻烦的，就留个言呐，或者点个赞呐(额，就是文章底部的“顶”啦)，要是嫌弃麻烦呢，也麻烦点个赞嘛，要是实在不想点赞呢，也不是不可以。但是，你要是想踩一脚呢，那还是赶紧，马上，快快的闪人。小心我手里三十米长的大刀。哼哼。想想都怕
复制链接

扫一扫