Java 依赖倒置 控制反转

软件开发六大设计原则 合称SOLID

依赖倒置原则也是其中一个

依赖倒置原则定义：

1. 上层模块不应该依赖底层模块，它们都应该依赖于抽象。
2. 抽象不应该依赖于细节，细节应该依赖于抽象。

比较晦涩，如同软件行业中的哲学
其中上层模块与下层模块

• 业务层 逻辑层 数据层
  业务层中的软件真正要进行的操作，就是做什么，或者叫面向用户层
  逻辑层是软件现阶段为了业务层的需求提供的实现细节，也就是怎么做
  数据层指业务层和逻辑层所需要的数据模型

什么是抽象和细节？

抽象如其名字一样，是一件很抽象的事物。抽象往往是相对于具体而言的，具体可以被称为细节，当然也可以被称为具象。
比如 抽象可以是画，而国画，油画，素描就是具体
具体映射到软件开发中，抽象可以是接口或者抽象类形式

public interface Driveable{
    void drive();
}
class Bike implements Driveable{
    @Override           注解 标识子类对父类方法的重载，在没有abstract
    public void drive() {
        // TODO Auto-generated method stub
        System.out.println("Bike drive.");
    }

}

class Car implements Driveable{

    @Override
    public void drive() {
        // TODO Auto-generated method stub
        System.out.println("Car drive.");
    }

}

Driveable就是抽象，然后 bike car 就是细节。

依赖倒置的好处

比如一个类person，在传统编码中是要什么给什么，引入什么对象
要出门，则三种交通工具都引入，作为成员变量。
这就是依赖于细节了，而且在交通方式变更中开销会很大。

public class Person {

//  private Bike mBike;
//  private Car mCar;
//  private Train mTrain;
    private Driveable mDriveable;

    public Person() {
        //mBike = new Bike();
        //mCar = new Car();
        //mTrain = new Train();
        mDriveable = new Train();
    }

    public void chumen() {
        System.out.println("出门了");
        //mBike.drive();
        //mCar.drive();
        //mTrain.drive();
        mDriveable.drive();
    }

}
所以 倒置过来 加入一层抽象
让人依赖于抽象，改，只需要改抽象，引入只需要引入抽象 再实例化即可

抽象不应该依赖细节，细节应该依赖于抽象

什么是控制反转

Inversion of Control

public class Person {

    private Driveable mDriveable;

    public Person(Driveable driveable) {

        this.mDriveable = driveable;
    }

    public void chumen() {
        System.out.println("出门了");

        mDriveable.drive();
    }

}
也就是说 不让person创建对象 而是留一个接口，让外侧创建实例并传递进去

把内部依赖的创建权力移交给外部，只关注依赖提供的功能，但并不关心依赖的创建
IoC离不开IoC的容器，也就是实例化抽象的地方

public class Restaurant {

    public static void peican(int orderid,int flowid) {
        WaimaiYuan person;
        Food food;

        if ( orderid == 0) {
            food = new PijiuYa();
        } else {
            food = new DuojiaoYutou();
        }

        if ( flowid % 2 == 0 ) {
            person = new Xiaohuozi(food);
        } else {
            person = new XiaoGuniang(food);
        }

        person.songWaiMai();

    }

}
比如例子中的Restaurant就是一个Ioc容器 
配置 一词比较重要
Spring相关度比较高

IoC模式最核心的地方就是在依赖方与被依赖方之间，引入了第三方，这个第三方统称为IoC容器，因为IoC容器的介入，导致上层模块对于它的依赖的实例化控制权发生变化，也就是所谓的控制反转的意思。

依赖注入 Dependency Injection

其实也是讲我们移交出对于依赖实例化的控制权，和IoC类似，并留有接口，在需要该依赖的时候注入进去injection

• 实现依赖注入有三种方式：
  1.构造函数中注入
  2.setter方式注入
  3.接口注入

接口的存在，表明了一种依赖配置的能力

在软件框架中，读取xml配置文件，或者利用反射技术读取注解，然后根据配置信息，框架动态将一些依赖配置给特定的接口类，我们也可以说injector也依赖于接口，而不是特定的实现类，这样进一步提高了准确性与灵活性

总结

1. 依赖倒置是面向对象开发领域中的软件设计原则，它倡导上层模块不依赖于底层模块，抽象不依赖细节。
2. 依赖反转是遵守依赖倒置这个原则而提出来的一种设计模式，它引入了 IoC 容器的概念。
3. 依赖注入是为了实现依赖反转的一种手段之一。
4. 它们的本质是为了代码更加的“高内聚,低耦合”。