设计模式十一：责任链模式

什么是责任链模式

用来处理相关事务责任的一条执行链，执行链上有多个节点，每个节点都有机会（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。
原则：存在一个对象链，一开始将请求发给链中的第一个对象，对象决定其是否处理该请求，对象将请求转发给下一个对象，重复该过程，直到到达链尾。

使用场景

用于让多个对象来处理单个请求
用于预先不知道应该由哪个对象来处理某个特定请求

典型案例

售水机,钞票放入后传递到内部分类到恰当的容器。退币时，从恰当的容器获取钱币返回到出口。

实例代码

#ATM找零（多个处理一个）
class Money:
    def __init__(self,total):
        self.total = total
        self.money_array = [0,0,0,0,0]

    def __str__(self):
        return 'Hundred : {},\n Fifty : {},\n Ten : {},\n Five : {},\n One : {}'.format(self.money_array[0],self.money_array[1],self.money_array[2],self.money_array[3],self.money_array[4])

class ATM:
    def __init__(self,nextodd):
        self.nextodd = nextodd
        
    def handlemoney(self,money):
        self.nextodd.handlemoney(money)
        

class Hundred(ATM):
    def handlemoney(self,money):
        odd = money.total % 100
        num = int(money.total / 100)
        money.money_array[0] = num
        money.total = odd
        self.nextodd.handlemoney(money)

class Fifty(ATM):
    def handlemoney(self,money):
        odd = money.total % 50
        num = int(money.total / 50)
        money.money_array[1] = num
        money.total = odd
        self.nextodd.handlemoney(money)

class Ten(ATM):
    def handlemoney(self,money):
        odd = money.total % 10
        num = int(money.total / 10)
        money.money_array[2] = num
        money.total = odd
        self.nextodd.handlemoney(money)

class Five(ATM):
    def handlemoney(self,money):
        odd = money.total % 5
        num = int(money.total / 5)
        money.money_array[3] = num
        money.money_array[4] = odd

def main():
    money = Money(176)
    five = Five(None)
    ten = Ten(five)
    fifty = Fifty(ten) 
    hundred = Hundred(fifty)
    atm = ATM(hundred)
    atm.handlemoney(money)
    print(money)

if __name__ == "__main__":
    main()

#事件处理（预先不知哪个对象处理）

class Event:
    def __init__(self,name):
        self.name = name
    
    def __str__(self):
        return self.name

class Widget:
    def __init__(self,parent = None):
        self.parent = parent
    
    def handle(self,event):
        handler = 'handle_{}'.format(event)
        #判断实例类中是否存在相应的方法
        if hasattr(self,handler):
            method = getattr(self,handler)
            method(handler)
        #如果当前类没有相应方法则交给父类去处理
        elif self.parent:
            self.parent.handle(event)
        #如果父类也没有相应方法则交给默认方法去处理
        elif hasattr(self,'handle_default'):
            self.handle_default(event)

class MainWindow(Widget):
    def handle_close(self,event):
        print('MainWindow: {}'.format(event))

    def handle_default(self,event):
        print('MainWindow Default : {}'.format(event))

class SendDialog(Widget):
    def handle_paint(self,event):
        print('SendDialog : {}'.format(event))

class MsgText(Widget):
    def handle_down(self,event):
        print('MsgText : {}'.format(event))

def main2():
    mw = MainWindow()
    sd = SendDialog(mw)
    msg = MsgText(sd)
    for event in ('down','paint','unhandled','close'):
        evt = Event(event)
        # print('---------MainWindow---------')
        # mw.handle(evt)
        # print('---------SendDialog---------')
        # sd.handle(evt)
        print('---------MsgText---------')
        msg.handle(evt)
        print()


if __name__ == "__main__":
    main2()