设计模式-责任链模式

责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，其核心思想是避免请求的发送者与接收者之间的直接耦合关系。多个处理者对象通过链条的方式处理请求，发送者将请求传递给链条中的第一个处理者，若当前处理者不能处理该请求，则将请求传递给下一个处理者，直到有处理者处理该请求或者链条结束。

该模式主要用于以下场景：

• 需要多个对象处理同一个请求，且不确定哪个对象处理该请求。
• 需要通过一系列处理对象对请求进行处理，并且这些对象之间的处理流程可动态改变。

责任链模式的结构

1. Handler（抽象处理者）：声明一个处理请求的接口，并且实现对下一个处理者的引用。
2. ConcreteHandler（具体处理者）：处理具体的请求，如果能够处理该请求，则处理；否则，传递给下一个处理者。
3. Client（客户端）：构建责任链并发起请求。

责任链模式的优点：

• 降低耦合度：请求的发送者和接收者之间没有直接的联系，增强了系统的灵活性。
• 增强扩展性：可以方便地向链中添加新的处理者，修改和扩展都不会影响现有的代码。
• 职责分离：每个处理者关注自己的职责，职责清晰。

UML 图示

  +---------------------+
  |      Handler        |<-----------------+
  +---------------------+                  |
  | - nextHandler: Handler |                |
  +---------------------+                  |
  | + setNext(handler: Handler) |           |
  | + handleRequest()         |           |
  +---------------------+                  |
           ^                              |
           |                              |
           |                              |
  +-------------------------+            |
  | ConcreteHandlerA        |            |
  +-------------------------+            |
  | + handleRequest()       |            |
  +-------------------------+            |
           ^                              |
           |                              |
  +-------------------------+            |
  | ConcreteHandlerB        |            |
  +-------------------------+            |
  | + handleRequest()       |            |
  +-------------------------+            |
           ^                              |
           |                              |
  +-------------------------+            |
  | ConcreteHandlerC        |            |
  +-------------------------+            |
  | + handleRequest()       |            |
  +-------------------------+            |

责任链模式的Python实现

以下是责任链模式的一个简单实现示例：

class Handler:
    def __init__(self):
        self.next_handler = None  # 下一处理者

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

    def handle_request(self, request):
        if self.next_handler:
            return self.next_handler.handle_request(request)
        return None


class ConcreteHandlerA(Handler):
    def handle_request(self, request):
        if request == "A":
            return "Handler A handled the request."
        else:
            return super().handle_request(request)


class ConcreteHandlerB(Handler):
    def handle_request(self, request):
        if request == "B":
            return "Handler B handled the request."
        else:
            return super().handle_request(request)


class ConcreteHandlerC(Handler):
    def handle_request(self, request):
        if request == "C":
            return "Handler C handled the request."
        else:
            return super().handle_request(request)


# 客户端代码
if __name__ == "__main__":
    # 创建处理者对象
    handler_a = ConcreteHandlerA()
    handler_b = ConcreteHandlerB()
    handler_c = ConcreteHandlerC()

    # 建立责任链
    handler_a.set_next(handler_b).set_next(handler_c)

    # 测试请求处理
    requests = ["A", "B", "C", "D"]
    for req in requests:
        result = handler_a.handle_request(req)
        if result:
            print(f"Request '{req}' processed: {result}")
        else:
            print(f"Request '{req}' was not handled.")

解释：

1. Handler 类：这是所有处理者的基类，提供了一个 set_next 方法来将责任链中的下一个处理者设置为当前处理者的 next_handler。handle_request 方法会将请求传递给下一个处理者，直到找到一个能够处理该请求的处理者为止。
2. ConcreteHandlerA、ConcreteHandlerB、ConcreteHandlerC 类：这些是具体的处理者类，它们根据不同的条件来处理请求。如果它们不能处理请求，就将请求传递给链中的下一个处理者。
3. 客户端代码：创建了一个责任链，通过 set_next 方法将各个具体的处理者连接起来。客户端发送不同的请求（"A"、"B"、"C"、"D"）给链的头部处理者，最终由能够处理请求的处理者来完成处理。

输出结果：

Request 'A' processed: Handler A handled the request.
Request 'B' processed: Handler B handled the request.
Request 'C' processed: Handler C handled the request.
Request 'D' was not handled.

总结：

• 责任链模式通过将多个处理者链接在一起形成一个链条，从而允许多个处理者共同处理一个请求。这样，当请求传递到责任链时，每个处理者都可以决定是否处理请求或将其传递给下一个处理者，直到找到合适的处理者。
• 在实际应用中，责任链模式常用于事件处理、日志处理等场景，在这些场景中，多个处理者需要按一定的顺序处理请求或事件。