简单代码演示控制反转IOC和依赖注入DI

(Updated: )
技术
,

ioc（Inversion of Control）

控制反转，也可以称为依赖倒置，即当A要调用B时，A无需主动获取，会有人主动把B送过来供A使用，以减少在A的代码中存在B，导致模块间的高度耦合。

正常的代码控制流程

1.创建一个接口Car

1
2
3
public interface Car {
  void go();
}

2.定义两种车实现接口car

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Benz implements Car {

  public void go() {
    System.out.println("benz go......");
  }
}

public class BMW implements Car{

  public void go() {
    System.out.println("bmw go......");
  }
}

3.人要开车

1
2
3
4
5
6
7
8
9
public class Person {

  Car car=new Benz();

  void DriveCar(){
    System.out.println("begin drive");
    car.go();
  }
}
  • 这种方式是我们常见的代码控制流程，人想要开车，需要自己实例化，且这个人只能开一种车。
  • 如何让他可以想开什么车就开什么车呢？

    通过依赖注入

依赖注入的方式DI（Dependency Injection）

  • 依赖注入是实现控制反转的方式之一。
  • 看一下修改后的person类
1
2
3
4
5
6
7
8
9
10
11
12
public class Person {

  Car car=null;
  public Person(Car car){
    this.car=car;
  }

  void driveCar(){
    System.out.println("begin drive");
    car.go();
  }
}

现在的Person类已经不自己实例化车的对象了，而是通过构造函数来获得车的对象，所以，这个类就可以开各种车了，只要这个车实现了Car接口就可以。看一下如何使用Person类

1
2
3
4
public static void main(String[] args) {
  Person person=new Person(new Benz());
  person.driveCar();
}

现在的Person类可以开不止一种车，只要你通过构造函数传递进来。在这个例子中，Car对象就是Person类的依赖，当我们实例化Person类时，将一个Car的实例传递给Person类，就是依赖注入，我们的Person类从而实现了控制反转。
控制反转到底反转了什么？有种说法是这样的：所谓控制反转，反转的是获取对象依赖的过程。控制权反转后，获取依赖对象的过程由自身管理变为由IOC容器注入。

Spring实现依赖注入的方式

在上面的这行代码中Person p=new Person(new Benz());，我们通过手动的方式new了一个Benz()的对象，然后将其注入到Person类中。而Spring不这么干，因为Spring觉得，你这行代码实例化了一个具体的Benz类，如果你以后想要在这里实例化一个BMW类的话，岂不是要修改代码？那我干脆写到配置文件里好了，即便你将来要该注意，至少不需要修改代码，于是就有了下面的配置

1
2
3
4
5
6
<beans>
  <bean id="car" class="com.XXX.Benz" />
  <bean id="person" class="com.XXX.Person" >
    <property name="car" ref="car" />
  </bean>
</beans>

从配置文件中获取Person类的对象时，car对象会被自动装配进来，而person对象不需要关心到底是哪个具体的类被传递进来了。所以，Spring作为一个IOC框架主要做了两步：创建对象和组装对象之间的关系。