设计模式：依赖反转原则（Dependency inversion principle，DIP）

Question

概念说明

摘自《中文维基百科》：

在面向对象编程领域中， 依赖反转原则（Dependency inversion principle，DIP） 一种特定的解耦（传统的依赖关系创建在高层次上，而具体的策略设置则应用在低层次的模块上）形式，使得高层次的模块不依赖于低层次的模块的实现细节，依赖关系被颠倒（反转），从而使得低层次模块依赖于高层次模块的需求抽象。

该原则规定：

• 高层次的模块不应该依赖于低层次的模块，两者都应该依赖于抽象接口。
• 抽象接口不应该依赖于具体实现。而具体实现则应该依赖于抽象接口。

该原则颠倒了一部分人对于面向对象设计的认识方式。如高层次和低层次对象都应该依赖于相同的抽象接口。

应用依赖反转原则同样被认为是应用了 适配器模式（adapter pattern） 。

示例代码

假设我们有一个商店类，需要接入支付接口，一开始我们只对接了微信支付，此时的代码如下：

class Store:

    def __init__(self, user):
        self.__weChat = WeChat(user)

    def buyBottle(self, quantity):
        self.__weChat.pay(100 * quantity * 10)

    def buyMaple(self, quantity):
        self.__weChat.pay(350 * quantity * 10)


class WeChat:

    def __init__(self, user):
        self.__user = user

    def pay(self, jiao):
        print(f'{self.__user} 通过微信支付 {jiao} 角')


print('\n 微信支付\n')
store = Store('Jason Wu')
store.buyBottle(1)
store.buyMaple(1)

过了一段时间，应顾客要求，我们加入了支付宝的支付接口。此时代码如下：

class Store:

    def __init__(self, user):
        self.__user = user
        self.__aLiPay = ALiPay()

    def buyBottle(self, quantity):
        self.__aLiPay.pay(self.__user, 100 * quantity)

    def buyMaple(self, quantity):
        self.__aLiPay.pay(self.__user, 350 * quantity)


class ALiPay:

    def pay(self, user, yuan):
        print(f'{user} 通过支付宝支付 {yuan} 元')


print('\n 支付宝支付\n')
store = Store('Jason Wu')
store.buyBottle(1)
store.buyMaple(1)

我们会发现，在加入支付宝接口后，我们修改了商店类的代码。这也就意味着，我们高层次的代码依赖于低层次的 API，每当低层次的 API 改变时，都会影响到我们的高层次代码，这使得我们的代码变得不易维护，且容易出错。

下面我们采用依赖反转原则，重构我们的代码：

class Store:

    def __init__(self, payTool):
        self.__payTool = payTool

    def buyBottle(self, quantity):
        self.__payTool.pay(100 * quantity)

    def buyMaple(self, quantity):
        self.__payTool.pay(350 * quantity)


class WeChatPayTool:

    def __init__(self, user):
        self.__weChat = WeChat(user)

    def pay(self, yuan):
        self.__weChat.pay(yuan * 10)


class ALiPayTool:

    def __init__(self, user):
        self.__user = user
        self.__aLiPay = ALiPay()

    def pay(self, yuan):
        self.__aLiPay.pay(self.__user, yuan)


class WeChat:

    def __init__(self, user):
        self.__user = user

    def pay(self, jiao):
        print(f'{self.__user} 通过微信支付 {jiao} 角')


class ALiPay:

    def pay(self, user, yuan):
        print(f'{user} 通过支付宝支付 {yuan} 元')


print('\n 微信支付\n')
store = Store(WeChatPayTool('Jason Wu'))
store.buyBottle(1)
store.buyMaple(1)

print('\n 支付宝支付\n')
store = Store(ALiPayTool('Jason Wu'))
store.buyBottle(1)
store.buyMaple(1)

此时我们的代码逼格变得更高，逻辑也更加清晰，可维护性也得到了相应的提高。

参考链接

• 依赖反转原则 - 维基百科，自由的百科全书