责任链设计模式

责任链设计模式是一种行为型设计模式，其主要目的是将请求的发送者和接收者解耦，从而使多个对象都有机会处理请求。将这些对象链接在一起并沿着链传递请求，直到有一个对象处理为止。

应用场景

在以下场景中，可以使用责任链设计模式：

• 有多个对象可以处理一个请求，但是具体哪个对象处理该请求在运行时才能确定。
• 需要在不明确接收者的情况下，向多个对象中的一个或多个发送请求。

UML图

角色

责任链设计模式主要包含以下角色：

• 抽象处理者（Handler）： 定义了一个处理请求的接口，同时维护一个后继处理者（可选）引用。如果请求在处理程序中间没有被处理，将请求传递到下一个处理程序。
• 具体处理者（Concrete Handler）： 实现处理请求的接口，并根据自身条件确定是否能够处理该请求。如果无法处理，则将请求传递到后继处理程序。
• 客户端（Client）： 创建和提交请求对象到处理程序链中。

代码示例

class Handler:
    def __init__(self):
        self._next_handler = None

    def set_next(self, handler):
        self._next_handler = handler
        return handler

    def handle(self, request):
        if not self._handle(request):
            self._next_handler.handle(request)

    def _handle(self, request):
        raise NotImplementedError('必须实现_handle方法')


class ConcreteHandler1(Handler):
    def _handle(self, request):
        if 0 < request <= 10:
            print(f'请求 {request} 被处理 by ConcreteHandler1')
            return True


class ConcreteHandler2(Handler):
    def _handle(self, request):
        if 10 < request <= 20:
            print(f'请求 {request} 被处理 by ConcreteHandler2')
            return True


class ConcreteHandler3(Handler):
    def _handle(self, request):
        if 20 < request <= 30:
            print(f'请求 {request} 被处理 by ConcreteHandler3')
            return True


class DefaultHandler(Handler):
    def _handle(self, request):
        print(f'未能处理请求 {request}')


class Client:
    def __init__(self):
        self.handler = ConcreteHandler1().set_next(
            ConcreteHandler2().set_next(
                ConcreteHandler3().set_next(
                    DefaultHandler()
                )
            )
        )

    def delegate(self, requests:list):
        for request in requests:
            self.handler.handle(request)


# 示例
client = Client()
client.delegate([1, 5, 15, 25, 40])
"""
输出：
请求 1 被处理 by ConcreteHandler1
请求 5 被处理 by ConcreteHandler1
请求 15 被处理 by ConcreteHandler2
请求 25 被处理 by ConcreteHandler3
未能处理请求 40
"""

总结

责任链设计模式能够将请求的发送者和接收者解耦，使多个对象都有机会处理请求。在实际场景中，可以通过责任链模式，创建一个可配置的请求处理流程，从而灵活地对应用程序的需求进行处理。