设计模式(十):外观模式——当完成一件事要按顺序协调五个子系统
一、模式原理
定义:外观模式为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
拆开看,这个定义包含三个要点:
- 一组接口,一个界面:外观面对的是多个子系统,但它只暴露一个统一的入口;
- 高层接口:外观提供的不是子系统的原子能力,而是"完成一件事"的粗粒度操作;
- 降低使用复杂度:客户端不需要知道子系统怎么划分、调用顺序是什么、异常如何处理。
意图:当多个子系统需要被按特定顺序协调才能完成一项任务,而这项任务在业务上是一个整体时,用一个外观把协调逻辑收拢起来,让客户端只表达"我要做什么",而不是"我要先调 A、再调 B、如果 B 失败要补偿 A"。
核心思想:把"子系统之间的协作知识"从客户端收拢到一个统一入口,降低客户端与子系统之间的耦合。
这里必须立刻澄清一个常见误解:外观模式不是"把子系统藏起来" 。子系统的接口仍然对外可见、可直接调用;外观只是额外提供一个更粗粒度的入口,不禁止直接访问。这和代理"控制访问"、适配器"转换接口"有本质区别——外观是"提供便利",不是"施加约束"。
和相邻模式的边界要一次说清,这是审查时最容易混淆的地方:
- 外观 vs 适配器:适配器处理"接口不兼容",目标是让两个已有接口能协作;外观处理"调用太复杂",目标是让客户端更容易使用一组本来就兼容的子系统。适配器是"翻译",外观是"简化"。
- 外观 vs 代理:代理和目标是同接口,客户端不感知代理;外观通常是一个新接口(或新类),客户端知道自己在调外观。代理控制"能不能访问",外观简化"怎么访问"。
- 外观 vs 中介者:中介者处理的是子系统之间的相互通信(子系统彼此不知道对方,通过中介者交互);外观处理的是客户端与子系统之间的交互(客户端不直接调子系统,通过外观调)。中介者是"子系统之间的协调者",外观是"对客户端的简化入口"。
- 外观 vs 装饰器:装饰器给单个对象叠加能力,接口不变;外观协调多个对象,接口是新的、更粗粒度的。
结构上只有两个角色:
- Facade(外观) :知道哪些子系统负责处理请求,把客户端的请求委托给相应的子系统,并负责协调顺序与异常;
- Subsystems(子系统) :实现具体功能,不知道外观的存在,可以独立使用。
关键约束:子系统不依赖外观。一旦子系统反向依赖外观,外观就从"可选的便利入口"变成了"强耦合的中心",分层关系被破坏。
代价一句话:你换来的是"客户端调用简化、协调逻辑集中",付出的是多一层间接、外观可能膨胀成上帝对象、以及子系统能力被外观"窄化"的风险。
二、先看一个真实痛点
订单履约流程在业务上只有一句话:"用户下单后,扣库存、收款、安排发货、通知用户。"但落到代码里,需要协调四个子系统:
// 客户端(订单控制器)里真实存在的代码
InventoryService inventory = ...;
PaymentService payment = ...;
ShippingService shipping = ...;
NotificationService notification = ...;
public void placeOrder(Order order) {
// 1. 扣库存
boolean locked = inventory.lock(order.items());
if (!locked) throw new OutOfStockException();
// 2. 收款
PaymentResult pay;
try {
pay = payment.charge(order.userId(), order.amount());
} catch (PaymentException e) {
inventory.release(order.items()); // 补偿:释放库存
throw e;
}
// 3. 安排发货
try {
shipping.schedule(order.id(), order.address());
} catch (ShippingException e) {
payment.refund(pay.transactionId()); // 补偿:退款
inventory.release(order.items()); // 补偿:释放库存
throw e;
}
// 4. 通知用户
try {
notification.send(order.userId(), "order confirmed");
} catch (NotificationException e) {
// 通知失败不回滚,只记录日志
log.warn("notify failed, orderId={}", order.id(), e);
}
}
问题有三层:
- 协调逻辑与业务入口混在一起:
placeOrder里一半是"订单业务的决策",一半是"子系统调用的顺序和补偿"。后者是编排知识,不是订单业务本身。 - 协调逻辑会被复制:退款流程、定时补单流程、后台手工重试流程,都需要"扣库存→收款→发货"这套顺序和补偿。每复制一次,补偿逻辑就可能漏掉一处。
- 客户端被迫了解子系统的异常语义:
PaymentException、ShippingException、NotificationException的处理策略各不相同(有的要回滚、有的不回滚),客户端必须知道这些细节。
这就是外观模式回应的压力:多个子系统需要按顺序协调才能完成一项业务操作,协调逻辑(含异常与补偿)被复制到多个入口,且客户端被迫了解子系统细节。 外观把这些收拢成一个粗粒度的 fulfill(order) 操作。
三、本质与结构速写
本质:用一个粗粒度入口封装"多个子系统的调用顺序、异常策略和补偿逻辑",让客户端只表达业务意图。
两个层次要分清:
- 纯委托型外观:外观只是把调用转发给子系统,不做额外编排。适用于"子系统之间没有顺序依赖,只是调用入口太分散"的场景。这种外观很薄,价值有限,容易被误认为"多此一举的一层"。
- 编排型外观:外观负责调用顺序、事务边界、异常转换、补偿逻辑。这是实践中真正有价值的外观,也是最容易膨胀成上帝对象的外观。
三条不变量,审查时必须检查:
- 子系统不知道外观:子系统的接口签名里不应出现外观类型,子系统可以独立测试、独立使用;
- 外观不新增业务规则:外观只做"协调",不做"决策"。如果外观里出现"VIP 用户跳过发货"这种业务分支,说明业务规则漏到了外观层——它应该属于领域服务,外观只负责调用。
- 客户端仍可直接访问子系统:外观是便利入口,不是唯一入口。一旦系统里出现"所有对子系统的访问都必须经过外观"的硬性约定,外观就变成了代理或网关,职责已经变了。
四、Java 实现:编排型外观
4.1 标准形态
// Facade:对外只暴露一个粗粒度操作
public class OrderFulfillmentFacade {
private final InventoryService inventory;
private final PaymentService payment;
private final ShippingService shipping;
private final NotificationService notification;
public OrderFulfillmentFacade(InventoryService inventory, PaymentService payment,
ShippingService shipping, NotificationService notification) {
this.inventory = inventory;
this.payment = payment;
this.shipping = shipping;
this.notification = notification;
}
public FulfillmentResult fulfill(Order order) {
// 1. 扣库存
if (!inventory.lock(order.items())) {
throw new OutOfStockException(order.id());
}
// 2. 收款,失败则释放库存
PaymentResult pay;
try {
pay = payment.charge(order.userId(), order.amount());
} catch (PaymentException e) {
inventory.release(order.items());
throw new FulfillmentException("payment failed", e);
}
// 3. 发货,失败则退款 + 释放库存
try {
shipping.schedule(order.id(), order.address());
} catch (ShippingException e) {
payment.refund(pay.transactionId());
inventory.release(order.items());
throw new FulfillmentException("shipping failed", e);
}
// 4. 通知,失败不回滚
try {
notification.send(order.userId(), "order confirmed");
} catch (NotificationException e) {
log.warn("notify failed, orderId={}", order.id(), e);
}
return new FulfillmentResult(pay.transactionId());
}
}
客户端:
public class OrderController {
private final OrderFulfillmentFacade fulfillment; // 只依赖外观
public void placeOrder(Order order) {
try {
fulfillment.fulfill(order);
} catch (FulfillmentException e) {
// 客户端只需要处理一种异常,不需要知道是哪个子系统失败
throw new ApiException("order failed: " + e.getMessage());
}
}
}
三个 Java 特有细节:
- 异常归一化是外观的核心价值之一。客户端从"要 catch 三种子系统异常、且每种处理策略不同"变成"只 catch
FulfillmentException"。这不是隐藏信息,而是把子系统异常翻译成业务语义——客户端关心的是"履约失败",不是"支付网关超时"。 - 补偿逻辑必须与调用顺序一一对应。上面第 2 步失败释放库存、第 3 步失败退款 + 释放库存,顺序不能乱。补偿逻辑是外观里最容易写错的部分,也是审查重点。
- 外观不应承担事务边界,除非子系统本身不提供事务。如果四个子系统共享一个数据库事务,事务边界应该由更上层的应用服务管理,外观只负责调用顺序。外观里写
@Transactional通常意味着职责越界。
4.2 外观不必是一个新类
如果协调逻辑只有几行、且只被一个入口使用,外观可以是一个方法:
public class OrderApplicationService {
public void placeOrder(Order order) {
inventory.lock(order.items());
// ...
}
}
外观模式的本质是"把协调知识收拢到一处",而不是"必须新建一个 Facade 类" 。方法、类、模块都可以承担外观角色。判断标准是:协调逻辑是否被多处复用、是否需要独立测试、是否值得一个明确的命名。三者都成立时,独立类更合适。
4.3 外观膨胀的信号
外观最容易出的问题是"什么都往里塞"。几个典型信号:
- 外观方法数量超过 10 个,且彼此不相关;
- 外观开始依赖越来越多的子系统,构造函数参数超过 6 个;
- 外观里出现业务分支(“如果是 VIP 用户……”);
- 客户端开始
instanceof判断外观返回的具体类型。
出现这些信号时,应该按业务能力拆成多个外观(下单外观、退款外观、对账外观),而不是让一个外观承担所有编排。外观的粒度应该匹配"业务操作的粒度",而不是"子系统的数量"。
五、Python 实现:模块即外观,函数即入口
5.1 最自然的形态:一个模块 + 一个函数
Python 里外观常常不需要一个类——一个模块本身就是命名空间,一个函数就是入口:
# fulfillment.py
from inventory import InventoryService
from payment import PaymentService
from shipping import ShippingService
from notification import NotificationService
_inventory = InventoryService()
_payment = PaymentService()
_shipping = ShippingService()
_notification = NotificationService()
class FulfillmentError(Exception):
"""对客户端暴露的统一异常。"""
def fulfill(order: Order) -> str:
if not _inventory.lock(order.items):
raise FulfillmentError(f"out of stock: {order.id}")
try:
txn = _payment.charge(order.user_id, order.amount)
except PaymentError as e:
_inventory.release(order.items)
raise FulfillmentError("payment failed") from e
try:
_shipping.schedule(order.id, order.address)
except ShippingError as e:
_payment.refund(txn)
_inventory.release(order.items)
raise FulfillmentError("shipping failed") from e
try:
_notification.send(order.user_id, "order confirmed")
except NotificationError:
logger.warning("notify failed, order=%s", order.id, exc_info=True)
return txn
客户端:
from fulfillment import fulfill, FulfillmentError
try:
fulfill(order)
except FulfillmentError as e:
raise ApiError(f"order failed: {e}") from e
结构和 Java 版一一对应:fulfill 是外观方法,_inventory / _payment / _shipping / _notification 是子系统引用,FulfillmentError 是归一化异常。差别在于——Python 用"模块 + 函数"就完成了外观的全部职责,不需要 class OrderFulfillmentFacade。这是总览篇"模式被语言吸收"的又一例:外观的意图(收拢协调、简化入口)不变,类结构被模块和函数吸收了。
5.2 需要依赖注入时:普通类
如果子系统实例需要从外部注入(便于测试、便于切换实现),外观写成一个普通类更合适:
class OrderFulfillmentFacade:
def __init__(self, inventory, payment, shipping, notification):
self._inventory = inventory
self._payment = payment
self._shipping = shipping
self._notification = notification
def fulfill(self, order: Order) -> str:
... # 与上面相同的编排逻辑
判断标准:子系统实例是"模块级单例"还是"需要注入" 。前者用模块函数更轻,后者用类更清晰。Python 不需要为了"看起来像外观模式"而把模块函数改写成类。
5.3 外观不必是唯一入口
一个容易过度的做法是"规定所有对子系统的访问都必须经过外观"。Python 里更务实的做法是:外观提供便利入口,子系统仍然可以被直接调用。比如库存服务在"库存盘点"场景下可能被直接调用,不需要经过履约外观——外观服务的是"履约"这件事,不是"库存"这件事。
# 履约走外观
fulfill(order)
# 库存盘点直接调子系统,不经过外观
inventory.reconcile()
外观是"场景化"的便利入口,不是"全局"的访问约束。 一旦它变成了约束,它就不是外观了,而是网关或代理。
5.4 外观 vs 依赖注入框架
FastAPI 的 Depends、dependency-injector 等框架,本质上是把"子系统装配"和"调用编排"分开:外观负责编排,DI 容器负责装配。这是现代 Python 工程里外观最常见的落点——外观类/函数只关心"按什么顺序调",子系统实例由框架注入。
六、双语言对照表
| 维度 | Java | Python |
|---|---|---|
| 典型实现 | Facade 类,持有子系统引用,暴露粗粒度方法 |
模块 + 函数;需要注入时用普通类 |
| 接口 | 新增一个类/接口,客户端依赖它 | 函数/模块即入口,无显式接口 |
| 子系统是否感知外观 | 否,子系统可独立使用 | 否,子系统可独立使用 |
| 异常归一化 | 外观把多种子系统异常翻译成一种业务异常 | 同样需要,常用自定义 Exception 子类 + from e 保留原因 |
| 协调逻辑复用 | 外观类被多处注入 | 模块函数被多处 import |
| 样板代码量 | 较高(类 + 构造注入) | 极低(模块函数) |
| 主要风险 | 外观膨胀成上帝对象、承担业务规则、事务边界错位 | 隐式约定、异常归一化被忽略、外观变成"什么都往里塞"的模块 |
| 现代替代 | 应用服务层、Spring @Service 编排、API Gateway |
应用服务函数、FastAPI Depends、API Gateway |
记忆锚点:外观 = 一个粗粒度入口,封装子系统的调用顺序与异常;它简化"怎么访问",不约束"能不能访问"。
七、现代视角:AI 生成外观时,审查什么
外观是 AI 生成质量"结构对、边界常错"的模式——因为它的结构(一个类持有若干子系统、暴露一个方法)极其模板化,而协调逻辑的完整性、异常策略、职责边界恰恰是模板之外的东西。
诊断阶段,先判断"这里需不需要一个外观"。 如果只是两三个子系统、调用顺序稳定、只在一个入口使用,那直接写在应用服务里就够——外观的价值在于"协调知识被多处复用、且值得独立命名和测试" 。AI 看到"多个子系统"就会生成外观类,但它不会先问"这个协调逻辑会不会被退款、补单、手工重试复用"。如果会复用,外观值得建;如果只有一处,直接写方法更诚实。
生成阶段,用编排语义而非模式名下指令。 “让下单流程按扣库存→收款→发货→通知的顺序执行,每一步失败时的补偿动作必须明确,客户端只需要处理一种业务异常”——这个描述会迫使 AI 处理顺序、补偿和异常归一。只说"用外观模式封装订单流程",AI 大概率生成一个逐行转发、没有补偿、异常原样抛出的空壳。
审查阶段,外观的检查清单:
- 协调逻辑是否真的被多处复用?如果只有一处调用,这个外观是不是多余的?
- 每一步失败时的补偿动作是否完整?补偿顺序是否与调用顺序严格相反?
- 异常是否被归一化成客户端能理解的业务语义?还是把子系统异常原样穿透?
- 外观里有没有业务规则(“VIP 跳过发货”、“金额超过 X 走人工审核”)?有的话,它该属于领域服务,不是外观。
- 外观是否在膨胀?方法数、依赖数是否已经超出"一个业务操作"的合理范围?
- 子系统是否仍然可以独立使用、独立测试?有没有出现"必须经过外观"的硬约定?
- Python 版:异常归一化是否做了?
from e是否保留了原始原因?模块级外观的子系统实例是否在测试中可替换?
一个务实判断:外观模式在现代架构里最重要的落点是"应用服务层"和"API 网关" 。应用服务层(Spring 的 @Service、FastAPI 的路由处理函数)本质上就是外观——它协调领域服务、仓储、消息队列,对控制器暴露粗粒度操作。API 网关则是系统级的外观——它把下游多个微服务协调成对客户端的一个入口。AI 在这些场景下生成外观是高频且合理的,但审查重点从"类结构"转向"编排语义":补偿是否完整、异常是否归一、外观是否承担了不属于它的业务规则、以及客户端是否还保留着直接访问子系统的能力——最后一点尤其重要,因为一旦外观变成唯一入口,它就从"便利"变成了"约束",职责已经变了。
八、三十秒自测
- 外观模式和适配器、代理、中介者,各自处理的是什么关系?为什么说外观是"简化"而不是"转换"或"控制"?
- 编排型外观里,补偿逻辑为什么必须与调用顺序严格对应?如果补偿顺序写反了,最坏会发生什么?
- 在你的项目里找一处"客户端为了完成一件事要按顺序调三四个服务"的地方,判断它该不该收敛成外观,以及收敛后哪些子系统应该保留直接访问能力。
- 点赞
- 收藏
- 关注作者
评论(0)