设计模式:我买了那本 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 一个函数繁琐
    诊断过度设计的三问:
  1. 这个设计是为了解决当前已存在的问题吗?
  2. 有证据表明那个“以后要换实现”的将来马上就来吗?
  3. 有没有更简单的方法,先解决问题同时保留演进空间?
    第三问的精髓是“保留演进空间”不等于“提前搭好架子”——一个函数将来需要多实现时,再抽接口也来得及,而从过度抽象往回收的成本,远高于从简单往抽象演进。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 侧学设计模式的正确姿势是三步:

  1. 先理解每种模式管理的变化维度(第一节那张表)
  2. 再看 Python 语言特性把它简化成了什么(第二节对照表)
  3. 最后判断手头的问题是否真的存在这个变化——存在才动手,不存在就让那个函数保持一个函数的形状
    设计模式的本质从来不是那 23 张 UML 图,而是一套关于“变化会以什么形态出现、该用什么结构应对”的经验分类学。语言进化会让具体形态过时,但“识别变化方向”这个能力穿越语言——而这正是它值得学的全部理由。
posted @ 2026-11-04 17:01  汤姆百宝箱  阅读(14)  评论(0)    收藏  举报