Python技术丛书

Appearance

设计模式速查表 ​

概述 ​

本文档提供设计模式的快速参考，包括模式分类、意图、适用场景和关键实现要点。适用于快速查阅和模式选择决策。

创建型模式速查 ​

模式概览 ​

模式意图核心结构适用场景
单例模式确保唯一实例私有构造 + 静态实例配置管理、日志、连接池
工厂方法延迟创建到子类Creator + Product接口日志系统、数据库驱动
抽象工厂创建产品家族AbstractFactory + 产品族跨平台UI、数据库访问
建造者模式分步构建复杂对象Builder + DirectorSQL构建器、配置对象
原型模式克隆创建对象clone()方法原型注册表、深拷贝

创建型模式决策树 ​

需要创建对象
│
├── 需要唯一实例？
│   └── 是 → 单例模式
│
├── 创建过程复杂，需要分步构建？
│   └── 是 → 建造者模式
│
├── 需要通过复制现有对象创建？
│   └── 是 → 原型模式
│
├── 需要创建相关对象家族？
│   └── 是 → 抽象工厂模式
│
└── 需要延迟创建决策到子类？
    └── 是 → 工厂方法模式

创建型模式实现要点 ​

python
# 单例模式 - 元类实现
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 Database(metaclass=SingletonMeta):
    pass

# 工厂方法
class Product(ABC):
    @abstractmethod
    def operation(self) -> str: ...

class Creator(ABC):
    @abstractmethod
    def factory_method(self) -> Product: ...
    
    def some_operation(self) -> str:
        product = self.factory_method()
        return product.operation()

# 抽象工厂
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: ...
    @abstractmethod
    def create_checkbox(self) -> Checkbox: ...

# 建造者
class SQLBuilder:
    def select(self, columns): ...
    def from_table(self, table): ...
    def where(self, condition): ...
    def build(self) -> str: ...

# 原型
import copy
class Prototype:
    def clone(self) -> 'Prototype':
        return copy.deepcopy(self)

结构型模式速查 ​

模式概览 ​

模式意图核心结构适用场景
适配器模式接口转换Adapter + Target第三方库集成、遗留代码
桥接模式分离抽象与实现Abstraction + Implementation多维度变化、跨平台
组合模式树形结构Component + Leaf + Composite文件系统、组织架构
装饰器模式动态添加职责Component + Decorator中间件、流处理
外观模式简化接口Facade子系统封装、API简化
享元模式共享细粒度对象Flyweight + FlyweightFactory文字编辑、游戏对象
代理模式控制访问Subject + Proxy延迟加载、访问控制

结构型模式决策树 ​

结构问题
│
├── 接口不兼容？
│   └── 是 → 适配器模式
│
├── 需要动态添加功能？
│   └── 是 → 装饰器模式
│
├── 需要简化复杂接口？
│   └── 是 → 外观模式
│
├── 需要控制对象访问？
│   └── 是 → 代理模式
│
├── 需要树形结构？
│   └── 是 → 组合模式
│
├── 需要多维度独立变化？
│   └── 是 → 桥接模式
│
└── 需要共享大量细粒度对象？
    └── 是 → 享元模式

结构型模式实现要点 ​

python
# 适配器
class Target(ABC):
    @abstractmethod
    def request(self) -> str: ...

class Adapter(Target):
    def __init__(self, adaptee: Adaptee):
        self._adaptee = adaptee
    
    def request(self) -> str:
        return self._adaptee.specific_request()

# 桥接
class Abstraction:
    def __init__(self, implementation: Implementation):
        self._implementation = implementation

# 组合
class Component(ABC):
    @abstractmethod
    def operation(self): ...

class Composite(Component):
    def __init__(self):
        self._children: List[Component] = []

# 装饰器
class Decorator(Component):
    def __init__(self, component: Component):
        self._component = component

# 外观
class Facade:
    def __init__(self):
        self._subsystem1 = Subsystem1()
        self._subsystem2 = Subsystem2()
    
    def operation(self):
        return f"{self._subsystem1.op1()} + {self._subsystem2.op2()}"

# 享元
class FlyweightFactory:
    _flyweights: Dict[str, Flyweight] = {}
    
    def get_flyweight(self, key: str) -> Flyweight:
        if key not in self._flyweights:
            self._flyweights[key] = Flyweight(key)
        return self._flyweights[key]

# 代理
class Proxy(Subject):
    def __init__(self, real_subject: Subject):
        self._real_subject = real_subject
    
    def request(self):
        if self.check_access():
            self._real_subject.request()

行为型模式速查 ​

模式概览 ​

模式意图核心结构适用场景
责任链模式链式处理请求Handler + ConcreteHandler中间件、审批流程
命令模式封装请求为对象Command + Invoker + Receiver撤销操作、任务队列
解释器模式定义语言文法AbstractExpression + ContextDSL、规则引擎
迭代器模式遍历聚合对象Iterator + Aggregate自定义集合遍历
中介者模式集中交互逻辑Mediator + ColleagueGUI组件、聊天室
备忘录模式保存恢复状态Memento + Originator + Caretaker撤销、存档
观察者模式一对多依赖通知Subject + Observer事件系统、数据绑定
状态模式状态改变行为State + Context状态机、订单状态
策略模式可互换算法Strategy + Context支付方式、排序算法
模板方法模式算法骨架AbstractClass + ConcreteClass框架设计、流程模板
访问者模式分离操作与结构Visitor + Element编译器、文档处理

行为型模式决策树 ​

行为问题
│
├── 需要通知多个对象？
│   └── 是 → 观察者模式
│
├── 需要切换算法？
│   └── 是 → 策略模式
│
├── 需要状态改变行为？
│   └── 是 → 状态模式
│
├── 需要链式处理？
│   └── 是 → 责任链模式
│
├── 需要撤销功能？
│   ├── 简单撤销 → 命令模式
│   └── 状态快照 → 备忘录模式
│
├── 需要遍历集合？
│   └── 是 → 迭代器模式
│
├── 需要协调多个对象？
│   └── 是 → 中介者模式
│
├── 需要固定算法骨架？
│   └── 是 → 模板方法模式
│
├── 需要封装操作？
│   └── 是 → 命令模式
│
└── 需要在结构上添加操作？
    └── 是 → 访问者模式

行为型模式实现要点 ​

python
# 责任链
class Handler(ABC):
    def __init__(self, successor: 'Handler' = None):
        self._successor = successor
    
    @abstractmethod
    def handle(self, request): ...

# 命令
class Command(ABC):
    @abstractmethod
    def execute(self): ...
    
    @abstractmethod
    def undo(self): ...

# 迭代器
class Iterator(ABC):
    @abstractmethod
    def __next__(self): ...

class Aggregate(ABC):
    @abstractmethod
    def create_iterator(self) -> Iterator: ...

# 中介者
class Mediator(ABC):
    @abstractmethod
    def notify(self, sender, event): ...

# 备忘录
@dataclass
class Memento:
    state: str

class Originator:
    def save(self) -> Memento: ...
    def restore(self, memento: Memento): ...

# 观察者
class Subject:
    def __init__(self):
        self._observers: List[Observer] = []
    
    def attach(self, observer): ...
    def detach(self, observer): ...
    def notify(self): ...

# 状态
class State(ABC):
    @abstractmethod
    def handle(self, context): ...

class Context:
    def __init__(self, state: State):
        self._state = state
    
    def transition_to(self, state: State): ...

# 策略
class Strategy(ABC):
    @abstractmethod
    def execute(self, data): ...

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

# 模板方法
class AbstractClass(ABC):
    def template_method(self):
        self.step1()
        self.step2()
        self.hook()
    
    @abstractmethod
    def step1(self): ...
    
    @abstractmethod
    def step2(self): ...

# 访问者
class Visitor(ABC):
    @abstractmethod
    def visit_concrete_a(self, element): ...
    
    @abstractmethod
    def visit_concrete_b(self, element): ...

模式关系图 ​

┌─────────────────────────────────────────────────────────────────────────┐
│                         设计模式关系图                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  创建型模式                                                              │
│  ┌─────────┐    ┌─────────────┐    ┌─────────────┐                     │
│  │ 单例    │    │ 工厂方法    │    │ 抽象工厂    │                     │
│  └────┬────┘    └──────┬──────┘    └──────┬──────┘                     │
│       │                │                  │                            │
│       │         ┌──────┴──────┐           │                            │
│       │         │             │           │                            │
│  ┌────▼────┐    │        ┌────▼─────┐     │                            │
│  │ 原型    │◄───┘        │ 建造者   │◄────┘                            │
│  └─────────┘             └──────────┘                                  │
│                                                                         │
│  结构型模式                                                              │
│  ┌─────────┐    ┌─────────────┐    ┌─────────────┐                     │
│  │ 适配器  │    │   桥接      │    │   组合      │                     │
│  └────┬────┘    └──────┬──────┘    └──────┬──────┘                     │
│       │                │                  │                            │
│       │         ┌──────┴──────┐           │                            │
│       │         │             │           │                            │
│  ┌────▼────┐    │        ┌────▼─────┐     │                            │
│  │ 装饰器  │◄───┘        │   外观   │◄────┘                            │
│  └────┬────┘             └──────────┘                                  │
│       │                                                                 │
│  ┌────▼────┐    ┌─────────────┐                                        │
│  │ 代理    │    │   享元      │                                        │
│  └─────────┘    └─────────────┘                                        │
│                                                                         │
│  行为型模式                                                              │
│  ┌─────────┐    ┌─────────────┐    ┌─────────────┐                     │
│  │责任链   │    │   命令      │    │  解释器     │                     │
│  └─────────┘    └─────────────┘    └─────────────┘                     │
│  ┌─────────┐    ┌─────────────┐    ┌─────────────┐                     │
│  │ 迭代器  │    │  中介者     │    │  备忘录     │                     │
│  └─────────┘    └─────────────┘    └─────────────┘                     │
│  ┌─────────┐    ┌─────────────┐    ┌─────────────┐                     │
│  │ 观察者  │    │   状态      │    │   策略      │                     │
│  └─────────┘    └─────────────┘    └─────────────┘                     │
│  ┌─────────┐    ┌─────────────┐                                        │
│  │模板方法 │    │  访问者     │                                        │
│  └─────────┘    └─────────────┘                                        │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

模式组合使用 ​

常见组合模式 ​

组合场景说明
单例 + 工厂配置管理工厂作为单例确保全局唯一
工厂 + 策略支付系统工厂创建不同支付策略
装饰器 + 责任链Web中间件装饰器包装处理链
观察者 + 状态事件驱动状态变化触发通知
组合 + 访问者文档处理访问者遍历组合结构
命令 + 备忘录编辑器命令执行时保存状态
建造者 + 原型配置复制建造者使用原型创建

企业级模式组合示例 ​

python
# 组合: 抽象工厂 + 建造者 + 单例
class DatabaseFactory(metaclass=SingletonMeta):
    def create_builder(self, db_type: str) -> 'QueryBuilder':
        builders = {
            'mysql': MySQLQueryBuilder,
            'postgres': PostgreSQLQueryBuilder
        }
        return builders[db_type]()

class QueryBuilder(ABC):
    @abstractmethod
    def select(self, columns): ...
    @abstractmethod
    def build(self) -> str: ...

# 组合: 策略 + 工厂 + 观察者
class PaymentProcessor:
    def __init__(self):
        self._strategies: Dict[str, PaymentStrategy] = {}
        self._observers: List[PaymentObserver] = []
    
    def register_strategy(self, name: str, strategy: PaymentStrategy):
        self._strategies[name] = strategy
    
    def process(self, method: str, amount: float):
        strategy = self._strategies[method]
        result = strategy.pay(amount)
        self._notify_observers(method, amount, result)
        return result

设计原则对照 ​

SOLID原则与模式映射 ​

原则支持的模式应用方式
SRP外观、建造者、策略、命令每个类专注单一职责
OCP策略、观察者、装饰器、工厂方法通过扩展而非修改
LSP状态、策略、模板方法子类可替换父类
ISP适配器、桥接、代理、迭代器接口职责单一
DIP工厂方法、策略、观察者、命令依赖抽象而非具体

原则冲突处理 ​

冲突解决方案
简洁性 vs 扩展性优先简洁，稳定变化点再抽象
性能 vs 灵活性热点代码可牺牲部分灵活性
复杂度 vs 可维护性适度复杂度换取可维护性

快速决策指南 ​

根据问题类型选择 ​

问题类型 → 推荐模式

创建对象:
  唯一实例 → 单例
  复杂构建 → 建造者
  克隆创建 → 原型
  家族创建 → 抽象工厂
  延迟决策 → 工厂方法

结构问题:
  接口不兼容 → 适配器
  添加功能 → 装饰器
  简化接口 → 外观
  控制访问 → 代理
  树形结构 → 组合
  多维变化 → 桥接
  共享对象 → 享元

行为问题:
  通知机制 → 观察者
  算法切换 → 策略
  状态变化 → 状态
  链式处理 → 责任链
  撤销操作 → 命令/备忘录
  遍历集合 → 迭代器
  协调交互 → 中介者
  算法骨架 → 模板方法

根据变化点选择 ​

变化点推荐模式
对象创建方式工厂方法、抽象工厂、原型、建造者
对象结构组合、装饰器、适配器、代理
对象行为策略、状态、命令、观察者
算法实现模板方法、策略
对象交互中介者、观察者、责任链
对象状态备忘录、状态

反模式警示 ​

常见反模式 ​

反模式问题正确做法
上帝类类职责过多应用SRP拆分
过度设计不必要的抽象应用YAGNI
硬编码魔法数字/字符串使用策略/配置
循环依赖模块相互依赖应用DIP解耦
深层继承继承层次过深应用CRP组合
全局状态滥用全局变量使用依赖注入

模式滥用警示 ​

模式滥用场景正确使用
单例所有类都用真正需要唯一实例时
装饰器简单功能也包装需要动态组合功能时
观察者所有状态变化真正需要通知机制时
工厂简单对象创建创建逻辑复杂时
策略单一算法场景需要切换算法时

检查清单 ​

模式选择检查 ​

  • [ ] 是否明确了要解决的问题？
  • [ ] 是否考虑了多种可选模式？
  • [ ] 是否评估了模式的复杂度？
  • [ ] 是否考虑了未来的变化？
  • [ ] 是否遵循了相关设计原则？

模式实现检查 ​

  • [ ] 是否正确实现了模式的核心结构？
  • [ ] 是否处理了边界情况？
  • [ ] 是否考虑了线程安全？
  • [ ] 是否提供了清晰的接口？
  • [ ] 是否有适当的文档说明？

总结 ​

设计模式是解决特定问题的成熟方案，选择合适的模式需要：

  1. 理解问题本质：明确要解决的问题类型
  2. 评估模式适用性：考虑模式的优缺点和适用场景
  3. 权衡复杂度：避免过度设计，保持简洁
  4. 遵循设计原则：以SOLID原则为指导
  5. 持续重构：根据实际需求调整设计

记住：模式是工具，不是目的。好的设计应该解决问题，而不是引入不必要的复杂性。

Python技术丛书 - 江苏省宿城中等专业学校

Copyright © 2020-2026 陈瑾瑜 | 苏ICP备2025184735号-1