一、引言：
设计模式的六大原则有：
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 { @Override public double getResult() { double result; result = getNumberA() + getNumberB(); return result; } }
减法类 OperationSub
public class OperationSub extends Operation { @Override public double getResult() { double result; result = getNumberA() - getNumberB(); return result; } }
乘法类 OperationMul
public class OperationMul extends Operation { @Override public double getResult() { double result; result = getNumberA() * getNumberB(); return result; } }
除法类 OperationDiv
public class OperationDiv extends Operation { @Override public 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{ @Override public Operation createOperation() { return new OperationAdd(); } }
减法工厂类： SubFactory（实现抽象接口）
public class SubFactory implements IFactory { @Override public Operation createOperation() { return new OperationSub(); } }
乘法工厂类：OperationMul（实现抽象接口）
public class MulFactory implements IFactory { @Override public Operation createOperation() { return new OperationMul(); } }
除法工厂类：DivFactory（实现抽象接口）
public class DivFactory implements IFactory{ @Override public 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容器。
