> 前言：在上一篇文章中，我们探讨了策略模式与责任链模式在 Python 3.10+ 语法特性下的优雅重构。今天，我们继续设计模式的现代化演进之旅，聚焦于控制"状态流转"与"状态变更通知"的两大经典行为型模式：状态模式（State Pattern）与观察者模式（Observer Pattern）。

> 传统的 OOP 实现往往依赖于庞大的继承体系、显式的接口抽象以及繁琐的观察者列表维护。而在 Python 3.10+ 中，凭借 pattern matching（结构化模式匹配）、dataclass(slots=True)、强类型标注以及异步生成器等特性，我们可以将这两个模式重写得极为优雅且极具 Pythonic 特色。

一、状态模式（State Pattern）：从类继承继承到类型驱动与结构化匹配

传统的状态模式通常为每个状态创建一个类，并在上下文（Context）对象中维护当前状态实例。这种写法在 Python 中显得过于重量级，且容易引发循环依赖。

传统 OOP 实现的痛点

* 类爆炸：仅仅几个状态就需要定义大量的 State 子类。

* 状态转移分散：逻辑散落在不同的 State 类中，难以直观查阅完整的状态机转换图。

* 状态与数据的耦合：为了在状态转移时传递数据，不得不频繁修改基类方法签名。

Python 3.10+ 现代重构：Enum + match-case + 纯函数

在 Python 3.10 中，match-case 结合强类型 dataclass 可以实现严格的状态机校验。我们将"状态"抽象为无状态的数据声明，将"转移逻辑"交由结构化匹配驱动的纯函数完成。

示例场景：订单状态流转系统

from enum import Enum, auto

from dataclasses import dataclass, field

from typing import Union, Optional, Literal

1. 定义状态与事件枚举

class OrderStatus(Enum):

PENDING = auto() # 待支付

PAID = auto() # 已支付

SHIPPED = auto() # 已发货

COMPLETED = auto() # 已完成

CANCELLED = auto() # 已取消

@dataclass(frozen=True)

class PayEvent:

amount: float

payment_method: str

@dataclass(frozen=True)

class ShipEvent:

tracking_number: str

@dataclass(frozen=True)

class CancelEvent:

reason: str

统一事件类型

OrderEvent = Union $PayEvent, ShipEvent, CancelEvent$

2. 状态转移上下文数据

@dataclass

class OrderContext:

order_id: str

status: OrderStatus = OrderStatus.PENDING

tracking_number: Optional $str$ = None

cancel_reason: Optional $str$ = None

3. 基于 match-case 的核心状态机逻辑（纯函数）

def transition_order(context: OrderContext, event: OrderEvent) -> OrderContext:

"""处理订单状态转移的纯函数"""

match (context.status, event):

待支付 -> 收到支付事件 -> 变更为已支付

case (OrderStatus.PENDING, PayEvent(amount=amt)) if amt > 0:

context.status = OrderStatus.PAID

print(f" $订单 {context.order_id}$ 支付成功，金额: ¥{amt}")

待支付 -> 取消事件 -> 变更为已取消

case (OrderStatus.PENDING, CancelEvent(reason=r)):

context.status = OrderStatus.CANCELLED

context.cancel_reason = r

print(f" $订单 {context.order_id}$ 已取消，原因: {r}")

已支付 -> 发货事件 -> 变更为已发货

case (OrderStatus.PAID, ShipEvent(tracking_number=tn)):

context.status = OrderStatus.SHIPPED

context.tracking_number = tn

print(f" $订单 {context.order_id}$ 已发货，运单号: {tn}")

已发货 -> 取消事件（不支持退款时抛出非法转换）

case (OrderStatus.SHIPPED, CancelEvent()):

raise ValueError(f"订单 {context.order_id} 已发货，无法直接取消！")

未匹配到的非法转换处理

case (current_status, unhandled_event):

raise InvalidStateTransition(

f"非法状态转移: 处于 {current_status.name} 状态时无法响应 {type(unhandled_event).name} 事件"

)

return context

class InvalidStateTransition(Exception):

pass

使用示例

if name == "main":

order = OrderContext(order_id="ORD-20261001")

模拟合法流转

transition_order(order, PayEvent(amount=199.0, payment_method="wechat"))

transition_order(order, ShipEvent(tracking_number="SF123456789"))

尝试非法转换，抛出清晰异常

try:

transition_order(order, CancelEvent(reason="买错了"))

except InvalidStateTransition as e:

print(f"转换拦截: {e}")

💡 模式突破点评

* 聚合性高：完整的状态流转图集中在 transition_order 函数的 match-case 中，一目了然，无需在数个文件间跳转。

* 零类膨胀：无需为每个状态编写包含 handle() 方法的类，降低内存开销并提升运行效率。

* Guard 语句强保障：配合 if amt > 0 等 Guard 条件，可在匹配同时进行属性级别的细粒度业务校验。

二、观察者模式（Observer Pattern）：从回调列表中解放，拥抱异步生成器与泛型总线

经典的观察者模式要求"被观察者（Subject）"维护一个 observer 列表，并在状态改变时遍历调用 notify()。

传统实现的不足

* 同步阻塞：若某个观察者的执行时间过长，会卡死主业务流程。

* 强耦合的注册方式：Observer 必须继承特定基类或遵循严格的接口规范。

* 内存泄漏风险：忘记显式注销观察者会导致引用计数无法释放。

Python 3.10+ 现代重构：异步解耦与强类型事件总线

结合 Python 3.10+ 的强类型注解（TypeVar, Generic）以及 asyncio 的强力支持，我们可以实现一个轻量、线程/协程安全的异步事件总线（Event Bus），彻底消除观察者与被观察者的硬编码关联。

现代化解耦实现

import asyncio

from typing import Type, TypeVar, Callable, Awaitable, Dict, List

from dataclasses import dataclass, field

T = TypeVar("T")

1. 定义事件基类/结构体

@dataclass(slots=True)

class UserRegisteredEvent:

user_id: str

email: str

@dataclass(slots=True)

class OrderCreatedEvent:

order_id: str

total_amount: float

2. 类型安全的强类型异步事件总线

class ModernEventBus:

def init(self):

建立 EventType -> Async Handlers 的映射字典

self._handlers: Dict $Type, List\[Callable\[\[any$ , Awaitable $None$ ]]] = {}

def subscribe(self, event_type: Type $T$ ):

"""装饰器：注册订阅者"""

def decorator(func: Callable $\[T$ , Awaitable $None$ ]):

if event_type not in self._handlers:

self._handlers $event_type$ = \[\]

self._handlers $event_type$ .append(func)

return func

return decorator

async def publish(self, event: object) -> None:

"""异步发布事件，并行触发所有订阅者"""

event_type = type(event)

if event_type not in self._handlers:

return

挂载所有订阅者的异步任务并发执行

tasks = [

asyncio.create_task(handler(event))

for handler in self._handlers $event_type$

]

if tasks:

await asyncio.gather(*tasks, return_exceptions=True)

实例化总线

bus = ModernEventBus()

3. 注册观察者（使用简单的 async 函数，无需任何继承）

@bus.subscribe(UserRegisteredEvent)

async def send_welcome_email(event: UserRegisteredEvent):

await asyncio.sleep(0.1) # 模拟 IO 操作

print(f"📧 $邮件服务$ 已向用户 {event.email} (ID: {event.user_id}) 发送欢迎邮件")

@bus.subscribe(UserRegisteredEvent)

async def create_user_wallet(event: UserRegisteredEvent):

print(f"💰 $钱包服务$ 为用户 {event.user_id} 创建初始账户成功")

@bus.subscribe(OrderCreatedEvent)

async def log_metrics(event: OrderCreatedEvent):

print(f"📊 $指标服务$ 监控到新订单 {event.order_id}，金额: {event.total_amount}")

运行主程序

async def main():

print("--- 触发用户注册事件 ---")

user_event = UserRegisteredEvent(user_id="U8092", email="dev@example.com")

发布事件，观察者异步并发响应

await bus.publish(user_event)

print("\n--- 触发订单创建事件 ---")

order_event = OrderCreatedEvent(order_id="ORD-9988", total_amount=520.0)

await bus.publish(order_event)

if name == "main":

asyncio.run(main())

💡 模式突破点评

* 完全解耦：发布者只需要知道 Event 数据类，订阅者只需要利用 @bus.subscribe 注册函数，两者互相感知不到对方的存在。

* 异步非阻塞：利用 asyncio.gather 并发调度观察者逻辑，大幅提升系统的吞吐效率。

* 强类型提示：依赖 Python 3.10+ 的类型推断，IDE 能够精准识别 event 的内部字段，防止拼写错误。

三、总结与对比

| 维度 | 传统 OOP 实现 | Python 3.10+ 现代实现 |

|---|---|---|

| 状态模式 | 为每个状态建立 State 类，重写 handle() | Enum + match-case + 结构化匹配纯函数 |

| 观察者模式 | Subject 显式维护 Observer 接口列表并循环通知 | 基于装饰器与泛型 TypeVar 的异步 EventBus |

| 扩展维护成本 | 高（需增加新类并实现接口） | 低（仅增加一个新的 Enum 匹配项或 Handler 函数） |

| 类型安全与提示 | 依赖复杂继承树 | 声明式 Typing + dataclass 直观校验 |

随着 Python 语言自身机制（模式匹配、异步 IO、强类型系统）的不断完善，许多源自 C++/Java 时代的经典设计模式在 Python 中都可以通过更轻量、更函数式的方式实现。

在下一篇文章中，我们将继续探讨享元模式与单例模式在 Python 3.10+ 中的内存优化与线程安全演变，敬请关注！

Python 进阶：重构经典设计模式（五）—— 状态模式与观察者模式在 Python 3.10+ 中的类型驱动与事件解耦

1. 定义状态与事件枚举

统一事件类型

2. 状态转移上下文数据

3. 基于 match-case 的核心状态机逻辑（纯函数）

待支付 -> 收到支付事件 -> 变更为已支付

待支付 -> 取消事件 -> 变更为已取消

已支付 -> 发货事件 -> 变更为已发货

已发货 -> 取消事件（不支持退款时抛出非法转换）

未匹配到的非法转换处理

模拟合法流转

尝试非法转换，抛出清晰异常

1. 定义事件基类/结构体

2. 类型安全的强类型异步事件总线

建立 EventType -> Async Handlers 的映射字典

挂载所有订阅者的异步任务并发执行

实例化总线

3. 注册观察者（使用简单的 async 函数，无需任何继承）

发布事件，观察者异步并发响应