经过前面 16 章的学习，我们已系统掌握创建型模式（单例、工厂、建造者、原型）、结构型模式（适配器、桥接、组合、装饰器、外观、享元、代理）、行为型模式（责任链、命令、迭代器、中介者、观察者、状态、策略）的核心原理与实现方式。本章将聚焦 “设计模式的综合应用”，从模式选型、跨模式组合、实战项目分析三个维度，帮助你突破 “单个模式会用，但复杂场景不会组合” 的困境，真正将设计模式转化为解决实际问题的能力。

一、设计模式选型策略：如何匹配场景选对模式？

在实际项目中，设计模式的 “选型” 比 “实现” 更关键 —— 选对模式能简化设计、提升扩展性，选错模式则会增加复杂度。以下是基于业务场景的选型框架，涵盖常见需求与对应模式的匹配逻辑：

1.1 按 “核心需求” 选型

1.2 按 “项目阶段” 选型

• 设计初期：优先考虑 “创建型模式” 与 “结构型模式”，搭建稳定的对象创建与结构框架（如用抽象工厂定义产品系列，用桥接模式分离多维度变化）；

• 开发中期：聚焦 “行为型模式”，解决对象间的协作问题（如用观察者模式实现模块联动，用策略模式封装多算法）；

• 维护阶段：侧重 “适配器模式”“装饰器模式”“外观模式”，在不修改原有代码的前提下扩展功能（如用适配器兼容旧接口，用外观模式简化复杂子系统调用）；

• 性能优化阶段：考虑 “享元模式”“代理模式”，减少内存占用或提升响应速度（如用享元模式复用相似对象，用代理模式实现缓存）。

二、跨模式组合实战：1+1>2 的设计技巧

实际项目中，单一模式往往无法满足复杂需求，需通过 “模式组合” 发挥更大价值。以下是 6 种高频跨模式组合案例，附代码思路与应用场景：

2.1 工厂模式 + 策略模式：动态创建策略

核心逻辑：用工厂模式封装 “策略对象的创建逻辑”，客户端只需指定策略类型，工厂自动创建对应策略，无需手动初始化策略对象，降低客户端与策略类的耦合。

应用场景：电商支付策略创建

# 1. 策略接口与具体策略（复用16章支付策略）

from chapter16 import PaymentStrategy, AlipayStrategy, WechatPayStrategy, UnionPayStrategy

# 2. 策略工厂：封装策略创建逻辑

class PaymentStrategyFactory:

@staticmethod

def create_strategy(strategy_type: str) -> PaymentStrategy:

"""根据策略类型创建对应支付策略"""

if strategy_type == "alipay":

return AlipayStrategy()

elif strategy_type == "wechat":

return WechatPayStrategy()

elif strategy_type == "unionpay":

return UnionPayStrategy()

else:

raise ValueError(f"不支持的支付方式：{strategy_type}")

# 3. 客户端使用：只需传递类型，无需关心策略创建细节

if __name__ == "__main__":

# 客户端选择支付方式（如从前端接收"wechat"）

user_choice = "wechat"

# 工厂创建策略

strategy = PaymentStrategyFactory.create_strategy(user_choice)

# 上下文使用策略

from chapter16 import PaymentContext

context = PaymentContext(strategy)

# 处理支付

result = context.process_payment(

order_id="order_001",

user_id="user_123",

amount=99.90,

extra_params={"wechat_openid": "o6_bmjrPTlm6_2sgVt7hMZOPfL2M"}

)

print("支付结果：", result)

优势：新增支付策略（如 ApplePay）时，只需新增策略类与工厂分支，客户端无需修改代码，符合开闭原则；客户端无需知道策略类的构造细节（如是否需要初始化参数）。

2.2 观察者模式 + 状态模式：状态变化联动通知

核心逻辑：状态模式管理对象的状态流转，观察者模式在状态变更时通知所有依赖对象，实现 “状态驱动行为 + 多对象联动” 的双重需求。

应用场景：订单状态变更通知

# 1. 观察者接口（复用14章观察者）

from chapter14 import Observer

# 2. 状态类（集成观察者通知逻辑）

from chapter15 import OrderState

class ObservableOrderState(OrderState):

def __init__(self):

super().__init__()

self.observers = [] # 维护观察者列表

def attach_observer(self, observer: Observer) -> None:

"""注册观察者"""

if observer not in self.observers:

self.observers.append(observer)

def notify_observers(self, data: dict) -> None:

"""状态变更时通知观察者"""

for observer in self.observers:

observer.update(self.context, data)

# 3. 具体状态：已支付状态（状态变更时通知）

class PaidState(ObservableOrderState):

def pay(self, amount: float, operator: str):

self._unsupported_action("支付")

def cancel(self, reason: str, operator: str):

# 取消订单逻辑...

print(f"已支付订单取消，原因：{reason}")

# 状态变更：已支付→已取消

from chapter15 import CancelledState

new_state = CancelledState()

# 传递观察者列表到新状态

new_state.observers = self.observers

self.context.set_state(new_state)

# 通知观察者

self.notify_observers({

"order_id": self.context.order_id,

"old_state": "已支付",

"new_state": "已取消",

"reason": reason,

"operator": operator

})

# 4. 客户端使用：订单取消时通知库存、UI、用户

if __name__ == "__main__":

# 创建观察者（库存模块、UI模块、用户通知模块）

class InventoryObserver(Observer):

def update(self, subject, data):

print(f"[库存观察者] 订单{data['order_id']}状态变更：{data['old_state']}→{data['new_state']}，恢复库存")

class UIObserver(Observer):

def update(self, subject, data):

print(f"[UI观察者] 订单{data['order_id']}状态变更，刷新页面显示")

# 创建订单上下文与初始状态

from chapter15 import OrderContext, PendingPayState

order = OrderContext(PendingPayState())

# 切换到已支付状态

paid_state = PaidState()

# 注册观察者

paid_state.attach_observer(InventoryObserver("库存模块"))

paid_state.attach_observer(UIObserver("UI模块"))

order.set_state(paid_state)

# 取消订单（触发状态变更与通知）

order.cancel_order(reason="用户主动取消", operator="user_123")

优势：状态流转逻辑由状态模式封装，观察者模式负责通知联动，两者职责分离；新增需要联动的模块（如财务模块）时，只需新增观察者，无需修改状态类代码。

2.3 装饰器模式 + 命令模式：增强命令功能

核心逻辑：命令模式封装请求，装饰器模式为命令的execute()方法添加额外功能（如日志、权限校验），实现 “请求封装 + 动态功能增强”。

应用场景：带日志与权限的命令执行

# 1. 命令接口（复用11章命令）

from chapter11 import Command

# 2. 装饰器：日志装饰器

class LogCommandDecorator(Command):

def __init__(self, command: Command):

self.command = command

def execute(self) -> None:

# 执行前记录日志

import datetime

print(f"[{datetime.datetime.now()}] 开始执行命令：{
self.command.__class__.__name__}")

# 执行原命令

self.command.execute()

# 执行后记录日志

print(f"[{datetime.datetime.now()}] 命令执行完成")

# 3. 装饰器：权限装饰器

class AuthCommandDecorator(Command):

def __init__(self, command: Command, required_role: str):

self.command = command

self.required_role = required_role

def execute(self) -> None:

# 权限校验

current_role = "admin" # 模拟当前用户角色

if current_role != self.required_role:

raise PermissionError(f"权限不足，需{self.required_role}角色")

# 校验通过，执行原命令

self.command.execute()

# 4. 具体命令：关机命令

class ShutdownCommand(Command):

def execute(self) -> None:

print("执行关机命令：关闭系统服务、断开网络连接、关机")

# 5. 客户端使用：装饰命令并执行

if __name__ == "__main__":

# 创建原始命令

shutdown_cmd = ShutdownCommand()

# 装饰命令：先权限校验，再日志记录

decorated_cmd = LogCommandDecorator(

AuthCommandDecorator(shutdown_cmd, required_role="admin")

)

# 执行命令

decorated_cmd.execute()

优势：命令的核心功能（关机）与增强功能（日志、权限）分离，可灵活组合装饰器（如仅日志、仅权限、两者都有）；新增增强功能（如异常捕获）时，只需新增装饰器，无需修改命令类。

2.4 外观模式 + 中介者模式：简化复杂子系统交互

核心逻辑：外观模式为客户端提供简化接口，中介者模式管理子系统间的交互，两者结合实现 “客户端简化调用 + 子系统解耦” 的双重目标。

应用场景：智能家居控制系统

# 1. 子系统类（灯光、空调、窗帘，复用9章智能家居）

from chapter9 import Light, AirConditioner, Curtain

# 2. 中介者：协调子系统交互

class SmartHomeMediator:

def __init__(self):

self.light = Light()

self.aircon = AirConditioner()

self.curtain = Curtain()

def trigger_sleep_mode(self) -> None:

"""睡眠模式：协调子系统交互"""

self.light.turn_on(brightness=10) # 灯光调暗

self.aircon.turn_on(temperature=27.0) # 空调调温

self.curtain.close() # 关闭窗帘

def trigger_wake_up_mode(self) -> None:

"""唤醒模式：协调子系统交互"""

self.curtain.open(percentage=50) # 窗帘半开

self.light.turn_on(brightness=30) # 灯光渐亮

self.aircon.turn_on(temperature=26.0) # 空调开机

# 3. 外观类：为客户端提供简化接口

class SmartHomeFacade:

def __init__(self):

self.mediator = SmartHomeMediator() # 持有中介者引用

def set_mode(self, mode: str) -> None:

"""简化接口：按模式调用中介者"""

if mode == "sleep":

self.mediator.trigger_sleep_mode()

print("睡眠模式已激活")

elif mode == "wake_up":

self.mediator.trigger_wake_up_mode()

print("唤醒模式已激活")

else:

print("不支持的模式")

# 4. 客户端使用：通过外观调用复杂子系统

if __name__ == "__main__":

facade = SmartHomeFacade()

# 激活睡眠模式（客户端只需调用一个方法）

facade.set_mode("sleep")

# 激活唤醒模式

facade.set_mode("wake_up")

优势：中介者解决子系统间的耦合问题（如睡眠模式需协调灯光、空调、窗帘），外观模式为客户端提供 “一句话调用” 的简化接口；子系统交互逻辑变更时，只需修改中介者，客户端与外观类无需调整。

2.5 责任链模式 + 工厂模式：动态构建责任链

核心逻辑：工厂模式封装 “责任链节点的创建与串联逻辑”，客户端只需指定链的类型，工厂自动创建节点并构建链条，无需手动串联节点。

应用场景：请求校验责任链

# 1. 责任链节点（复用10章责任链）

from chapter10 import Handler

class LogHandler(Handler):

def handle_request(self, request):

print(f"日志记录：请求{request['id']}")

if self.next_handler:

self.next_handler.handle_request(request)

class AuthHandler(Handler):

def handle_request(self, request):

if request.get("user_role") == "admin":

print(f"权限校验通过：用户{request['user_id']}")

if self</doubaocanvas>