Python实现设计模式--08.中介者模式（Mediator Pattern）

中介者模式就像代理模式的高级版，代理模式只代理一方，而中介者代理两方或者更多的角色。

场景案例：公司的3个部门，销售、采购、库存相互协作，他们之间有如下约定：

• 销售部门的成绩决定是否要采购
• 库存不足的情况下，销售部门停止销售，采购部门尽快采购
• 库存要清仓，通知采购部门停止采购，销售部门打折出售

这里看到3者之间都是相互联系的，如果用通常的做法定义3个类，会发现他们之间耦合非常大，读者有兴趣可以尝试下。下面我使用中介者模式来实现它。

抽象中介者类：

# 抽象中介者类
class AbstractMediator:
    # 中介者管理的同事列表
    _colleagues = {}

    # 增加一个要被管理的同事
    def add_colleague(self, name, colleague):
        self._colleagues[name] = colleague
        colleague.set_mediator(self)

    # 中介者最重要的事件方法，处理多个同事对象之间的关系
    def execute(self, method, args):
        pass

抽象同事类：

# 抽象同事类，只定义关联的中介者，继承此类的子类共用一个中介者
class AbstractColleague:
    _mediator = None

    def set_mediator(self, _mediator):
        self._mediator = _mediator

库存类：

# 库存类
class Stock(AbstractColleague):
    # 库存数量，刚开始有10台
    __number = 10

    # 获取库存余量
    def get_stock_number(self):
        return self.__number

    # 增加库存
    def increase(self, number):
        self.__number += number

    # 减少库存
    def decrease(self, number):
        self.__number -= number

    # 清仓处理
    def clear_stock(self):
        print('开始清仓，当前库存数量：%d' % self.__number)
        self._mediator.execute('stock.clear', None)

采购类：

# 采购类
class Purchase(AbstractColleague):
    # 采购多少台电脑
    def buy_computer(self, number):
        self._mediator.execute('purchase.buy', number)

    # 停止采购
    def stop_buy(self):
        print('停止采购啦')

销售类：

# 销售类
class Sale(AbstractColleague):
    # 销售电脑
    def sell_computer(self, number):
        self._mediator.execute('sale.sell', number)
        print('销售卖了%d台电脑' % number)

    # 获取销售情况（0-100分）
    def get_sale_score(self):
        score = random.randint(0, 100)
        print('当前销售分数：%d' % score)
        return score

    # 打折处理
    def off_sale(self):
        self._mediator.execute('sale.offSale', None)

下面是关键的中介者类：

# 具体中介者
class Mediator(AbstractMediator):
    # 重写抽象类的事件方法
    def execute(self, method, args):

        if method == 'purchase.buy':
            self.buy_computer(args)
        elif method == 'sale.sell':
            self.sell_computer(args)
        elif method == 'sale.offSale':
            self.off_sale()
        elif method == 'stock.clear':
            self.clear_stock()

    # 购买电脑
    def buy_computer(self, number):
        __sale = self._colleagues['sale']
        __stock = self._colleagues['stock']
        score = __sale.get_sale_score()
        if score > 80:
            print('销售情况不错，采购电脑%d台' % number)
            __stock.increase(number)
        elif score >= 30:
            print('销售情况凑合，采购电脑%d台' % (number / 2))
            __stock.increase(number / 2)
        else:
            print('销售情况稀烂，不买了')

    # 销售电脑
    def sell_computer(self, number):
        __stock = self._colleagues['stock']
        __purchase = self._colleagues['purchase']
        if __stock.get_stock_number() < number:
            print('库存不足%d，急需要采购' % number)
            __purchase.buy_computer(number)
        __stock.decrease(number)

    # 打折销售
    def off_sale(self):
        __stock = self._colleagues['stock']
        print('折价销售%d台电脑' % __stock.get_stock_number())
        __stock.decrease(__stock.get_stock_number())

    # 清仓处理
    def clear_stock(self):
        __purchase = self._colleagues['purchase']
        __sale = self._colleagues['sale']
        __purchase.stop_buy()
        __sale.off_sale()

构造场景：

if __name__ == '__main__':
    purchase = Purchase()
    sale = Sale()
    stock = Stock()

    mediator = Mediator()
    mediator.add_colleague("purchase", purchase)
    mediator.add_colleague("sale", sale)
    mediator.add_colleague("stock", stock)
    print()

    buy_number = random.randint(50, 100)
    print('---------采购人员计划采购电脑' + str(buy_number) + '台---------')
    purchase.buy_computer(buy_number)
    print('当前库存数量为：%d' % stock.get_stock_number())
    print()

    sell_number = random.randint(20, 80)
    print('---------销售人员要销售电脑' + str(sell_number) + '台---------')
    sale.sell_computer(sell_number)
    print('当前库存数量为：%d' % stock.get_stock_number())
    print()

    print('---------库房清仓---------')
    stock.clear_stock()
    print('当前库存数量为：%d' % stock.get_stock_number())
    print()

执行结果：

---------采购人员计划采购电脑59台---------
当前销售分数：80
销售情况凑合，采购电脑29台
当前库存数量为：39

---------销售人员要销售电脑49台---------
库存不足49，急需要采购
当前销售分数：68
销售情况凑合，采购电脑24台
销售卖了49台电脑
当前库存数量为：15

---------库房清仓---------
开始清仓，当前库存数量：15
停止采购啦
折价销售15台电脑
当前库存数量为：0

中介者模式往往在框架的设计层面上才用得到，比如著名的MVC（这里的C即Controller，就是一个中介者）。平时业务代码很少出现这么高的耦合情况，如果滥用的话，反而会使项目变的更复杂。