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

此篇文章,参考其他文章,亲自测试,并附上测试代码和测试结果图,详详细细,明明白白的讲解什么叫依赖注入,什么叫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();
    }
}

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

<?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类做简单的修改,修改后的代码如下:

/**
 * 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实例。
构造注入的配置文件也需做简单的修改,修改后的配置文件如下:

<?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测试环境

 

我写完文章,给自己点个赞,不过分吧,
不过分,那我可就点啦啊。
我先点为敬,你们随意。大家随意。不要客气。。。

©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值