设计模式:我买了那本 23 种模式的书,然后写出了一堆没人用的抽象类
每个学完面向对象的人,几乎都会经历同一条路径:某天刷到“大厂面试必考设计模式”,下单那本封面画着 23 种模式结构图的经典书,两周啃完,合上书的那一刻热血沸腾——觉得自己掌握了“高级编程”的密码。
然后第一次实战来了。需求是给用户加积分,我大笔一挥:
from abc import ABC, abstractmethod
class PointsService(ABC):
@abstractmethod
def add_points(self, user_id: int, points: int) -> int: ...
class PointsServiceImpl(PointsService):
def __init__(self):
self._db = {}
def add_points(self, user_id, points):
self._db[user_id] = self._db.get(user_id, 0) + points
return self._db[user_id]
class PointsServiceFactory:
@staticmethod
def get_service() -> PointsService:
return PointsServiceImpl()
接口、实现、工厂,三层结构教科书般标准。我满意地提交——这代码拿去面试能拿满分。三个月后回看:PointsService 只有一个实现,工厂里只有一行 return,拆在三个文件里的结构让每次改动都要跳三次。整个系统只有两三个接口,压根没有第二个实现出现的迹象。
更尴尬的是后来读 Python 标准库源码,发现同样的需求人家是这样写的:
def add_points(user_id: int, points: int) -> int:
...
一个函数,完事。那一刻的认知冲击,就是这篇文章要展开的主题。
一、先立模型:模式是“变化的分类学”,不是名词表
把 23 种模式当成名词去背,永远学不会设计模式。它们真正的组织逻辑只有一个维度:变化的方向。
软件系统里所有“将来可能变的东西”,归纳起来就四类,每类对应一组模式:
| 变化的东西 | 应对的模式家族 | 核心问题 |
|---|---|---|
| 对象怎么创建 | 创建型:单例、工厂、建造者 | 调用方不该知道对象怎么 new 出来的 |
| 类怎么组装 | 结构型:装饰器、代理、适配器 | 不改源码怎么加功能 |
| 行为怎么分派 | 行为型:策略、观察者、责任链 | 运行时怎么切换/广播/传递动作 |
| 状态怎么共享 | (横切问题)单例、享元 | 多处用同一份实例/数据 |
| 把这个表立在心里,看到任何模式先问一个问题:它在替我管理哪种变化?工厂管理的是“具体类将来会换”——现在没得换,工厂就是纯开销;装饰器管理的是“功能将来要叠加”——现在只有一层,装饰器就是画蛇添足。 |
二、Python 改写了游戏规则
GoF 那本书 1994 年出版,写的是 C++/Java 时代的语言。Python 的语言特性让其中一大半模式的“经典实现”变成了不必要的仪式。对照表先摆出来:
| GoF 模式 | Java/C++ 里的写法 | Python 里的等价物 | 省掉了什么 |
|---|---|---|---|
| 策略 | 定义接口 + 多个实现类 | 传一个函数 | 整个类层次 |
| 命令 | Command 接口 + execute 方法 | 闭包 / lambda | 整个类层次 |
| 单例 | 私有构造 + 静态方法 + 双检锁 | 一个模块 | 类本身 |
| 装饰器(结构型) | 抽象装饰类继承被装饰接口 | @ 语法糖 |
继承链 |
| 模板方法 | 抽象类定义骨架,子类填空 | 高阶函数传钩子 | 继承链 |
| 观察者 | Subject/Observer 接口对 | 回调函数列表 / signal 库 | 接口定义 |
| 背后的三个语言特性,是这张表的发动机: | |||
| 鸭子类型:Java 需要接口是因为编译器必须确认“对象有这个方法”。Python 不确认——运行时能调就是有。于是“接口定义”这层仪式被整体跳过,策略模式坍缩成一个参数。 | |||
头等函数:函数是对象,能存、能传、能返回。命令模式的本质是“把动作打包成可传递的东西”——在 Python 里 action = lambda: do_something() 就完成了打包,不需要为“打包”这个动作发明一个类。 |
|||
| 模块即单例:Python 的 import 机制保证模块只加载一次、之后所有 import 拿到同一个模块对象。这个语言级保证,让“单例模式”在 Python 里默认免费存在——这是下一节的主角。 |
三、四个高频模式的 Python 侧写
单例:连类都不用写的模式
单例是 23 种模式里名气最大、误解最深的一个。它在 Python 里的三种写法,从"最 Pythonic"到“最仪式感”排列:
写法一:模块——首选。Python 模块天然是单例,第一次 import 时执行、之后缓存复用:
# config.py
class _Config:
debug = True
db_url = "postgresql://localhost/app"
config = _Config() # 模块加载时创建一次
# 任何地方
from config import config
config.debug # 永远是同一个对象
零成本、线程安全、无需任何特殊代码。如果需求只是“共享一份状态”,这就是答案。
写法二:__new__——当你必须用类时:
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
注意一个坑:__init__ 会被调用多次——每次 Singleton() 都触发一次初始化,重复执行的副作用要用 _initialized 标记防住。
写法三:元类——框架级工具,日常业务慎用:
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class Config(metaclass=SingletonMeta): ...
元类适合“需要统一约束大量类”的框架场景;日常代码里写它,大概率是在炫技。
单例的翻车现场必须记录,因为它最容易被滥用:
- 全局变量诅咒:单例本质是全局状态的变体,滥用导致“牵一发动全身”的泥球代码
- 测试地狱:实例跨测试存活,单元测试无法隔离依赖——mock 一个单例比 mock 一个参数难十倍
- 分布式噩梦:单例保证的是“进程内唯一”,多进程/多机器部署时这份保证消失——内存缓存在三台机器上就是三份不同的数据
判断标准只有一条:系统在逻辑上是否真的只允许存在一个实例(配置、日志、连接池——是;业务对象如订单、用户——从来不是)。
工厂:把 if/elif 关进笼子
工厂模式管理的变化是“具体类将来会换”。Python 侧最实用的形态是简单工厂:
# 传统 if/elif 版
def create_payment(method):
if method == 'alipay':
return Alipay()
elif method == 'wechat':
return WechatPay()
raise ValueError(f"Unknown: {method}")
# Pythonic 字典版——策略的另一种表达
PAYMENT_REGISTRY = {
'alipay': Alipay,
'wechat': WechatPay,
'apple': ApplePay, # 新增一行搞定,不动旧代码
}
def create_payment(method):
return PAYMENT_REGISTRY[method]()
字典版工厂的妙处:新增实现 = 注册一个新键,主流程代码零修改——这就是开闭原则的直接兑现,且不需要任何抽象类参与。
GoF 原版工厂方法(子类化工厂)在 Python 里几乎总是过度设计——除非工厂本身的创建逻辑有复杂的多态需要,否则字典/match 语句是更平的答案。
装饰器:@ 符号背后的结构型模式
这里有个容易混淆的对照值得讲清楚:GoF 的“装饰器模式”(结构型)和 Python 的“装饰器语法”(@decorator)是两个东西,但后者是前者的极致简化。
GoF 装饰器要解决的问题:不改接口、不改源码,给对象叠加可组合的功能层。经典案例——通知系统:
Notifier
├── EmailNotifier
├── SMSNotifier
├── LoggingEmailNotifier # 组合爆炸开始
├── RetryingLoggingEmailNotifier
├── RateLimitedRetryingLoggingEmailNotifier
└── ...(4 种通知 × 3 个横切关注点 = 32 个类)
每种功能组合都要一个新类,指数爆炸。装饰器的解法是运行时套娃:
# Python 极简版——装饰器语法直接可用
import functools
def retry(times=3):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(times):
try:
return func(*args, **kwargs)
except Exception:
if attempt == times - 1:
raise
return wrapper
return decorator
def log_calls(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"调用 {func.__name__}({args})")
return func(*args, **kwargs)
return wrapper
@log_calls
@retry(times=5)
def send_sms(phone, msg):
... # 短信发送逻辑
@log_calls @retry 两行叠加 = GoF 里“重试日志短信通知器”一个类。顺序敏感这一点两种形态一致:先加密再压缩 ≠ 先压缩再加密。系列前面有整篇装饰器详解,这里只强调结构对照——@ 语法是装饰器模式在语言层面的原生落地,Python 程序员每天都在用 GoF 模式而不自知。
责任链:Web 中间件的骨架
责任链管理的变化是“处理流程将来要插入新环节”。它在 Python Web 框架里无处不在——只是换了名字叫中间件。
请求到达 → 认证中间件 → 日志中间件 → 限流中间件 → 路由处理 → 响应逐层回传——每个中间件处理自己关心的部分、决定是否放行到下一层,这正是责任链的标准结构。日志系统的分级处理(DEBUG 走控制台、WARNING 进文件、ERROR 发邮件)是另一经典实现。
class Logger:
def __init__(self, next_logger=None):
self.next_logger = next_logger
def log(self, level: int, message: str):
if self.can_handle(level):
self.handle(message)
if self.next_logger:
self.next_logger.log(level, message)
理解了责任链,看 FastAPI/Flask/Django 的中间件文档就不再是“记 API”,而是“看这个框架怎么实现一个熟悉的模式”——模式是框架的阅读语法。
四、什么时候不要用:过度设计的完整病理
这部分和踩坑系列是同一血脉,值得用完整的反例呈现。开篇那个积分系统的故事,完整的病理对照:
# ❌ 过度工程版(开篇的翻车代码)
service.py → PointsService (ABC) + PointsServiceImpl
factory.py → PointsServiceFactory.get_service()
main.py → service = get_points_service(); service.add_points(...)
# ✅ 适度版
points_db = {}
def add_points(user_id: int, points: int) -> int:
points_db[user_id] = points_db.get(user_id, 0) + points
return points_db[user_id]
过度版的病灶清单:
- 接口只有一个实现:抽象层无对应的多态需求,纯仪式
- 工厂只有一行 return:没有创建逻辑可封装
- 三个文件拆散:修改一个功能要在三个文件间跳转
- 测试更难:mock 工厂链比 mock 一个函数繁琐
诊断过度设计的三问:
- 这个设计是为了解决当前已存在的问题吗?
- 有证据表明那个“以后要换实现”的将来马上就来吗?
- 有没有更简单的方法,先解决问题同时保留演进空间?
第三问的精髓是“保留演进空间”不等于“提前搭好架子”——一个函数将来需要多实现时,再抽接口也来得及,而从过度抽象往回收的成本,远高于从简单往抽象演进。YAGNI 原则(You Aren't Gonna Need It)的全部内容就这一句:别为未来做设计,除非它真的已经来了。
五、结语:两本“经书”的哲学分歧
回头看这趟旅程,最大的收获不是“学会了哪些模式”,而是看清了两套哲学的分歧。
GoF 诞生于 C++/Java 时代——强类型、编译期绑定、继承是主要复用手段。那套语言里,“抽象出接口”是解开耦合的唯一钥匙,所以 23 种模式里大半在教人怎么搭接口和继承层次。
Python 的哲学写在 import this 里:Flat is better than nested. Simple is better than complex.鸭子类型解开了类型耦合,头等函数解开了行为耦合,模块机制解开了实例管理——三大解锁之后,GoF 里一整层“为解耦而存在的仪式”失去了用武之地。
所以 Python 侧学设计模式的正确姿势是三步:
- 先理解每种模式管理的变化维度(第一节那张表)
- 再看 Python 语言特性把它简化成了什么(第二节对照表)
- 最后判断手头的问题是否真的存在这个变化——存在才动手,不存在就让那个函数保持一个函数的形状
设计模式的本质从来不是那 23 张 UML 图,而是一套关于“变化会以什么形态出现、该用什么结构应对”的经验分类学。语言进化会让具体形态过时,但“识别变化方向”这个能力穿越语言——而这正是它值得学的全部理由。

浙公网安备 33010602011771号