设计模式 - 16.职责链模式 [行为型模式]

为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

避免递归过深

import abc

class IClsA(metaclass=abc.ABCMeta):

    def __init__(self):
        self._next = None

    @property
    def next(self):
        return self._next

    @next.setter
    def next(self, next):
        self._next = next

    @abc.abstractmethod
    def handle_request(self, param):
        pass


class ClsA1(IClsA):
    def handle_request(self, param):
        if param=='1':
            print('deal', self.__class__.__name__)
            return self
        elif self.next is not None:
            return self.next.handle_request(param)
        else:
            print('end')
            return None

class ClsA2(IClsA):
    def handle_request(self, param):
        if param=='2':
            print('deal', self.__class__.__name__)
            return self
        elif self.next is not None:
            return self.next.handle_request(param)
        else:
            print('end')
            return None

class ClsA_X(IClsA):
    def __init__(self, key):
        super().__init__()
        self.key = key

    def handle_request(self, param):
        if param == self.key:
            print('deal', self.__class__.__name__)
            return self
        elif self.next is not None:
            return self.next.handle_request(param)
        else:
            print('end')
            return None

if __name__=='__main__':
    # a1 = ClsA1()
    # a2 = ClsA2()
    # a1.next = a2
    # print(a1.handle_request('2'))
    
    a0 = ClsA_X(0)
    a1 = a0
    for k in range(1,10000):
        aN = ClsA_X(k)
        a1.next = aN
        a1 = aN
    print(a0.handle_request(9999))