Java：控制反转（IoC）与依赖注入（DI）

很长一段时间里，我对控制反转和依赖注入这两个概念很模糊，闭上眼睛想想，总有一种眩晕的感受。但为了成为一名优秀的 Java 工程师，我花了一周的时间，完全把它们搞清楚了。

0一、紧耦合

在咱们编码的过程当中，一般都须要两个或者更多的类经过彼此的合做来实现业务逻辑，也就是说，某个对象须要获取与其合做对象的引用，若是这个获取的过程须要本身实现，代码的耦合度就会高，维护起来的成本就比较高。

咱们来经过实战模拟一下。假如老王是少林寺的主持，他想让小二和尚去扫达摩院的地，代码能够这样实现。

小二类的代码以下所示：

public class Xiaoer {
    public void saodi() {
        System.out.println("小二我在扫达摩院的地");
    }
}

老王类的代码以下所示：

public class Laowang {
    public void mingling() {
        new Xiaoer().saodi();
    }
}

测试类的代码以下所示：

public class Test {

    public static void main(String[] args) {
        Laowang laowang = new Laowang();
        laowang.mingling();
    }

}

Laowang 类的 mingling 方法中使用 new 关键字建立了一个 Xiaoer 类的对象——这种代码的耦合度就很高，维护起来的成本就很高，为何这么说呢？

某一天，达摩院的地又脏了，老王主持想起了小二和尚，可小二和尚去练易筋经了，让谁去扫地呢，老王主持想起了小三和尚，因而 Laowang 类就不得不从新下一个新的命令，因而代码变成了这样：

public class Xiaosan {
    public void saodi() {
        System.out.println("小三我在扫达摩院的地");
    }
}
public class Laowang {
    public void mingling() {
        new Xiaoer().saodi();
    }

    public void mingling1() {
        new Xiaosan().saodi();
    }
}

假如小三和尚去挑水了，老王主持没准要下命令给小四和尚去扫达摩院的地。这样下去的话，Laowang 这个类会疯掉的。

老王主持以为本身堂堂一届高僧，下个扫地的命令居然这样麻烦，他以为很不爽。

0二、控制反转

咱们得替老王主持想个办法对不对？

不如把这个扫地的差事交给老王的师弟老方吧，老方负责去叫小二和尚仍是小三和尚仍是小四和尚去执行老王主持的命令。代码能够这样实现。

定义一个扫地和尚的接口，代码以下所示：

public interface Heshang {
    void saodi();
}

小二类的代码修改以下所示：

public class Xiaoer implements Heshang {

    @Override
    public void saodi() {
        System.out.println("小二我在扫达摩院的地");        
    }

    public boolean isYijinjing() {
        // 星期三的时候小二和尚要练易筋经
        return false;
    }
}

小三类的代码修改以下所示：

public class Xiaosan implements Heshang {

    @Override
    public void saodi() {
        System.out.println("小三我在扫达摩院的地");        
    }
}

老方类的代码以下所示：

public class Laofang {
    public static Heshang getSaodiseng() {
        Xiaoer xiaoer = new Xiaoer();
        if (xiaoer.isYijinjing()) {
            return new Xiaosan();
        }
        return xiaoer;
    }
}

若是老方确认小二和尚在练易筋经，就叫小三和尚。

老王类的代码修改以下所示：

public class Laowang {
    public void mingling() {
        Laofang.getSaodiseng().saodi();
    }
}

测试类的代码不改变，以下所示：

public class Test {

    public static void main(String[] args) {
        Laowang laowang = new Laowang();
        laowang.mingling();
    }

}

老王如今是否是省心多了，他只管下命令，该叫谁去扫达摩院的地由他师弟老方去负责。

咱们替老王想的这个办法就叫控制反转（Inversion of Control，缩写为 IoC），它不是一种技术，而是一种思想——指导咱们设计出松耦合的程序。

控制反转从词义上能够拆分为“控制”和“反转”，说到控制，就必须找出主语和宾语，谁控制了谁；说到反转，就必须知道正转是什么。

你看，在紧耦合的状况下，老王下命令的时候本身要经过 new 关键字建立依赖的对象（小二和尚或者小三和尚）；而控制反转后，老王要找的扫地和尚由他师弟老方负责，也就是说控制权交给了老方，是否是反转了呢？

0三、依赖注入

依赖注入（Dependency Injection，简称 DI）是实现控制反转的主要方式：在类 A 的实例建立过程当中就建立了依赖的 B 对象，经过类型或名称来判断将不一样的对象注入到不一样的属性中。大概有 3 种具体的实现形式：

1）基于构造函数。实现特定参数的构造函数，在新建对象时传入所依赖类型的对象。

老王类的代码修改以下所示：

public class Laowang {
    private Heshang saodiseng;

    public Laowang(Heshang saodiseng) {
        this.saodiseng = saodiseng;
    }
    public void mingling() {
       this.saodiseng.saodi();
    }
}

测试类的代码修改以下所示：

public class Test {

    public static void main(String[] args) {
        Laowang laowang = new Laowang(new Xiaosan());
        laowang.mingling();
    }

}

这时候，控制权掌握在测试类的手里，它决定派小二和尚仍是小三和尚去执行老王的扫地命令。

2）基于 set 方法。实现特定属性的 public set 方法，让外部容器调用传入所依赖类型的对象。

老王类的代码修改以下所示：

public class Laowang {
    private Heshang saodiseng;

    public Heshang getSaodiseng() {
        return saodiseng;
    }

    public void setSaodiseng(Heshang saodiseng) {
        this.saodiseng = saodiseng;
    }

    public void mingling() {
       this.getSaodiseng().saodi();
    }
}

测试类的代码修改以下所示：

public class Test {

    public static void main(String[] args) {
        Laowang laowang = new Laowang();
        Xiaosan xiaosan = new Xiaosan();
        laowang.setSaodiseng(xiaosan);
        laowang.mingling();
    }

}

这时候，控制权仍然掌握在测试类的手里，它决定派小二和尚仍是小三和尚去执行老王的扫地命令。

3）基于接口。实现特定接口以供外部容器注入所依赖类型的对象，这种作法比较构造函数和 set 方法更为复杂，这里就此略过。

可能有人会把控制反转等同于依赖注入，但实际上它们有着本质上的不一样：控制反转是一种思想，而依赖注入是实现控制反转的一种形式。

0四、Spring 框架

当咱们搞清楚控制反转和依赖注入的概念后，就能够顺带了解一下大名鼎鼎的 Spring 框架。控制反转是 Spring 框架的核心，贯穿始终。Spring 中依赖注入有两种实现方式：set 方式（传值方式）和构造器方式（引用方式）。

首先，咱们须要在 pom.xml 文件中加入 Spring 的依赖项，代码以下所示：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.2.RELEASE</version>
</dependency>

其次，咱们将 Laowang 类修改成以下内容：

public class Laowang {
    private Heshang saodiseng;

    public Laowang(Heshang saodiseng) {
        this.saodiseng = saodiseng;
    }
    public void mingling() {
       this.saodiseng.saodi();
    }
}

而后，咱们建立一个 Spring 的配置文件 application.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 id="laowang" class="com.cmower.java_demo.ioc.Laowang">
    <constructor-arg ref="saodiseng" />
  </bean>

  <bean id="saodiseng" class="com.cmower.java_demo.ioc.Xiaosan" />

</beans>

经过 元素配置了两个对象，一个老王主持，一个小三和尚，使用 元素将小三和尚做为老王主持的构造参数。

准备工做完成之后，咱们来测试一下，代码示例以下：

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        Laowang laowang = (Laowang) context.getBean("laowang");
        laowang.mingling();
    }

}

你看，咱们将控制权交给了 IoC 框架 Spring，这样也能够完美的解决代码耦合度较紧的问题。

0五、最后

总结一下：

1）控制反转是一种在软件工程中解耦合的思想，把控制权交给了第三方，在运行的时候由第三方决定将具体的依赖对象“注入”到调用类的对象中。

2）依赖注入能够做为控制反转的一种实现方式，将实例变量传入到一个对象中去。

3）经过 IoC 框架，类 A 依赖类 B 的强耦合关系能够在运行时经过容器创建，也就是说把建立 B 实例的工做移交给容器，类 A 只管使用就能够。

 

https://github.com/itwanger/JavaBooks