背景
这几天组内的人一起学习DDD，里面再次提到了依赖倒置原则，在这学习过程中，大家又讨论了一下依赖倒置原则。
说明
采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定性，减少并行开发引起的风险，提高代码的可读性和可维护性。
那么依赖倒置原则是什么呢？
高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。
抽象不应该依赖于具体，具体应该依赖于抽象。
High-level modules should not depend on low-level modules. Both should depend on abstractions.
Abstractions should not depend on details. Details should depend on abstractions.
依赖倒置原则是Robert C. Martin在1996年为“C++Reporter”所写的专栏Engineering Notebook的第三篇，后来加入到他在2002年出版的经典著作“Agile Software Development, Principles,Parrerns,and Practices”一书中。
例子
下面是一个违反依赖倒置原则的示例。我们有高层类Manager，还有底层类Worker。现在我们需要在应用程序中增加一个新模块，以模拟由雇用新专业工人决定的公司结构变化，我们为此创建了一个新的类SuperWorker。
让我们假设Manager类相当复杂，包含非常复杂的逻辑。现在我们必须改变它，以引入新的SuperWorker。让我们看看缺点：
- 我们必须更改类
Manager（记住这是一个复杂的类，这将涉及时间和精力进行更改）。 Manager类中的某些功能可能会受到影响。- 单元测试应重做。
所有这些问题都可能需要很多时间来解决，并且它们可能会在旧功能中诱发新的错误。如果应用程序是按照依赖倒置原则来设计的，情况就不一样了。这意味着我们设计Manager类时，IWorker 接口和实现 IWorker 接口的Worker类即可。当我们需要添加SuperWorker时，我们要做的就是为此实现IWorker接口。现有类没有其他更改。
// Dependency Inversion Principle - Bad example
class Worker {
public void work() {
// ....working
}
}
class Manager {
Worker worker;
public void setWorker(Worker w) {
worker = w;
}
public void manage() {
worker.work();
}
}
class SuperWorker {
public void work() {
//.... working much more
}
}
以下是支持依赖性反转原则的代码。在这个新设计中，通过IWorker 界面添加了一个新的抽象层。现在，上述代码中的问题已经解决（考虑到高层逻辑没有变化）：
- 在添加
SuperWorker时，Manager类不需要更改。 - 由于我们不会改变它，因此最大限度地降低影响
Manager器类中当前旧功能的风险。 - 无需重做
Manager类的单元测试。
// Dependency Inversion Principle - Good example
interface IWorker {
public void work();
}
class Worker implements IWorker{
public void work() {
// ....working
}
}
class SuperWorker implements IWorker{
public void work() {
//.... working much more
}
}
class Manager {
IWorker worker;
public void setWorker(IWorker w) {
worker = w;
}
public void manage() {
worker.work();
}
}
当然，使用此原则意味着加大努力，将导致更多的类和接口来维护，换句话说，在更复杂的代码，但更灵活。不应盲目地将这一原则应用于每个类或每个模块。如果我们的类功能将来更有可能保持不变，则无需应用此原则。
“倒置”的解释
《设计模式之禅》中对“倒置”的解释：
讲了这么多，估计大家对“倒置”这个词还是有点不理解，那到底什么是“倒置”呢？我们先说“正置”是什么意思，依赖正置就是类间的依赖是实实在在的实现类间的依赖，也就是面向实现编程，这也是正常人的思维方式，我要开奔驰车就依赖奔驰车，我要使用笔记本电脑就直接依赖笔记本电脑，而编写程序需要的是对现实世界的事物进行抽象，抽象的结果就是有了抽象类和接口，然后我们根据系统设计的需要产生了抽象间的依赖，代替了人们传统思维中的事物间的依赖，“倒置”就是从这里产生。
可以这么解释：高层A依赖于低层B修改为高层A依赖于抽象层C，低层B依赖于抽象层C，而抽象层C是低层B的高层，所以说低层依赖于高层了，即倒置。但是A依赖于C，这个不能说是低层依赖于高层吧，A和C谁高谁低是这么判定的？因为抽象层C是属于A层的，即由A层来规定抽象层C的接口规范，而B是对C的实现，因此通过引入C层实现了“依赖倒置”。
总结
一句话：依赖倒置原则的核心就是面向抽象（抽象类或者接口）编程。
设计类结构的方法是从高层模块到底层模块：
高层类 --> 抽象层 --> 底层类
参考资料
- 《Agile Software Development: Principles, Patterns, and Practices》 Robert C·Martin
- 《实现领域驱动设计》 Vaughn Vernon
- https://www.oodesign.com/dependency-inversion-principle.html
- https://q.cnblogs.com/q/72496/