设计模式(十):外观模式——当完成一件事要按顺序协调五个子系统

举报
小不点和猫 发表于 2026/11/16 08:30:02 2026/11/16
【摘要】 一、模式原理定义:外观模式为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。拆开看,这个定义包含三个要点:一组接口,一个界面:外观面对的是多个子系统,但它只暴露一个统一的入口;高层接口:外观提供的不是子系统的原子能力,而是"完成一件事"的粗粒度操作;降低使用复杂度:客户端不需要知道子系统怎么划分、调用顺序是什么、异常如何处理。意图:当多...

一、模式原理

定义:外观模式为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

拆开看,这个定义包含三个要点:

  • 一组接口,一个界面:外观面对的是多个子系统,但它只暴露一个统一的入口;
  • 高层接口:外观提供的不是子系统的原子能力,而是"完成一件事"的粗粒度操作;
  • 降低使用复杂度:客户端不需要知道子系统怎么划分、调用顺序是什么、异常如何处理。

意图:当多个子系统需要被按特定顺序协调才能完成一项任务,而这项任务在业务上是一个整体时,用一个外观把协调逻辑收拢起来,让客户端只表达"我要做什么",而不是"我要先调 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);
    }
}

问题有三层:

  1. 协调逻辑与业务入口混在一起:placeOrder 里一半是"订单业务的决策",一半是"子系统调用的顺序和补偿"。后者是编排知识,不是订单业务本身。
  2. 协调逻辑会被复制:退款流程、定时补单流程、后台手工重试流程,都需要"扣库存→收款→发货"这套顺序和补偿。每复制一次,补偿逻辑就可能漏掉一处。
  3. 客户端被迫了解子系统的异常语义: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 大概率生成一个逐行转发、没有补偿、异常原样抛出的空壳。

审查阶段,外观的检查清单:

  1. 协调逻辑是否真的被多处复用?如果只有一处调用,这个外观是不是多余的?
  2. 每一步失败时的补偿动作是否完整?补偿顺序是否与调用顺序严格相反?
  3. 异常是否被归一化成客户端能理解的业务语义?还是把子系统异常原样穿透?
  4. 外观里有没有业务规则(“VIP 跳过发货”、“金额超过 X 走人工审核”)?有的话,它该属于领域服务,不是外观。
  5. 外观是否在膨胀?方法数、依赖数是否已经超出"一个业务操作"的合理范围?
  6. 子系统是否仍然可以独立使用、独立测试?有没有出现"必须经过外观"的硬约定?
  7. Python 版:异常归一化是否做了?from e 是否保留了原始原因?模块级外观的子系统实例是否在测试中可替换?

一个务实判断:外观模式在现代架构里最重要的落点是"应用服务层"和"API 网关" 。应用服务层(Spring 的 @Service、FastAPI 的路由处理函数)本质上就是外观——它协调领域服务、仓储、消息队列,对控制器暴露粗粒度操作。API 网关则是系统级的外观——它把下游多个微服务协调成对客户端的一个入口。AI 在这些场景下生成外观是高频且合理的,但审查重点从"类结构"转向"编排语义":补偿是否完整、异常是否归一、外观是否承担了不属于它的业务规则、以及客户端是否还保留着直接访问子系统的能力——最后一点尤其重要,因为一旦外观变成唯一入口,它就从"便利"变成了"约束",职责已经变了。

八、三十秒自测

  1. 外观模式和适配器、代理、中介者,各自处理的是什么关系?为什么说外观是"简化"而不是"转换"或"控制"?
  2. 编排型外观里,补偿逻辑为什么必须与调用顺序严格对应?如果补偿顺序写反了,最坏会发生什么?
  3. 在你的项目里找一处"客户端为了完成一件事要按顺序调三四个服务"的地方,判断它该不该收敛成外观,以及收敛后哪些子系统应该保留直接访问能力。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。