设计模式-行为型-责任链模式-EW帮帮网

1. 责任链模式概述

责任链模式（Chain of Responsibility Pattern） 是一种行为型设计模式，它允许多个对象依次处理请求，形成一条处理链。每个对象都包含对下一个对象的引用，如果它无法处理请求，则将请求传递给下一个对象。

责任链模式的主要特点

降低耦合：请求的发送者和接收者解耦，发送者无需关心请求由谁处理。
动态组合处理者：可以在运行时决定请求的处理顺序。
增强灵活性：可以方便地增加或修改处理逻辑。

责任链模式的核心角色

Handler（处理者接口）：定义处理请求的方法，并包含一个指向下一个处理者的引用。
ConcreteHandler（具体处理者）：具体实现处理逻辑，如果无法处理请求，则传递给下一个处理者。
Client（客户端）：创建责任链，并向链的起点发送请求。

2. 责任链模式的 Python 实现

2.1 经典实现

class Handler:
    """处理者基类"""
    def __init__(self, successor=None):
        self.successor = successor  # 指向下一个处理者
    
    def handle_request(self, request):
        if self.successor:
            self.successor.handle_request(request)

class ConcreteHandlerA(Handler):
    def handle_request(self, request):
        if request == "A":
            print("ConcreteHandlerA 处理请求 A")
        elif self.successor:
            self.successor.handle_request(request)

class ConcreteHandlerB(Handler):
    def handle_request(self, request):
        if request == "B":
            print("ConcreteHandlerB 处理请求 B")
        elif self.successor:
            self.successor.handle_request(request)

# 创建责任链
handler_chain = ConcreteHandlerA(ConcreteHandlerB())

# 发送请求
handler_chain.handle_request("A")  # 由 ConcreteHandlerA 处理
handler_chain.handle_request("B")  # 由 ConcreteHandlerB 处理
handler_chain.handle_request("C")  # 无处理者响应

2.2 使用装饰器优化责任链

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 self.next_handler:
            return self.next_handler.handle(request)
        return None

class AuthHandler(Handler):
    def handle(self, request):
        if request.get("auth", False):
            print("AuthHandler: 认证成功")
            return super().handle(request)
        print("AuthHandler: 认证失败")
        return None

class LoggingHandler(Handler):
    def handle(self, request):
        print("LoggingHandler: 记录日志")
        return super().handle(request)

# 创建责任链
handler_chain = AuthHandler()
handler_chain.set_next(LoggingHandler())

# 处理请求
request = {"auth": True}
handler_chain.handle(request)  # 认证成功 -> 记录日志

3. 责任链模式的优缺点

优点

✅ 降低耦合：请求的发送方和处理方解耦，灵活性提高。

✅ 动态组合处理者：可以根据需求动态修改责任链结构。

✅ 增强扩展性：新增处理逻辑时，只需增加新的处理者，无需修改已有代码。

缺点

❌ 请求可能未被处理：如果责任链没有合适的处理者，可能导致请求未被处理。

❌ 调试困难：由于请求可能经过多个处理者，调试可能较为复杂。

❌ 可能影响性能：如果责任链过长，可能导致请求的处理变慢。

4. 适用场景

责任链模式适用于以下场景：

多个对象可以处理同一请求，但具体由哪个对象处理在运行时确定（如日志记录、事件处理）。
希望避免请求发送者和接收者之间的强耦合（如权限验证）。
希望能动态调整处理者的顺序（如拦截器、过滤器链）。

5. 责任链模式的实际应用

5.1 Web 框架中的请求处理

在 Web 框架（如 Flask、Django）中，中间件（Middleware）通常采用责任链模式。例如：

class Middleware:
    def __init__(self, next_middleware=None):
        self.next = next_middleware
    
    def process_request(self, request):
        if self.next:
            return self.next.process_request(request)

class AuthMiddleware(Middleware):
    def process_request(self, request):
        if not request.get("authenticated", False):
            return "403 Forbidden"
        return super().process_request(request)

class LoggerMiddleware(Middleware):
    def process_request(self, request):
        print(f"Logging request: {request}")
        return super().process_request(request)

# 构建责任链
middleware_chain = AuthMiddleware(LoggerMiddleware())

# 处理请求
request = {"authenticated": True}
response = middleware_chain.process_request(request)
print(response)

5.2 事件处理系统

如 GUI 事件处理、游戏开发中键盘/鼠标事件的传递。

5.3 任务审批流程

如公司审批流程，经理审批后交给总监，总监审批后交给 CEO。

6. 总结

责任链模式通过将多个处理者串联成链，使得请求可以沿着链传递，直到被合适的处理者处理。这种模式有效降低了对象之间的耦合，提高了系统的灵活性和可扩展性。

责任链模式适用于 请求处理具有层次性或顺序性的场景，如日志记录、权限校验、Web 中间件等。

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