目录

一、引言：

二、概述：

三、举例：

“简单工厂”：

依赖倒置：

四、问题来了

五、在spring中

---

一、引言：

设计模式的六大原则有：

Single Responsibility Principle：单一职责原则
Open Closed Principle：开闭原则
Liskov Substitution Principle：里氏替换原则
Law of Demeter：迪米特法则
Interface Segregation Principle：接口隔离原则
Dependence Inversion Principle：依赖倒置原则
把这六个原则的首字母联合起来（两个 L 算做一个）就是 SOLID （solid，稳定的）。六大原则是设计模式的基石，这篇文章中，我们来看一下依赖倒置原则。

二、概述：

依赖倒置原则是：

1、高层模块不应该依赖低层模块。两个都应该依赖抽象；

2、抽象不应该依赖细节。细节应该依赖抽象；

 

三、举例：

以《大话设计模式》中，大鸟要求小菜实现计算机加减乘除功能为例

“简单工厂”：

运算类 Operation

public class Operation {private double numberA = 0;private double numberB = 0;public double getResult() {double result = 0;return result;}public double getNumberA() {return this.numberA;}public void setNumberA(double numberA) {this.numberA = numberA;}public double getNumberB() {return numberB;}public void setNumberB(double numberB) {this.numberB = numberB;}}

加法类 OperationAdd

public class OperationAdd extends Operation {@Overridepublic double getResult() {double result;result = getNumberA() + getNumberB();return result;}
}

减法类 OperationSub

public class OperationSub extends Operation {@Overridepublic double getResult() {double result;result = getNumberA() - getNumberB();return result;}
}

 

乘法类  OperationMul

public class OperationMul extends Operation {@Overridepublic double getResult() {double result;result = getNumberA() * getNumberB();return result;}
}

除法类  OperationDiv

public class OperationDiv extends Operation {@Overridepublic double getResult() {double result;if (getNumberB() == 0) {System.out.println("除数不能为0");return 0;}result = getNumberA() / getNumberB();return result;}
}

简单工厂类 OperationFactory

public class OperationFactory {public static Operation createOperate(String operate) {Operation oper = null;switch (operate) {case "+":oper = new OperationAdd();break;case "-":oper = new OperationSub();break;case "*":oper = new OperationMul();break;case "/":oper = new OperationDiv();break;}return oper;}
}

main 方法

public static void main(String[] args) {Operation oper;oper = OperationFactory.createOperate("+");oper.setNumberA(1);oper.setNumberB(2);double result = oper.getResult();System.out.println(result);}

在这段代码中，可以看出，实现加法功能，加法工厂（高层）需要调用加法实现（低层），在main方法中，通过传入“+”，在工厂中生成实现类。此时如果增加“求平方”的功能。添加子类的同时，需要修改OperationFactory类。上层依赖下层实现。

依赖倒置：

使用依赖倒置原则，试着解决下这个问题。以工厂方法模式为例：

在“简单工厂”的基础上，加上抽象工厂。

抽象接口：IFactory

public interface IFactory {Operation createOperation();
}

加法工厂类：AddFactory（实现抽象接口）

public class AddFactory implements IFactory{@Overridepublic Operation createOperation() {return new OperationAdd();}
}

减法工厂类： SubFactory（实现抽象接口）

public class SubFactory implements IFactory {@Overridepublic Operation createOperation() {return new OperationSub();}
}

乘法工厂类：OperationMul（实现抽象接口）

public class MulFactory implements IFactory {@Overridepublic Operation createOperation() {return new OperationMul();}
}

除法工厂类：DivFactory（实现抽象接口）

public class DivFactory implements IFactory{@Overridepublic Operation createOperation() {return new OperationDiv();}
}

main 方法：

public static void main(String[] args) {IFactory factory = new AddFactory();Operation oper = factory.createOperation();oper.setNumberA(1);oper.setNumberB(2);double result = oper.getResult();System.out.println(result);
}

加入工厂方法模式，最直观的感受是：代码多了。

从main方法可以看出，工厂（高层）不直接调用具体的子类（低层），而是工厂和子类都依赖抽象接口，工厂只需要调用抽象接口，将具体实现延迟到了子类。此时如果增加“求平方”的功能，只需要新增实现类，实现抽象接口IFactory即可。实现了依赖倒置。

四、对比

1、工厂方法中，父类依赖抽象不依赖具体，那在哪里决定生成哪个子类？

换句话说：IFactory factory = new AddFactory();

main方法中的这段代码，应该写在哪里？

答案是，这段代码，可以任何形式由调用者传入，可以写在具体调用者的事件下，也可以写在配置文件中。调用者只需“告诉”程序要实现什么功能，具体交给子类实现。

2、两种方式都能实现功能，使用依赖倒置的好处是什么？

1）高层和低层都依赖抽象，低层修改不影响高层，实现解耦合，增加了低层的可扩展性；

2）高层仅需考虑调用哪个接口，无需关注具体实现，由低层实现，低层功能内聚；

 

五、在spring中

       IFactory factory = new AddFactory();

       其实，这段代码，spring帮我们实现了。spring的IOC容器就是工厂，生成各种功能工厂，高层根据功能选择生成哪个工厂。低层是实现类bean，可通过配置，注解等方式，注入到工厂中。高层通过反射从spring工厂中获取bean；bean依赖spring容器，注入到容器中，交给容器管理。spring IOC容器，将调用和实现解耦，使高层和低层都面向了spring IOC容器。