设计模式-行为型-责任链模式

责任链模式

定义：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

角色

• 抽象处理者（Handler）
• 具体处理者（ConcreteHandler）
• 客户端（Client）

适用场景

• 有多个对象可以处理一个请求，哪个对象处理由运行时决定
• 在不明确接收者的情况下，想多个对象中的一个提交一个请求

优点

• 降低耦合度：一个对象无需知道是其他哪一个对象处理其请求
• 可以随时地增加或修改一个请求地结构，增强了给对象指派职责的灵活性。

抽象处理者：定义一个处理请示的接口；
具体处理者：处理它所负责的请求，如果可处理当前请求，则处理；如不能，则将该请求转发给它的后继者；

from abc import ABCMeta, abstractmethod


class Handler(metaclass=ABCMeta):
    def __init__(self):
        self.__successor = None

    @property
    def successor(self):
        return self.__successor

    @successor.setter
    def successor(self, succesor):
        self.__successor = succesor

    @abstractmethod
    def handle_request(self, request):
        pass


class ConcreteHandler1(Handler):
    def __init__(self):
        super().__init__()

    def handle_request(self, request: int):
        if 0 <= request < 10:
            print("{} 处理请求 {}".format(self.__class__.__name__, request))
        elif self.successor is not None:
            # 将请求传递给继任者处理
            self.successor.handle_request(request)


class ConcreteHandler2(Handler):
    def __init__(self):
        super().__init__()

    def handle_request(self, request: int):
        if 10 <= request < 20:
            print("{} 处理请求 {}".format(self.__class__.__name__, request))
        elif self.successor is not None:
            # 将请求传递给继任者处理
            self.successor.handle_request(request)


class ConcreteHandler3(Handler):
    def __init__(self):
        super().__init__()

    def handle_request(self, request: int):
        if 20 <= request < 30:
            print("{} 处理请求 {}".format(self.__class__.__name__, request))
        elif self.successor is not None:
            # 将请求传递给继任者处理
            self.successor.handle_request(request)


def main():
    h1 = ConcreteHandler1()
    h2 = ConcreteHandler2()
    h3 = ConcreteHandler3()
    h1.successor = h2
    h2.successor = h3

    request = [2, 5, 14, 22, 18]

    for req in request:
        # 从h1开始处理请求
        h1.handle_request(req)


if __name__ == '__main__':
    main()

不同的具体处理者仅仅针对处理不同请求条件进行了实现

应用案例
当我们进行请假、调薪等都会经过层层审批，经理->总监->总经理，因为每个层级的权限不同，整个审批过程仿佛一条责任链，逐级处理。

from abc import ABCMeta, abstractmethod


class Request:
    def __init__(self):
        self.__requestType = None
        self.__requestContent = None
        self.__number = None

    @property
    def request_type(self):
        return self.__requestType

    @request_type.setter
    def request_type(self, value: str):
        self.__requestType = value

    @property
    def requset_content(self):
        return self.__requestContent

    @requset_content.setter
    def request_content(self, content: str):
        self.__requestContent = content

    @property
    def number(self):
        return self.__number

    @number.setter
    def number(self, num: int):
        self.__number = num


class Manager(metaclass=ABCMeta):
    def __init__(self, name):
        self.__superior = None
        self.name = name

    @property
    def superior(self):
        return self.__superior

    @superior.setter
    def superior(self, superior):
        self.__superior = superior

    @abstractmethod
    def handle_request(self, request: Request):
        pass


# 经理
class CommonManager(Manager):
    def __init__(self, name):
        super().__init__(name)

    def handle_request(self, request: Request):
        if request.request_type == "请假" and request.number <= 2:
            print("{}: {} 数量{} 被批准".format(self.name, request.request_content, request.number))
        else:
            if self.superior is not None:
                self.superior.handle_request(request)


# 总监
class Majordomo(Manager):
    def __init__(self, name):
        super().__init__(name)

    def handle_request(self, request: Request):
        if request.request_type == "请假" and 2 < request.number <= 5:
            print("{}: {} 数量{} 被批准".format(self.name, request.request_content, request.number))
        else:
            if self.superior is not None:
                self.superior.handle_request(request)


# 总经理
class GeneralManager(Manager):
    def __init__(self, name):
        super().__init__(name)

    def handle_request(self, request: Request):
        if request.request_type == "请假":
            print("{}: {} 数量{} 被批准".format(self.name, request.request_content, request.number))

        elif request.request_type == "加薪" and request.number <= 500:
            print("{}: {} 数量{} 被批准".format(self.name, request.request_content, request.number))

        elif request.request_type == "加薪" and request.number > 500:
            print("{}: {} 数量{} 再说吧".format(self.name, request.request_content, request.number))

        else:
            if self.superior is not None:
                self.superior.handle_request(request)


def main():
    jingli = CommonManager("经理")
    zongjian = Majordomo("总监")
    zongjingli = GeneralManager("总经理")

    jingli.superior = zongjian
    zongjian.superior = zongjingli

    request = Request()
    request.request_type = "请假"
    request.request_content = "小菜请假"
    request.number = 1
    jingli.handle_request(request)

    request = Request()
    request.request_type = "请假"
    request.request_content = "小菜请假"
    request.number = 4
    jingli.handle_request(request)

    request = Request()
    request.request_type = "加薪"
    request.request_content = "小菜请求加薪"
    request.number = 500
    jingli.handle_request(request)

    request = Request()
    request.request_type = "加薪"
    request.request_content = "小菜请求加薪"
    request.number = 1000
    jingli.handle_request(request)


if __name__ == '__main__':
    main()

总结：责任链模式就是在当前类中设置一个继任者，根据条件判断是在当前类中处理请求还是把请求交给它的继任者处理。

参考资料
《大话设计模式》