Python——常用行为模式

行为模式（Behavioral Design Patterns） 主要解决的是对象之间的职责划分与协作问题。这类模式通过定义对象间的通信方式、责任分配和行为组织，帮助构建可扩展、灵活的系统，并且通过减少耦合和提高复用性来优化系统行为。

常见的行为模式有：

• 责任链模式（Chain of Responsibility）
• 命令模式（Command Pattern）
• 观察者模式（Observer Pattern）
• 策略模式（Strategy Pattern）
• 状态模式（State Pattern）

在这些模式中，责任链模式尤为常见，适用于处理请求时，多个对象可以依次对其进行处理，直到有对象处理完成为止。

1. 责任链模式（Chain of Responsibility Pattern）

原理

责任链模式的核心思想是：将请求沿着一条处理链传递，每个对象有机会处理请求，但不一定必须处理。如果当前对象无法处理，它会将请求传递给下一个对象，直到请求被处理或者到达链的末尾。

• 解耦请求与处理者：客户端发送请求时，不需要关心由谁处理，也不需要关心具体的处理逻辑。处理者可以动态增加或减少，从而使系统更加灵活。

典型使用场景

• 异常的分层处理：异常捕获可以从最底层向上层逐级传播，直到有合适的层次处理这个异常。
• 用户请求的逐层处理：处理用户请求时，从网络层到应用层，每个环节都有机会对请求进行操作，如DNS、HTTP、Socket请求处理等。
• 权限校验：多个权限层次的校验，可以依次判断每个权限层是否满足，直到通过所有校验或者拒绝。

2. Python 中的责任链模式实现

在 Python 中，责任链模式可以通过类继承和方法传递来实现，每个对象负责处理某个具体的任务，或者将请求传递给下一个对象。

示例 1：异常的分层处理

我们可以通过责任链模式逐层捕获和处理异常，从底层向上级抛出，直到有合适的层次处理异常。

class Handler:
    def __init__(self, successor=None):
        self.successor = successor

    def handle(self, request):
        if self.successor:
            return self.successor.handle(request)
        else:
            raise Exception("No handler could process the request")


class ConcreteHandlerA(Handler):
    def handle(self, request):
        if request == "A":
            return f"Handled by A"
        else:
            return super().handle(request)


class ConcreteHandlerB(Handler):
    def handle(self, request):
        if request == "B":
            return f"Handled by B"
        else:
            return super().handle(request)


# 组装责任链
handler = ConcreteHandlerA(ConcreteHandlerB())

# 处理请求
print(handler.handle("A"))  # 输出 "Handled by A"
print(handler.handle("B"))  # 输出 "Handled by B"
# 请求未被处理会抛出异常
# print(handler.handle("C"))  # 抛出 Exception: No handler could process the request

解释：

• Handler 类：定义了处理请求的基础逻辑，包括向下传递请求的机制。
• ConcreteHandlerA 和 ConcreteHandlerB：负责具体的请求处理。
• 责任链结构：通过将不同的 Handler 依次组合，形成处理链。

3. 责任链模式的典型场景

场景 1：用户请求逐层处理（如 DNS, HTTP, Socket）

当用户请求网站失败时，通常会有多个层次来进行逐级处理，如 DNS 解析失败、HTTP 错误、Socket连接问题等。通过责任链模式，我们可以设计一个逐级的请求处理流程，直到确定问题所在。

class DNSHandler(Handler):
    def handle(self, request):
        if request == "DNS":
            return "DNS lookup failed"
        return super().handle(request)

class HTTPHandler(Handler):
    def handle(self, request):
        if request == "HTTP":
            return "HTTP error"
        return super().handle(request)

class SocketHandler(Handler):
    def handle(self, request):
        if request == "Socket":
            return "Socket connection issue"
        return super().handle(request)

# 构建责任链：DNS -> HTTP -> Socket
handler_chain = DNSHandler(HTTPHandler(SocketHandler()))

# 处理逐层请求
print(handler_chain.handle("HTTP"))   # 输出 "HTTP error"
print(handler_chain.handle("Socket")) # 输出 "Socket connection issue"
print(handler_chain.handle("DNS"))    # 输出 "DNS lookup failed"

场景 2：权限校验

权限管理系统中，每个请求可能需要通过不同的权限校验机制，比如用户权限、角色权限、以及特定资源的权限。

class PermissionHandler(Handler):
    def handle(self, request):
        if request == "Admin":
            return "Admin access granted"
        return super().handle(request)

class RoleHandler(Handler):
    def handle(self, request):
        if request == "Manager":
            return "Manager access granted"
        return super().handle(request)

class ResourceHandler(Handler):
    def handle(self, request):
        if request == "Read":
            return "Resource read access granted"
        return super().handle(request)

# 构建责任链：Permission -> Role -> Resource
handler_chain = PermissionHandler(RoleHandler(ResourceHandler()))

# 处理请求
print(handler_chain.handle("Manager"))  # 输出 "Manager access granted"
print(handler_chain.handle("Read"))     # 输出 "Resource read access granted"

场景 3：用户请求日志记录

可以通过责任链模式将用户请求日志分发到不同的日志处理器，如数据库日志、文件日志、和控制台日志。

4. 责任链模式的好处

• 解耦请求与处理逻辑：客户端不需要知道具体的请求处理者是谁，责任链中的每一个对象都可能处理请求。
• 灵活的责任分配：可以根据需求动态调整责任链中的对象，添加、移除或更改处理顺序。
• 可扩展性：当需要增加新的请求处理逻辑时，只需新增相应的处理器即可，不必修改现有代码。

5. 总结

责任链模式通过将请求沿着处理链传递，有效地解耦了请求的发出者和处理者。它在处理异常、请求校验、日志记录等场景中非常有用，帮助系统应对复杂的处理流程。Python 中可以通过类继承与方法传递灵活实现责任链模式，提高系统的可维护性和扩展性。