[TOC]

image

背景

这几天组内的人一起学习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