依赖注入_依赖注入详解 - CSDN
依赖注入 订阅
依赖注入(Dependency Injection)是Spring框架的核心之一。 展开全文
依赖注入(Dependency Injection)是Spring框架的核心之一。
信息
外文名
DI
中文名
依赖注入
企业微信发展历程
当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为依赖注入。依赖注入有两种:设值注入、构造注入所谓依赖注入,是指程序运行过程中,如果需要调用另一个对象协助时,无须在代码中创建被调用者,而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理。
收起全文
精华内容
参与话题
  • 什么是依赖注入

    万次阅读 多人点赞 2018-06-09 17:48:57
    Spring 能有效地组织J2EE应用各层的对象。不管是控制层的Action对象,还是业务层的Service对象,还是持久层的DAO对象,都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起,Action...
    Spring 能有效地组织J2EE应用各层的对象。不管控制层的Action对象,还是业务层的Service对象,还是持久层的DAO对象,都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起,Action对象无须关心Service对象的具体实现,Service对 象无须关心持久层对象的具体实现,各层对象的调用完全面向接口。当系统需要重构时,代码的改写量将大大减少。

    上面所说的一切都得宜于Spring的核心机制,依赖注入依赖注入让bean与bean之间以配置文件组织在一起,而不是以硬编码的方式耦合在一起。理解依赖注入

    依赖注入(Dependency Injection)和控制反转(Inversion of Control)同一个概念。具体含义:当某个角色(可能一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为依赖注入

    不管依赖注入,还是控制反转,都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。在理解依赖注入之前,看如下这个问题在各种社会形态里如何解决:一个人(Java实例,调用者)需要一把斧子(Java实例,被调用者)。

    (1)原始社会里,几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

    (2)进入工业社会,工厂出现。斧子不再由普通人完成,而在工厂里被生产出来,此时需要斧子的人(调用者)找到工厂,购买斧子,无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

    (3)进入“按需分配”社会,需要斧子的人不需要找到工厂,坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的依赖注入

    第一种情况下,Java实例的调用者创建被调用的Java实例,必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

    第二种情况下,调用者无须关心被调用者具体实现过程,只需要找到符合某种标准(接口)的实例,即可使用。此时调用的代码面向接口编程,可以让调用者和被调用者解耦,这也是工厂模式大量使用的原因。但调用者需要自己定位工厂,调用者与特定工厂耦合在一起。

    第三种情况下,调用者无须自己定位工厂,程序运行到需要被调用者时,系统自动提供被调用者实例。事实上,调用者和被调用者都处于Spring的管理下,二者之间的依赖关系由Spring提供。

    所谓依赖注入指程序运行过程中,如果需要调用另一个对象协助时,无须在代码中创建被调用者,而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

    ·设值注入

    ·构造注入
    设值注入

      设值注入指通过setter方法传入被调用者的实例。这种注入方式简单、直观,因而在Spring的依赖注入里大量使用。看下面代码,Person的接口
    //定义Person接口
    public interface Person
    {
    //Person接口里定义一个使用斧子的方法
    public void useAxe();
    }

    然后Axe的接口
    //定义Axe接口
    public interface Axe
    {
    //Axe接口里有个砍的方法
    public void chop();
    }

    Person的实现类
    //Chinese实现Person接口

    public class Chinese implements Person
    {
    //面向Axe接口编程,而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //设值注入所需的setter方法
    public void setAxe(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    Axe的第一个实现类
    //Axe的第一个实现类 StoneAxe

    public class StoneAxe implements Axe
    {
    //默认构造器
    public StoneAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "石斧砍柴好慢";
    }
    }

    下面采用Spring的配置文件将Person实例和Axe实例组织在一起。配置文件如下所示:
    <!-- 下面标准的XML文件头 -->
    <?xml version="1.0" encoding="gb2312"?>
    <!-- 下面一行定义Spring的XML配置文件的dtd -->
    "http://www.springframework.org/dtd/spring-beans.dtd">
    <!-- 以上三行对所有的Spring配置文件都相同的 -->
    <!-- Spring配置文件的根元素 -->
    <BEANS>
    <!—定义第一bean,该bean的idchinese, class指定该bean实例的实现类 -->
    <BEAN class=lee.Chinese id=chinese>
    <!-- property元素用来指定需要容器注入的属性,axe属性需要容器注入此处设值注入,因此Chinese类必须拥有setAxe方法 -->
    <property name="axe">
    <!-- 此处将另一个bean的引用注入给chinese bean -->
    <REF local="”stoneAxe”/">
    </property>
    </BEAN>
    <!-- 定义stoneAxe bean -->
    <BEAN class=lee.StoneAxe id=stoneAxe />
    </BEANS>

    从配置文件中,可以看到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属性完成。

    下面看主程序部分:
    public class BeanTest
    {
    //主方法,程序的入口
    public static void main(String[] args)throws Exception
    {
    //因为独立的应用程序,显式地实例化Spring的上下文。
    ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
    //通过Person bean的id来获取bean实例,面向接口编程,因此
    //此处强制类型转换为接口类型
    Person p = (Person)ctx.getBean("chinese");
    //直接执行Person的userAxe()方法。
    p.useAxe();
    }
    }

    程序的执行结果如下:

    石斧砍柴好慢

    主程序调用Person的useAxe()方法时,该方法的方法体内需要使用Axe的实例,但程序里没有任何地方将特定的Person实例和Axe实 例耦合在一起。或者说,程序里没有为Person实例传入Axe的实例,Axe实例由Spring在运行期间动态注入

    Person实例不仅不需要了解Axe实例的具体实现,甚至无须了解Axe的创建过程。程序在运行到需要Axe实例的时候,Spring创建了Axe 实例,然后注入给需要Axe实例的调用者。Person实例运行到需要Axe实例的地方,自然就产生了Axe实例,用来供Person实例使用。

    调用者不仅无须关心被调用者的实现过程,连工厂定位都可以省略(真是按需分配啊!)。下面也给出使用Ant编译和运行该应用的简单脚本:
    <?xml version="1.0"?>
    <!-- 定义编译该项目的基本信息-->
    <PROJECT name="spring" default="." basedir=".">
    <!-- 定义编译和运行该项目时所需的库文件 -->
    <PATH id=classpath>
    <!-- 该路径下存放spring.jar和其他第三方类库 -->
    <FILESET dir=../../lib>
    <INCLUDE name="*.jar" />
    </FILESET>
    <!-- 同时还需要引用已经编译过的class文件-->
    <PATHELEMENT path="." />
    </PATH>
    <!-- 编译全部的java文件-->
    <TARGET description="Compile all source code" name="compile">
    <!-- 指定编译后的class文件的存放位置 -->
    <JAVAC debug="true" destdir=".">
    deprecation="false" optimize="false" failοnerrοr="true">
    <!-- 指定需要编译的源文件的存放位置 -->
    <SRC path="." />
    <!-- 指定编译这些java文件需要的类库位置-->
    <CLASSPATH refid="classpath" />
    </JAVAC>
    </TARGET>
    <!-- 运行特定的主程序 -->
    <TARGET description="run the main class" name="run" depends="compile">
    <!-- 指定运行的主程序:lee.BeanTest。-->
    <JAVA failοnerrοr="true" fork="yes" classname="lee.BeanTest">
    <!-- 指定运行这些java文件需要的类库位置-->
    <CLASSPATH refid="classpath" />
    </JAVA>
    </TARGET>
    </PROJECT>

    如果需要改写Axe的实现类。或者说,提供另一个实现类给Person实例使用。Person接口、Chinese类都无须改变。只需提供另一个Axe的实现,然后对配置文件进行简单的修改即可。

    Axe的另一个实现如下:
    //Axe的另一个实现类 SteelAxe
    public class SteelAxe implements Axe
    {
    //默认构造器
    public SteelAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "钢斧砍柴真快";
    }
    }

    然后,修改原来的Spring配置文件,在其中增加如下一行:
    <!-- 定义一个steelAxe bean-->
    <BEAN class=lee.SteelAxe id=steelAxe />

    该行重新定义了一个Axe的实现:SteelAxe。然后修改chinese bean的配置,将原来传入stoneAxe的地方改为传入steelAxe。也就是将
    <REF local="”stoneAxe”/">

    改成
    <REF local="”steelAxe”/">

    此时再次执行程序,将得到如下结果:

    钢斧砍柴真快

    Person与Axe之间没有任何代码耦合关系,bean与bean之间的依赖关系由Spring管理。采用setter方法为目标bean注入属性的方式,称为设值注入

    业务对象的更换变得相当简单,对象与对象之间的依赖关系从代码里分离出来,通过配置文件动态管理。
    构造注入

      所谓构造注入,指通过构造函数来完成依赖关系的设定,而不是通过setter方法。对前面代码Chinese类做简单的修改,修改后的代码如下:
    //Chinese实现Person接口
    public class Chinese implements Person
    {
    //面向Axe接口编程,而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //构造注入所需的带参数的构造器
    public Chinse(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    此时无须Chinese类里的setAxe方法,构造Person实例时,Spring为Person实例注入依赖的Axe实例。构造注入的配置文件也需做简单的修改,修改后的配置文件如下:
    <!-- 下面标准的XML文件头 -->
    <xml version="1.0" encoding="gb2312"?>
    <!-- 下面一行定义Spring的XML配置文件的dtd -->
    "http://www.springframework.org/dtd/spring-beans.dtd">
    <!-- 以上三行对所有的Spring配置文件都相同的 -->
    <!-- Spring配置文件的根元素 -->
    <BEANS>
    <!—定义第一个bean,该bean的idchinese, class指定该bean实例的实现类 -->
    <BEAN class=lee.Chinese id=chinese>
    </BEAN>
    <!-- 定义stoneAxe bean -->
    <BEAN class=lee.SteelAxe id=steelAxe />
    </BEANS>

    执行效果与使用steelAxe设值注入时的执行效果完全一样。区别在于:创建Person实例中Axe属性的时机不同——设值注入现创建一个默认的bean实例,然后调用对应的构造方法注入依赖关系。而构造注入则在创建bean实例时,已经完成了依赖关系的
    展开全文
  • 依赖注入原理(为什么需要依赖注入)

    万次阅读 多人点赞 2018-01-17 11:46:04
    在软件工程领域,依赖注入(Dependency Injection)是用于实现控制反转(Inversion of Control)的最常见的方式之一。本文主要介绍依赖注入原理和常见的实现方式,重点在于介绍这种年轻的设计模式的适用场景及优势。...

    0. 前言

    在软件工程领域,依赖注入(Dependency Injection)是用于实现控制反转(Inversion of Control)的最常见的方式之一。本文主要介绍依赖注入原理和常见的实现方式,重点在于介绍这种年轻的设计模式的适用场景及优势。

    1. 为什么需要依赖注入

    控制反转用于解耦,解的究竟是谁和谁的耦?这是我在最初了解依赖注入时候产生的第一个问题。

    下面我引用Martin Flower在解释介绍注入时使用的一部分代码来说明这个问题。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    
    public class MovieLister {
        private MovieFinder finder;
    
        public MovieLister() {
            finder = new MovieFinderImpl();
        }
        
        public Movie[] moviesDirectedBy(String arg) {
            List allMovies = finder.findAll();
            for (Iterator it = allMovies.iterator(); it.hasNext();) {
                Movie movie = (Movie) it.next();
                if (!movie.getDirector().equals(arg)) it.remove();
            }
            return (Movie[]) allMovies.toArray(new Movie[allMovies.size()]);
        }
        ...
    }
    

    1
    2
    3
    
    public interface MovieFinder {
        List findAll();
    }
    

    我们创建了一个名为MovieLister的类来提供需要的电影列表,它moviesDirectedBy方法提供根据导演名来搜索电影的方式。真正负责搜索电影的是实现了MovieFinder接口的MovieFinderImpl,我们的MovieLister类在构造函数中创建了一个MovieFinderImpl的对象。

    目前看来,一切都不错。但是,当我们希望修改finder,将finder替换为一种新的实现时(比如为MovieFinder增加一个参数表明Movie数据的来源是哪个数据库),我们不仅需要修改MovieFinderImpl类,还需要修改我们MovieLister中创建MovieFinderImpl的代码。

    这就是依赖注入要处理的耦合。这种在MovieLister中创建MovieFinderImpl的方式,使得MovieLister不仅仅依赖于MovieFinder这个接口,它还依赖于MovieListImpl这个实现。 这种在一个类中直接创建另一个类的对象的代码,和硬编码(hard-coded strings)以及硬编码的数字(magic numbers)一样,是一种导致耦合的坏味道,我们可以把这种坏味道称为硬初始化(hard init)。同时,我们也应该像记住硬编码一样记住,new(对象创建)是有毒的。

    Hard Init带来的主要坏处有两个方面:1)上文所述的修改其实现时,需要修改创建处的代码;2)不便于测试,这种方式创建的类(上文中的MovieLister)无法单独被测试,其行为和MovieFinderImpl紧紧耦合在一起,同时,也会导致代码的可读性问题(“如果一段代码不便于测试,那么它一定不便于阅读。”)。

    2. 依赖注入的实现方式

    依赖注入其实并不神奇,我们日常的代码中很多都用到了依赖注入,但很少注意到它,也很少主动使用依赖注入进行解耦。这里我们简单介绍一下赖注入实现三种的方式。

    2.1 构造函数注入(Contructor Injection)

    这是我认为的最简单的依赖注入方式,我们修改一下上面代码中MovieList的构造函数,使得MovieFinderImpl的实现在MovieLister类之外创建。这样,MovieLister就只依赖于我们定义的MovieFinder接口,而不依赖于MovieFinder的实现了。

    1
    2
    3
    4
    5
    6
    7
    8
    
    public class MovieLister {
        private MovieFinder finder;
    
        public MovieLister(MovieFinder finder) {
            this.finder = finder;
        }
        ...
    }
    

    2.2 setter注入

    类似的,我们可以增加一个setter函数来传入创建好的MovieFinder对象,这样同样可以避免在MovieFinder中hard init这个对象。

    1
    2
    3
    4
    5
    6
    
    public class MovieLister {
        s...
        public void setFinder(MovieFinder finder) {
            this.finder = finder;
        }
    }
    

    2.3 接口注入

    接口注入使用接口来提供setter方法,其实现方式如下。
    首先要创建一个注入使用的接口。

    1
    2
    3
    
    public interface InjectFinder {
        void injectFinder(MovieFinder finder);
    }
    

    之后,我们让MovieLister实现这个接口。
    1
    2
    3
    4
    5
    6
    7
    
    class MovieLister implements InjectFinder {
        ...
        public void injectFinder(MovieFinder finder) {
          this.finder = finder;
        }
        ...
    }
    

    最后,我们需要根据不同的框架创建被依赖的MovieFinder的实现。

    3. 最后

    依赖注入降低了依赖和被依赖类型间的耦合,在修改被依赖的类型实现时,不需要修改依赖类型的实现,同时,对于依赖类型的测试,可以更方便的使用mocking object替代原有的被依赖类型,以达到对依赖对象独立进行单元测试的目的。

    最后需要注意的是,依赖注入只是控制反转的一种实现方式。控制反转还有一种常见的实现方式称为依赖查找。

    参考

    1. Inversion of Control Containers and the Dependency Injection pattern
    2. How to Think About the “new” Operator with Respect to Unit Testing
    3. 依赖注入
    展开全文
  • Spring的五种依赖注入方式

    万次阅读 多人点赞 2019-03-04 18:25:09
    平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是...

    平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”,通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。

    spring有多种依赖注入的形式,下面介绍spring进行DI的方式:

    一.目前使用最广泛的 @Autowired:自动装配

    自动装配,用于替代基于XML配置的自动装配,详见【3.3.3  自动装配】。

    基于@Autowired的自动装配,默认是根据类型注入,可以用于构造器、字段、方法注入,使用方式如下:

    java代码:

    1. @Autowired(required=true)  
    2. 构造器、字段、方法  

    @Autowired默认是根据参数类型进行自动装配,且必须有一个Bean候选者注入默认required=true如果允许出现0个Bean候选者需要设置属性“required=false”,“required”属性含义和@Required一样,只是@Required只适用于基于XML配置的setter注入方式,只能打在setting方法上。

    (1)、构造器注入:通过将@Autowired注解放在构造器上来完成构造器注入,默认构造器参数通过类型自动装配,如下所示:

    1、准备测试Bean,在构造器上添加@AutoWired注解:

    java代码:

    package cn.javass.spring.chapter12;  
    import org.springframework.beans.factory.annotation.Autowired;  
    public class TestBean11 {  
        private String message;  
        @Autowired //构造器注入  
        private TestBean11(String message) {  
            this.message = message;  
        }  
        //省略message的getter和setter  
    }  

    2、在Spring配置文件(chapter12/dependecyInjectWithAnnotation.xml)添加如下Bean配置:

    xml代码:

    <bean id="testBean11" class="cn.javass.spring.chapter12.TestBean11"/>  

    3、测试类如下:

    java代码:

    @Test  
    public void testAutowiredForConstructor() {  
        TestBean11 testBean11 = ctx.getBean("testBean11", TestBean11.class);  
        Assert.assertEquals("hello", testBean11.getMessage());  
    }  

        在Spring配置文件中没有对“testBean11”进行构造器注入和setter注入配置,而是通过在构造器上添加@ Autowired来完成根据参数类型完成构造器注入。

    (2)、字段注入:通过将@Autowired注解放在构造器上来完成字段注入。

    1、准备测试Bean,在字段上添加@AutoWired注解:

    java代码:

    package cn.javass.spring.chapter12;  
    import org.springframework.beans.factory.annotation.Autowired;  
    public class TestBean12 {  
        @Autowired //字段注入  
        private String message;  
        //省略getter和setter  
    } 

    2、在Spring配置文件(chapter12/dependecyInjectWithAnnotation.xml)添加如下Bean配置:

    xml代码:

    <bean id="testBean12" class="cn.javass.spring.chapter12.TestBean12"/>  

    3、测试方法如下:

    java代码:

    @Test  
    public void testAutowiredForField() {  
        TestBean12 testBean12 = ctx.getBean("testBean12", TestBean12.class);  
        Assert.assertEquals("hello", testBean12.getMessage());  
    }  

        字段注入在基于XML配置中无相应概念,字段注入不支持静态类型字段的注入。

    (3)、方法参数注入:通过将@Autowired注解放在方法上来完成方法参数注入。

    1、准备测试Bean,在方法上添加@AutoWired注解:

    java代码:

    package cn.javass.spring.chapter12;  
    import org.springframework.beans.factory.annotation.Autowired;  
    public class TestBean13 {  
        private String message;  
        @Autowired //setter方法注入  
        public void setMessage(String message) {  
            this.message = message;  
        }  
        public String getMessage() {  
            return message;  
        }  
    }  

    java代码:

    package cn.javass.spring.chapter12;  
    //省略import  
    public class TestBean14 {  
        private String message;  
        private List<String> list;  
        @Autowired(required = true) //任意一个或多个参数方法注入  
        private void initMessage(String message, ArrayList<String> list) {  
            this.message = message;  
            this.list = list;  
        }  
        //省略getter和setter  
    }  

    2、在Spring配置文件(chapter12/dependecyInjectWithAnnotation.xml)添加如下Bean配置:

    xml代码:

    <bean id="testBean13" class="cn.javass.spring.chapter12.TestBean13"/>  
    <bean id="testBean14" class="cn.javass.spring.chapter12.TestBean14"/>  
    <bean id="list" class="java.util.ArrayList">  
        <constructor-arg index="0">  
            <list>  
                <ref bean="message"/>  
                <ref bean="message"/>  
            </list>  
       </constructor-arg>          
    </bean>  

    代码:

    3、测试方法如下:

    java代码:

    @Test  
    public void testAutowiredForMethod() {  
        TestBean13 testBean13 = ctx.getBean("testBean13", TestBean13.class);  
        Assert.assertEquals("hello", testBean13.getMessage());  
       
        TestBean14 testBean14 = ctx.getBean("testBean14", TestBean14.class);  
        Assert.assertEquals("hello", testBean14.getMessage());  
        Assert.assertEquals(ctx.getBean("list", List.class), testBean14.getList());  
    }  

       方法参数注入除了支持setter方法注入,还支持1个或多个参数的普通方法注入,在基于XML配置中不支持1个或多个参数的普通方法注入,方法注入不支持静态类型方法的注入。

    • 二.setter 方法注入

    这是最简单的注入方式,假设有一个SpringAction,类中需要实例化一个SpringDao对象,那么就可以定义一个private的SpringDao成员变量,然后创建SpringDao的set方法(这是ioc的注入入口):

    Java代码  

    package com.bless.springdemo.action;  
    public class SpringAction {  
            //注入对象springDao  
        private SpringDao springDao;  
            //一定要写被注入对象的set方法  
            public void setSpringDao(SpringDao springDao) {  
            this.springDao = springDao;  
        }  
      
            public void ok(){  
            springDao.ok();  
        }  
    }  

    随后编写spring的xml文件,<bean>中的name属性是class属性的一个别名,class属性指类的全名,因为在SpringAction中有一个公共属性Springdao,所以要在<bean>标签中创建一个<property>标签指定SpringDao。<property>标签中的name就是SpringAction类中的SpringDao属性名,ref指下面<bean name="springDao"...>,这样其实是spring将SpringDaoImpl对象实例化并且调用SpringAction的setSpringDao方法将SpringDao注入:

    xml代码  

    <!--配置bean,配置后该类由spring管理-->  
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
            <!--(1)依赖注入,配置当前类中相应的属性-->  
            <property name="springDao" ref="springDao"></property>  
        </bean>  
    <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>  

    三:构造器注入

    这种方式的注入是指带有参数的构造函数注入,看下面的例子,我创建了两个成员变量SpringDao和User,但是并未设置对象的set方法,所以就不能支持第一种注入方式,这里的注入方式是在SpringAction的构造函数中注入,也就是说在创建SpringAction对象时要将SpringDao和User两个参数值传进来:

    Java代码  

    public class SpringAction {  
        //注入对象springDao  
        private SpringDao springDao;  
        private User user;  
          
        public SpringAction(SpringDao springDao,User user){  
            this.springDao = springDao;  
            this.user = user;  
            System.out.println("构造方法调用springDao和user");  
        }  
              
            public void save(){  
            user.setName("卡卡");  
            springDao.save(user);  
        }  
    }  

    在XML文件中同样不用<property>的形式,而是使用<constructor-arg>标签,ref属性同样指向其它<bean>标签的name属性:

    Xml代码  

    <!--配置bean,配置后该类由spring管理-->  
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
            <!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->  
            <constructor-arg ref="springDao"></constructor-arg>  
            <constructor-arg ref="user"></constructor-arg>  
        </bean>  
            <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>  
             <bean name="user" class="com.bless.springdemo.vo.User"></bean>  

      解决构造方法参数的不确定性,你可能会遇到构造方法传入的两参数都是同类型的,为了分清哪个该赋对应值,则需要进行一些小处理:

    下面是设置index,就是参数位置:

    Xml代码  :

    <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
            <constructor-arg index="0" ref="springDao"></constructor-arg>  
            <constructor-arg index="1" ref="user"></constructor-arg>  
        </bean> 

     另一种是设置参数类型:

    Xml代码  :

    <constructor-arg type="java.lang.String" ref=""/>  
    • 四丶静态工厂的方法注入

    静态工厂顾名思义,就是通过调用静态工厂的方法来获取自己需要的对象,为了让spring管理所有对象,我们不能直接通过"工程类.静态方法()"来获取对象,而是依然通过spring注入的形式获取:

    Java代码  

    package com.bless.springdemo.factory;  
      
    import com.bless.springdemo.dao.FactoryDao;  
    import com.bless.springdemo.dao.impl.FactoryDaoImpl;  
    import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;  
      
    public class DaoFactory {  
        //静态工厂  
        public static final FactoryDao getStaticFactoryDaoImpl(){  
            return new StaticFacotryDaoImpl();  
        }  
    }  

    同样看关键类,这里我需要注入一个FactoryDao对象,这里看起来跟第一种注入一模一样,但是看随后的xml会发现有很大差别:

    Java代码  :

     public class SpringAction {  
            //注入对象  
        private FactoryDao staticFactoryDao;  
          
        public void staticFactoryOk(){  
            staticFactoryDao.saveFactory();  
        }  
        //注入对象的set方法  
        public void setStaticFactoryDao(FactoryDao staticFactoryDao) {  
            this.staticFactoryDao = staticFactoryDao;  
        }  
    }  

    Spring的IOC配置文件,注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类,而是指向静态工厂DaoFactory,并且配置 factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法:

    Xml代码  

    <!--配置bean,配置后该类由spring管理-->  
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction" >  
            <!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)-->  
            <property name="staticFactoryDao" ref="staticFactoryDao"></property>  
                    </property>  
        </bean>  
        <!--(3)此处获取对象的方式是从工厂类中获取静态方法-->  
        <bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>  

          五丶实例工厂的方法注入

    实例工厂的意思是获取对象实例的方法不是静态的,所以你需要首先new工厂类,再调用普通的实例方法:

    Java代码  

    public class DaoFactory {  
        //实例工厂  
        public FactoryDao getFactoryDaoImpl(){  
            return new FactoryDaoImpl();  
        }  
    }  

    那么下面这个类没什么说的,跟前面也很相似,但是我们需要通过实例工厂类创建FactoryDao对象:

    Java代码  

    public class SpringAction {  
        //注入对象  
        private FactoryDao factoryDao;  
          
        public void factoryOk(){  
            factoryDao.saveFactory();  
        }  
      
        public void setFactoryDao(FactoryDao factoryDao) {  
            this.factoryDao = factoryDao;  
        }  
    } 

    最后看spring配置文件:

    Xml代码  

    <!--配置bean,配置后该类由spring管理-->  
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
            <!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)-->  
            <property name="factoryDao" ref="factoryDao"></property>  
        </bean>  
          
        <!--(4)此处获取对象的方式是从工厂类中获取实例方法-->  
        <bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>  
        <bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean> 

     平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”,通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。

    展开全文
  • 控制反转和依赖注入的理解(通俗易懂)

    万次阅读 多人点赞 2019-09-20 11:06:32
    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring...

     学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。

    一、分享Iteye的开涛对Ioc的精彩讲解

      首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinnianshilongnian.iteye.com/blog/1413846

    1.1、IoC是什么

      Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

      ●谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对 象的创建;谁控制谁?当然是IoC 容器控制了对象;控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等)

      ●为何是反转,哪些方面反转了:有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象;为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;哪些方面反转了?依赖对象的获取被反转了。

      用图例说明一下,传统程序设计如图2-1,都是主动去创建相关对象然后再组合起来:

    图1-1 传统应用程序示意图

      当有了IoC/DI的容器后,在客户端类中不再主动去创建这些对象了,如图2-2所示:

    图1-2有IoC/DI容器后程序结构示意图

    1.2、IoC能做什么

      IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

      其实IoC对编程带来的最大改变不是从代码上,而是从思想上,发生了“主从换位”的变化。应用程序原本是老大,要获取什么资源都是主动出击,但是在IoC/DI思想中,应用程序就变成被动的了,被动的等待IoC容器来创建并注入它所需要的资源了。

      IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找。

    1.3、IoC和DI

      DI—Dependency Injection,即“依赖注入”组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

      理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

      ●谁依赖于谁:当然是应用程序依赖于IoC容器

      ●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源

      ●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象

      ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)

      IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”

      看过很多对Spring的Ioc理解的文章,好多人对Ioc和DI的解释都晦涩难懂,反正就是一种说不清,道不明的感觉,读完之后依然是一头雾水,感觉就是开涛这位技术牛人写得特别通俗易懂,他清楚地解释了IoC(控制反转) 和DI(依赖注入)中的每一个字,读完之后给人一种豁然开朗的感觉。我相信对于初学Spring框架的人对Ioc的理解应该是有很大帮助的。

    二、分享Bromon的blog上对IoC与DI浅显易懂的讲解

    2.1、IoC(控制反转)

      首先想说说IoC(Inversion of Control,控制反转)。这是spring的核心,贯穿始终。所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………,想办法认识她们,投其所好送其所要,然后嘿嘿……这个过程是复杂深奥的,我们必须自己设计和面对每个环节。传统的程序开发也是如此,在一个对象中,如果要使用另外的对象,就必须得到它(自己new一个,或者从JNDI中查询一个),使用完之后还要将对象销毁(比如Connection等),对象始终会和其他的接口或类藕合起来。

      那么IoC是如何做的呢?有点像通过婚介找女朋友,在我和女朋友之间引入了一个第三者:婚姻介绍所。婚介管理了很多男男女女的资料,我可以向婚介提出一个列表,告诉它我想找个什么样的女朋友,比如长得像李嘉欣,身材像林熙雷,唱歌像周杰伦,速度像卡洛斯,技术像齐达内之类的,然后婚介就会按照我们的要求,提供一个mm,我们只需要去和她谈恋爱、结婚就行了。简单明了,如果婚介给我们的人选不符合要求,我们就会抛出异常。整个过程不再由我自己控制,而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此,所有的类都会在spring容器中登记,告诉spring你是个什么东西,你需要什么东西,然后spring会在系统运行到适当的时候,把你要的东西主动给你,同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制,也就是说控制对象生存周期的不再是引用它的对象,而是spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被spring控制,所以这叫控制反转。

    2.2、DI(依赖注入)

      IoC的一个重点是在系统运行中,动态的向某个对象提供它所需要的其他对象。这一点是通过DI(Dependency Injection,依赖注入)来实现的。比如对象A需要操作数据库,以前我们总是要在A中自己编写代码来获得一个Connection对象,有了 spring我们就只需要告诉spring,A中需要一个Connection,至于这个Connection怎么构造,何时构造,A不需要知道。在系统运行时,spring会在适当的时候制造一个Connection,然后像打针一样,注射到A当中,这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行,而这个Connection是由spring注入到A中的,依赖注入的名字就这么来的。那么DI是如何实现的呢? Java 1.3之后一个重要特征是反射(reflection),它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性,spring就是通过反射来实现注入的。

      理解了IoC和DI的概念后,一切都将变得简单明了,剩下的工作只是在spring的框架中堆积木而已。

    三、我对IoC(控制反转)和DI(依赖注入)的理解

      在平时的java应用开发中,我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成,在没有使用Spring的时候,每个对象在需要使用他的合作对象时,自己均要使用像new object() 这样的语法来将合作对象创建出来,这个合作对象是由自己主动创建出来的,创建合作对象的主动权在自己手上,自己需要哪个合作对象,就主动去创建,创建合作对象的主动权和创建时机是由自己把控的,而这样就会使得对象间的耦合度高了,A对象需要使用合作对象B来共同完成一件事,A要使用B,那么A就对B产生了依赖,也就是A和B之间存在一种耦合关系,并且是紧密耦合在一起,而使用了Spring之后就不一样了,创建合作对象B的工作是由Spring来做的,Spring创建好B对象,然后存储到一个容器里面,当A对象需要使用B对象时,Spring就从存放对象的那个容器里面取出A要使用的那个B对象,然后交给A对象使用,至于Spring是如何创建那个对象,以及什么时候创建好对象的,A对象不需要关心这些细节问题(你是什么时候生的,怎么生出来的我可不关心,能帮我干活就行),A得到Spring给我们的对象之后,两个人一起协作完成要完成的工作即可。

      所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移,以前创建对象的主动权和创建时机是由自己把控的,而现在这种权力转移到第三方,比如转移交给了IoC容器,它就是一个专门用来创建对象的工厂,你要什么对象,它就给你什么对象,有了 IoC容器,依赖关系就变了,原先的依赖关系就没了,它们都依赖IoC容器了,通过IoC容器来建立它们之间的关系。

      这是我对Spring的IoC(控制反转)的理解。DI(依赖注入)其实就是IOC的另外一种说法,DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结:控制的什么被反转了?就是:获得依赖对象的方式反转了。

    四、小结

      对于Spring Ioc这个核心概念,我相信每一个学习Spring的人都会有自己的理解。这种概念上的理解没有绝对的标准答案,仁者见仁智者见智。如果有理解不到位或者理解错的地方,欢迎广大园友指正!

     

     

    展开全文
  • 依赖注入是什么?

    千次阅读 2019-01-13 20:46:05
    依赖注入(Dependency Injection) Spring的两个核心内容为控制反转(Ioc)和面向切面(AOP),依赖注入(DI)是控制反转(Ioc)的一种方式。 依赖注入这个词让人望而生畏,现在已经演变成一项复杂的编程技巧 或...
  • 依赖注入主要是通过让各个模块互相不依赖 使各个模块依赖于抽象(接口)从而降低系统的耦合性 依赖注入方式 分为三种构造器注入(Constructor Injection)、属性注入(Property Injection),以及方法调用注入(Method ...
  • 容器与依赖注入

    2019-03-17 23:07:58
    容器是一种轻量级操作系统层面的虚拟机,它为应用软件及其依赖组件提供了一个资源独立的运行环境。应用软件所依赖的组件会被打包成一个可重用的镜像,镜像运行环境并不会与主操作系统共享内存、CPU和硬盘空间,由此...
  • 在《WCF技术剖析》中使用了Unity依赖注入容器,书中给出了两个使用Unity的方法: 方法一:直接在代码中使用  using System; using System.Collections.Generic; using System.Linq; using ...
  • 依赖注入,也叫控制反转。简单的来说就是:一个类中用到其他类的实例时,我们不在该类中创建实例,而是在类外创建实例后把实例作为参数传入类中。 当需要创建大量的类的实例的时候,我们为了方便管理,把类实例化的...
  •  今天,先不谈容器(container),首先用一些具体的例子来介绍依赖注入的概念,证明依赖注入这种模式可以解决哪些问题,同时能给开发人员带来哪些好处。 如果你已经知道了依赖注入的概念,你可以跳过这篇文章。依赖...
  • javascript依赖注入详解

    千次阅读 2017-12-13 15:09:40
    本人在研究前端自动化时,开始深入学习设计模式,由此引发了对依赖注入的学习,站在巨人的肩膀上参考了很多文章,在这里对这些作者表示敬仰,并赋予相关博客链接。 前端需要知道的 依赖注入(Dependency Injection, ...
  • 依赖注入

    2018-03-01 23:19:51
    依赖注入 理解: 是一种允许我们从硬编码的依赖中解耦出来,从而在运行时或者编译时能够修改的软件设计模式。 简单来说依赖注入是通过构造注入,函数调用或者属性的设置等来提供组件的依赖关系。 控制反转 ...
  • 关于Spring IOC (DI-依赖注入)你需要知道的一切

    万次阅读 多人点赞 2017-07-28 23:37:36
    【版权申明】未经博主同意,不允许转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 《Spring入门经典》这本无论对于初学者或者有经验的工程师还是很值一看的,最近花了点时间回顾了Spring的内容,在...
  • Java 依赖注入标准(JSR-330,Dependency Injection for Java)1.0 规范已于2009年10 月份发布。该规范主要是面向依赖注入使用者,而对注入器实现、配置并未作详细要求。Spring、Guice 已经开始兼容该规范,JSR-299...
  • websocket之参数传递和依赖注入

    万次阅读 2020-03-11 09:45:44
    需要注入service 层的类,以便在onOpen()方法中进行数据查询和业务处理。百度谷歌一顿搜索后,发现这两个问题还挺有共性的,很多人都在问,但是靠谱的答案却比较少见。通过查看源码和各种折腾,最后还是解决了这些...
  • 写这篇文章的原因是这两天在编写关于 Dagger2 主题的博文时,花了大量的精力来解释依赖注入这个概念。后来想一下,这些在面向对象开发过程中与依赖相关的诸多术语和概念实际情况下非常的抽象,因此独立成文也有就...
  • 依赖注入和控制反转的理解,写的太好了。

    万次阅读 多人点赞 2015-08-11 17:53:22
    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring...
  • Spring源码剖析——依赖注入实现原理

    万次阅读 多人点赞 2018-06-25 20:42:11
    引言  在之前的 Spring源码剖析——核心IOC容器原理这篇文章中,已经详细介绍了在Spring当中我们配置的Bean是怎样被Spring解析和管理的,我们配置的那些Bean经过 载入 、解析 和 注册 这三个过程后,在框架内部被...
  • Spring之依赖注入

    万次阅读 2018-01-10 12:58:59
    Spring框架的核心功能之一就是通过依赖注入的方式来管理Bean之间的依赖关系。那么我们今天的主角依赖注入到底有什么神奇之处呢?请往下继续看。 了解过设计模式的朋友肯定知道工厂模式吧,即所有的对象的创建都交给...
  • 依赖注入的原理

    千次阅读 多人点赞 2016-07-12 11:26:31
    什么是依赖注入依赖注入是实现程序解耦的一种方式。如果通过百度搜索可以找到如下答案: 控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题.控制反转一般...
1 2 3 4 5 ... 20
收藏数 276,776
精华内容 110,710
关键字:

依赖注入