设计模式之依赖倒转原则

一  原理 

依赖倒置原则又称依赖倒置原则：

抽象不应该依赖细节，细节应该依赖于抽象。说白了，就是针对接口编程，不要针对实现编程。

依赖倒置原则包含三层含义：

1)高层模块不应该依赖低层模块，两者都应该依赖其抽象；

2)抽象不应该依赖细节;

3)细节应该依赖抽象。

看了上面的解释相信大家会和我一样会有一些疑问在脑海里(你存在我深深的脑海里)下面来详细说一说吧：

1)为什么要针对接口编程，而不是针对实现编程呢？

很简单的一个例子，我们现在使用的电脑有各式的品牌，联想、神舟、戴尔等等，

电脑需要用到鼠标，键盘；假设鼠标、键盘是针对某一个品牌的机器实现去做的话，那么我们将会遇到什么问题呢？

那么我们市面上的键盘和鼠标就都是各式各样的，有一天鼠标，或键盘坏了，我们要怎么去买呢？难道记住这个电脑是什么品牌，什么型号，还有什么类型的去买么？这样会疯掉的。现在我们的电脑基本上都是使用USB接口的了，无论是键盘也好，鼠标也好，我们只要买USB接口的就可以使用了，同时，使用USB接口还可以有其他的扩展，只要实现了，这个接口，实现怎么样都没关系，例如，实现了USB接口的小台灯，只要接上USB线就可以照明了；又如实现了USB

接口的充电器，接到我们的电脑上就可以充电了。 

2)高层模块不应该依赖低层模块，两者都应该依赖其抽象又如何理解呢？这个问题也可以这么问：为什么要叫倒置(倒转)呢？

在面向过程的开发中，为了使用常用的代码可以复用，一般都会把这些常用的代码写成许许多多函数的程序库，这样我们做新项目的时候，就去调用这些函数就可以了。

例如：我们做的项目大多要访问数据库，所以我们就把数据库的代码写成了函数，每次做新项目时就去调用这些函数，这也就是高层依赖于低层模块了。

问题就出现在这里了，我们在做新项目的时候，会发现业务逻辑的高层模块是一样的，我们希望能重用这些高层模块，但是这些高层模块和低层模块的数据库绑定在一起了，这样我们就没办法复用这些高层模块了，这样就。

如果我们的高层模块和低层模块都依赖于抽象，具体一点就是依赖于接口或抽象类，只要接口够稳定，那么任何一个的更改都不用担心其他受到影响了。

3)为什么依赖了抽象的接口或是抽象类，就不怕更改了呢？要解决这个问题，先看看里氏替换原则。

里氏替换原则：

一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化；

简单的说：子类型必须能够替换掉它们的父类型。例如：企鹅在生物学分类上是属于鸟的，但是在编程中，企鹅就不能以父类的(鸟)的身份出现。

假设有一个鸟的父类，拥有一个会飞的方法fly()，我们是不能让企鹅继承于鸟的，这样当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正的被复用，

而子类也能够在父类的基础上添加新的行为。例如：猫是继承动物类的，以动物的身份拥有吃、喝、跑、叫等行为，

可当某一天，我们需要狗、牛、羊也拥有类似的行为，由于它们都是继承于动物，所以除了更改实例化的地方，程序其他地方就需要改变了。

正是由于子类型的可替换性才使得使用父类类型在的模块在无需修改的情况下就可以扩展。咱们来看看UML图：

高层模块依赖于接口或抽象类，低层模块实现接口或抽象类。依赖倒置原则其实就是谁也不依靠谁，除了约定的接口，这样大家都可以灵活自由了。

二 案例

背景1：公司是福特和本田公司的金牌合作伙伴，现要求开发一套自动驾驶系统，只要汽车上安装该系统就可以实现无人驾驶，该系统可以在福特和本田车上使用，只要这两个品牌的汽车使用该系统就能实现自动驾驶。于是有人做出了分析如图一。

　　对于图一分析：我们定义了一个AutoSystem类，一个FordCar类，一个HondaCar类。FordCar类和HondaCar类中各有三个方法:Run(启动Car)、Turn(转弯Car)、Stop(停止Car)，当然了一个汽车肯定不止这些功能，这里只要能说明问题即可。AutoSystem类是一个自动驾驶系统，自动操纵这两辆车。

　　代码实现：

　　public class HondaCar {

Java代码  

1. <span style="font-size: medium;">       public void Run()  {  
2. 　　          Console.WriteLine("本田开始启动了");  
3. 　　      }  
4. 　　      public void Turn()  {  
5. 　　          Console.WriteLine("本田开始转弯了");  
6. 　　      }  
7. 　　      public void Stop()  {  
8. 　　          Console.WriteLine("本田开始停车了");  
9. 　　      }  
10. 　　}  
11. 　　public class FordCar  
12. 　　{  
13. 　　      public void Run() {  
14. 　　          Console.WriteLine("福特开始启动了");  
15. 　　      }  
16. 　　      public void Turn() {  
17. 　　          Console.WriteLine("福特开始转弯了");  
18. 　　      }  
19. 　　      public void Stop() {  
20. 　　          Console.WriteLine("福特开始停车了");  
21. 　　          }  
22. 　　}  
23. 　　public class AutoSystem  
24. 　　{  
25. 　　      public enum CarType{ Ford, Honda };  
26. 　　      private HondaCar hcar = new HondaCar();  
27. 　　      private FordCar fcar = new FordCar();  
28. 　　      private CarType type;  
29. 　　      public AutoSystem(CarType type) {  
30. 　　          this.type = type;  
31. 　　      }  
32. 　　      private void RunCar() {  
33. 　　          if (type == CarType.Ford) {  
34. 　　              fcar.Run();  
35. 　　          }  
36. 　　          else {  
37. 　　              hcar.Run();  
38. 　　          }  
39. 　　      }  
40. 　　      private void TurnCar() {  
41. 　           if (type == CarType.Ford) {  
42. 　　              fcar.Turn();  
43. 　　          }  
44. 　　          else {  
45. 　　              hcar.Turn();  
46. 　　          }  
47. 　　      }  
48. 　　          private void StopCar() {  
49. 　               if (type == CarType.Ford) {  
50. 　　                  fcar.Stop();  
51. 　　              }  
52. 　　              else {  
53. 　　                  hcar.Stop();  
54. 　　              }  
55. 　　          }  
56. 　　}</span>  

 

　　代码分析：上面的程序确实能够实现针对Ford和Honda车的无人驾驶，但是软件是在不断变化的，软件的需求也在不断的变化。

　　背景2：公司的业务做大了，同时成为了通用、三菱、大众的金牌合作伙伴，于是公司要求该自动驾驶系统也能够安装在这3种公司生产的汽车上。于是我们不得不变动AutoSystem：

　　public class AutoSystem

Java代码  

1. <span style="font-size: medium;">　　{  
2. 　　public enum CarType { Ford, Honda ,Bmw};  
3. 　　HondaCar hcar = new HondaCar();  
4. 　　FordCar fcar = new FordCar();  
5. 　　BmwCar bcar = new BmwCar();  
6. 　　private CarType type;  
7. 　　public AutoSystem(CarType type)  
8. 　　{  
9. 　　this.type = type;  
10. 　　}  
11. 　　private void RunCar()  
12. 　　{  
13. 　　if (type == CarType.Ford)  
14. 　　{  
15. 　　fcar.Run();  
16. 　　}  
17. 　　else if (type == CarType.Honda)  
18. 　　{  
19. 　　hcar.Run();  
20. 　　}  
21. 　　else if (type == CarType.Bmw)  
22. 　　{  
23. 　　bcar.Run();  
24. 　　}  
25. 　　}  
26. 　　private void TurnCar()  
27. 　　{  
28. 　　if (type == CarType.Ford)  
29. 　　{  
30. 　　fcar.Turn();  
31. 　　}  
32. 　　else if (type == CarType.Honda)  
33. 　　{  
34. 　　hcar.Turn();  
35. 　　}  
36. 　　else if (type == CarType.Bmw)  
37. 　　{  
38. 　　bcar.Turn();  
39. 　　}  
40. 　　}  
41. 　　private void StopCar()  
42. 　　{  
43. 　　if (type == CarType.Ford)  
44. 　　{  
45. 　　fcar.Stop();  
46. 　　}  
47. 　　else if (type == CarType.Honda)  
48. 　　{  
49. 　　hcar.Stop();  
50. 　　}  
51. 　　else if (type == CarType.Bmw)  
52. 　　{  
53. 　　bcar.Stop();  
54. 　　}  
55. 　　}</span>  

 

　　}分析：这会给系统增加新的相互依赖。随着时间的推移，越来越多的车种必须加入到AutoSystem中，这个“AutoSystem”模块将会被if/else语句弄得很乱，而且依赖于很多的低层模块，只要低层模块发生变动，AutoSystem就必须跟着变动，

　　它最终将变得僵化、脆弱。

　　导致上面所述问题的一个原因是，含有高层策略的模块，如AutoSystem模块，依赖于它所控制的低层的具体细节的模块（如HondaCar()和FordCar()）。如果我们能够找到一种方法使AutoSystem模块独立于它所控制的具体细节，那么我们就可以自由地复用它了。我们就可以用这个模块来生成其它的程序，使得系统能够用在需要的汽车上。OOD给我们提供了一种机制来实现这种“依赖倒置”。

这儿有一个“AutoSystem”类，它包含一个“ICar”接口。这个“AutoSystem”类根本不依赖于“FordCar”和“HondaCar”。所以，依赖关系被“倒置”了：“AutoSystem”模块依赖于抽象，那些具体的汽车操作也依赖于相同的抽象。

　　于是可以添加ICar

　　

public interface ICar

Java代码  

1. <span style="font-size: medium;">　　{  
2. 　　void Run();  
3. 　　void Turn();  
4. 　　void Stop();  
5. 　　}  
6. 　　public class BmwCar:ICar  
7. 　　{  
8. 　　public void Run()  
9. 　　{  
10. 　　Console.WriteLine("宝马开始启动了");  
11. 　　}  
12. 　　public void Turn()  
13. 　　{  
14. 　　Console.WriteLine("宝马开始转弯了");  
15. 　　}  
16. 　　public void Stop()  
17. 　　{  
18. 　　Console.WriteLine("宝马开始停车了");  
19. 　　}  
20. 　　}  
21. 　　public class FordCar:ICar  
22. 　　{  
23. 　　public void Run()  
24. 　　{  
25. 　　Console.WriteLine("福特开始启动了");  
26. 　　}  
27. 　　public void Turn()  
28. 　　{  
29. 　　Console.WriteLine("福特开始转弯了");  
30. 　　}  
31. 　　public void Stop()  
32. 　　{  
33. 　　Console.WriteLine("福特开始停车了");  
34. 　　}  
35. 　　}  
36. 　　public class HondaCar:ICar  
37. 　　{  
38. 　　public void Run()  
39. 　　{  
40. 　　Console.WriteLine("本田开始启动了");  
41. 　　}  
42. 　　public void Turn()  
43. 　　{  
44. 　　Console.WriteLine("本田开始转弯了");  
45. 　　}  
46. 　　public void Stop()  
47. 　　{  
48. 　　Console.WriteLine("本田开始停车了");  
49. 　　}  
50. 　　}  
51. 　　public class AutoSystem  
52. 　　{  
53. 　　private ICar icar;  
54. 　　public AutoSystem(ICar icar)  
55. 　　{  
56. 　　this.icar = icar;  
57. 　　}  
58. 　　private void RunCar()  
59. 　　{  
60. 　　icar.Run();  
61. 　　}  
62. 　　private void TurnCar()  
63. 　　{  
64. 　　icar.Turn();  
65. 　　}  
66. 　　private void StopCar()  
67. 　　{  
68. 　　icar.Stop();  
69. 　　}  
70. 　　}</span>  

 

现在AutoSystem系统依赖于ICar 这个抽象，而与具体的实现细节HondaCar、FordCar、BmwCar无关，所以实现细节的变化不会影响AutoSystem。对于实现细节只要实现ICar 即可，即实现细节依赖于ICar 抽象。

　　

 

综上：

　　一个应用中的重要策略决定及业务模型正是在这些高层的模块中。也正是这些模型包含着应用的特性。但是，当这些模块依赖于低层模块时，低层模块的修改将会直接影响到它们，迫使它们也去改变。这种境况是荒谬的。应该是处于高

　　层的模块去迫使那些低层的模块发生改变。应该是处于高层的模块优先于低层的模块。无论如何高层的模块也不应依赖于低层的模块。而且，我们想能够复用的是高层的模块。通过子程序库的形式，我们已经可以很好地复用低层的模块了。当高层的模块依赖于低层的模块时，这些高层模块就很难在不同的环境中复用。但是，当那些高层模块独立于低层模块时，它们就能很简单地被复用了。这正是位于框架设计的最核心之处的原则。

 

　　总结：依赖倒置原则

　　A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

　　B.抽象不应该依赖于具体，具体应该依赖于抽象。