编程范式与设计模式 / 知识点
设计模式选型与应用速查
对象创建与生命周期
把具体对象的创建延迟到实现方,调用代码依赖稳定的产品抽象;适合产品类型持续扩展且创建选择不应散落在业务代码中的场景。
工厂方法
工厂方法把“创建哪一种具体产品”的决定交给实现方,使用者只依赖产品抽象;当新增产品类型时,可以增加对应创建实现,而不必把大量具体类判断散落到业务代码中。
成立边界
工厂方法适合产品具有稳定抽象,但具体类型会扩展或由上下文决定的场景。它解决的是单类产品的创建扩展问题,并不意味着任何 new 都应被工厂替代。
如果对象构造简单、类型固定,而且调用方本来就应该知道具体类型,直接创建通常更清楚。若必须同时创建多个相互匹配的产品,则更接近抽象工厂的职责。
与简单工厂和抽象工厂的区别
| 方式 | 创建决策放在哪里 | 更适合解决什么问题 |
|---|---|---|
| 简单工厂 | 一个集中式创建方法 | 根据条件选择少量具体类型 |
| 工厂方法 | 不同创建者实现各自的工厂方法 | 让单类产品的创建随实现扩展 |
| 抽象工厂 | 一个工厂接口中的一组创建方法 | 创建彼此兼容的一整组产品 |
关键区别不是有没有名为 Factory 的类,而是创建职责如何扩展。工厂方法通常让新增产品通过新增创建者实现接入,而不是持续修改一个集中式条件分支。
最小例子
假设通知模块统一依赖 Notifier。邮件和短信都实现这个产品抽象,而不同创建者分别决定实例化 EmailNotifier 或 SmsNotifier。业务流程可以继续面向 Notifier 工作,不需要知道具体构造细节。
当以后增加新的通知类型时,可以增加对应实现和创建者;如果反而不断在一个 create(type) 方法里增加 if 或 switch,那更接近简单工厂,而不是典型的工厂方法结构。
通过统一工厂接口创建一组相互匹配的对象,避免客户端绑定具体产品族;适合需要整体切换数据库、平台或组件实现的场景。
抽象工厂
抽象工厂通过一个统一的工厂抽象创建一组彼此匹配的产品,让使用者能够整体切换产品族,而不直接依赖其中任何具体实现。
成立边界
抽象工厂适合多个对象必须保持同一实现族的场景。例如一套 UI 组件需要同时提供相互匹配的按钮和输入框,不同平台各自提供完整的一组实现;调用方选择一次工厂后,再通过该工厂创建整套组件。
它的优势来自“产品族一致性”。如果实际上只有一种产品需要扩展,工厂方法通常更直接;如果不同产品之间没有兼容或成组切换关系,把它们强行塞进同一个抽象工厂反而会扩大接口。
与工厂方法的区别
| 模式 | 主要变化维度 | 创建对象的关系 |
|---|---|---|
| 工厂方法 | 某一种产品的具体实现 | 通常围绕单类产品扩展 |
| 抽象工厂 | 整个产品族 | 一次提供多种相互匹配的产品 |
两者可以组合使用:抽象工厂规定一组创建能力,而具体工厂实现这些创建方法。判断时应先问“是否需要保证多个产品属于同一族”,而不是只看代码中工厂方法的数量。
最小例子
假设 UIFactory 同时负责创建 Button 和 TextField。WindowsFactory 返回 Windows 风格的两个组件,MacFactory 返回 macOS 风格的两个组件。应用只持有一个 UIFactory,因此不会无意中组合 Windows 按钮和 macOS 输入框。
这里真正需要保护的是整组对象的一致性。如果应用只创建按钮,并不存在成组产品需要一起切换,那么使用抽象工厂通常没有必要。
把复杂对象的分步构造与最终表示分离,减少超长构造参数和非法组合;适合可选参数多、构造过程存在约束的对象。
建造者
建造者(Builder)把复杂对象的构造步骤集中到独立构造器中,调用方逐步提供必要或可选信息,最后一次性创建满足约束的对象。
成立边界
建造者适合构造参数较多、可选项较多,或创建前需要检查参数组合的对象。它解决的是对象如何被组织和构造,而不是决定运行时应该创建哪一种具体类型。
如果对象只有两三个含义明确的参数,普通构造函数或静态工厂通常更直接。若 Builder 只是机械地为每个字段增加一个 setter,却没有改善可读性、不可变性或约束检查,引入它的收益有限。
与工厂的区别
| 概念 | 主要关注点 | 典型结果 |
|---|---|---|
| 建造者 | 一个复杂对象如何分步组装 | 根据多项配置得到最终对象 |
| 工厂 | 应该创建哪一种对象 | 隐藏具体类型的选择和实例化 |
两者可以组合:工厂负责选择具体产品或 Builder,Builder 再负责收集参数并完成复杂对象的构造。
最小例子
假设创建 HTTP 请求对象时,URL 和方法是必需信息,超时、请求头和重试次数都是可选项。Builder 可以让调用方只设置需要的选项,最后在 build() 时统一检查 URL 是否存在、超时是否为正数等约束。
相比 Request(url, method, timeout, headers, retries, ...) 这类不断增长的构造函数,Builder 能让参数含义更明确,也能避免依靠参数位置表达配置。
通过复制已有实例产生新对象,复用昂贵的初始化结果;适合对象创建成本高且新实例与模板高度相似,但需明确深拷贝与共享状态边界。
原型
原型(Prototype)以一个已经存在的对象为模板,通过复制其状态产生新对象,从而避免每次都从零执行相同或昂贵的初始化过程。
成立边界
原型适合新对象与模板对象初始状态高度相似,并且重新构造、加载或计算这些状态成本较高的场景。复制后的对象是否真正独立,取决于内部引用采用浅拷贝、深拷贝还是有意共享。
如果对象创建本身很便宜,或者复制后仍需重做绝大多数初始化工作,Prototype 通常不会带来明显收益。对象持有文件句柄、数据库连接、锁等外部资源时,也不能假定普通字段复制就能得到有效的新实例。
浅拷贝与深拷贝
| 方式 | 嵌套可变对象 | 主要边界 |
|---|---|---|
| 浅拷贝 | 原对象与副本可能共享引用 | 一方修改共享对象可能影响另一方 |
| 深拷贝 | 需要独立的嵌套状态也被复制 | 复制成本更高,并需定义资源如何处理 |
深拷贝并不意味着无条件复制对象图中的一切。不可变值可以安全共享,而连接、线程、锁等运行时资源通常需要重新建立或明确禁止复制。
最小例子
一个报表模板已经完成字体、页面布局和几十项默认样式的初始化。创建新报表时,可以复制模板,再修改标题和数据区域,而不必重新执行全部样式配置。
如果模板和副本中的 sections 指向同一个可变列表,那么修改副本的章节也可能改变模板;只有业务要求两者独立时,才应复制该列表及必要的内部对象。
限制某类对象在约定作用域内只有一个实例并提供统一访问点;适合确有唯一资源语义的对象,不应作为隐藏依赖和全局状态的替代方案。
单例
单例是在约定作用域内限制某类对象只有一个实例,并让需要它的代码获得同一实例的创建型模式;判断是否适用时,关键是确认业务或资源是否真的具有唯一实例语义。
边界
“只有一个实例”必须先说明作用域。进程内单例通常只能保证当前进程或运行时中的唯一性;多进程、多容器或分布式部署后,每个进程都可能拥有自己的实例,因此不能据此推导出集群级唯一。
单例也不等于“任何地方都能直接访问的全局变量”。创建限制与依赖传递是两个问题:即使某对象只有一个实例,也可以通过构造函数或依赖注入显式交给使用者,从而保留依赖关系的可见性和可测试性。
与相邻概念的区别
| 概念 | 核心约束 | 典型区别 |
|---|---|---|
| 单例 | 约定作用域内只有一个实例 | 强调实例数量与访问方式 |
| 全局变量 | 数据可从广泛作用域直接访问 | 不保证所属对象只有一个实例 |
| 依赖注入中的单例作用域 | 容器在指定作用域复用同一对象 | 唯一性由容器及其作用域规则管理 |
最小例子
一个进程只创建一个应用配置注册表,并把同一实例注入多个服务,可以体现单例的实例复用语义。但如果应用启动三个独立进程,通常会得到三个注册表实例,而不是整个部署环境共享一个实例。
集成适配与结构解耦
把已有接口转换成调用方需要的接口,使不兼容组件能够协作;常用于接入第三方 SDK、遗留系统或统一多个供应商接口。
适配器
适配器是在不要求调用方直接依赖原有接口的前提下,把已有组件的接口转换为调用方期望的接口;当第三方 SDK、遗留代码或不同供应商接口形状不一致时,可用它隔离这种差异。
边界
适配器解决的是接口不兼容:它可以转换方法名、参数结构、返回对象或异常表达,但不应借机承载大量业务规则。若主要任务是为复杂子系统提供一个更简单的统一入口,更接近外观模式;若目标是动态增加对象职责,则更接近装饰器模式。
适配也不意味着必须抹平所有供应商差异。无法可靠映射的能力、错误语义或约束应显式暴露,否则统一接口看似简单,却可能隐藏重要行为差异。
与相邻模式的区别
| 模式 | 主要目的 | 是否重点改变接口 |
|---|---|---|
| 适配器 | 让不兼容接口能够协作 | 是 |
| 外观 | 为复杂子系统提供更简单的入口 | 不一定 |
| 装饰器 | 在保持原接口的基础上附加职责 | 通常否 |
最小例子
假设业务层只认识 PaymentGateway.pay(amount),供应商 SDK 却提供 charge(total)。适配器可以实现 pay,在内部把金额转换成供应商要求的参数后调用 charge。业务层因此只依赖自己的支付接口,替换供应商时主要修改对应适配器。
在复杂子系统前提供更稳定、更简单的入口,隐藏内部调用顺序和组件组合;适合为领域能力、基础设施或第三方系统建立粗粒度边界。
外观
外观(Facade)是在复杂子系统前提供一个更简单、稳定的统一入口,由它协调内部多个对象完成常用任务,从而降低调用方对内部结构和调用顺序的依赖。
边界
外观主要解决入口复杂和耦合扩散问题。它可以封装多个组件的组合调用,但通常不改变这些组件本身的能力,也不要求禁止调用方直接访问底层接口。
当调用方必须了解多个内部对象、固定调用顺序或大量初始化细节才能完成一个业务动作时,适合引入外观。若只是两个接口形状不兼容,则更接近适配器;若目标是控制对象访问,则更接近代理。
与相邻模式的区别
| 模式 | 核心目的 | 是否主要改变调用入口 |
|---|---|---|
| 外观 | 简化对子系统的使用 | 是,提供更粗粒度入口 |
| 适配器 | 让不兼容接口能够协作 | 是,但重点是接口转换 |
| 代理 | 控制对原对象的访问 | 通常保持相近接口 |
外观关注的是“调用方不必知道内部怎样协作”,而不是把一种接口机械转换成另一种接口。
最小例子
订单提交原本要求调用方依次执行库存检查、支付预授权和订单保存。增加 OrderFacade.submit() 后,由外观负责协调这三个组件,调用方只表达“提交订单”这一粗粒度意图。
这并不意味着库存、支付和订单组件被合并成一个对象;它们仍可保持各自职责,外观只是提供稳定的组合入口。
常见误解
外观不是“把所有方法集中到一个万能类”。如果不断把无关业务能力塞进同一个外观,它会逐渐变成职责混乱的上帝对象。合理边界应围绕一组内聚的子系统能力,而不是单纯追求入口数量更少。
保持原接口不变,通过对象包装动态叠加职责;适合日志、缓存、鉴权等可组合横切能力,避免为不同功能组合创建大量子类。
装饰器
装饰器(Decorator)是在保持对象原有接口可替换性的前提下,用一层或多层包装对象动态叠加职责,使功能组合不必依赖大量不同的子类。
边界
装饰器成立的关键是包装对象与被包装对象遵循相同的抽象契约:调用方仍面向原接口使用对象,而每层装饰器在转发调用前后增加自己的行为。
它适合日志、缓存、鉴权、指标等能够独立组合的职责。如果新增行为会改变核心业务语义,或者包装后已经无法按照原接口理解和使用,就不宜仅为了形式上的复用而采用装饰器。
与相邻模式的区别
| 模式 | 核心目的 | 典型关系 |
|---|---|---|
| 装饰器 | 动态叠加职责 | 包装对象并保持相同抽象 |
| 代理 | 控制对目标对象的访问 | 代理代表目标对象 |
| 适配器 | 转换不兼容接口 | 把一种接口映射成另一种 |
| 继承 | 静态扩展类型行为 | 功能组合在类型层级确定 |
装饰器和代理在结构上都可能持有目标对象,但装饰器强调可组合地增加职责;代理强调访问控制、延迟加载或远程访问等间接访问目的。
最小例子
一个 DataService 提供数据读取能力。缓存装饰器包装它后先检查缓存,日志装饰器再包装缓存装饰器并记录调用信息。调用方始终依赖 DataService,却可以按需要组合“日志 + 缓存”等职责。
如果改用继承为每种组合建立类型,日志、缓存、鉴权三种独立能力就可能产生大量组合子类;装饰器把这些变化拆成可独立包装的对象。
常见误解
装饰器不是任意“包一层对象”。如果包装类暴露完全不同的接口,它更可能是适配器;如果各层存在严格顺序依赖,也要明确组合规则,否则交换装饰器顺序可能改变行为,例如缓存命中后是否仍记录底层调用。
使用代理对象控制对真实对象的访问,并在调用前后加入远程访问、延迟加载或权限控制;重点在访问控制而非扩展对象职责。
代理
代理模式是在客户端与真实对象之间放置一个具有相同访问接口的代理对象,由代理决定何时、以何种条件把请求转交给真实对象。需要控制访问、延迟创建或封装远程访问时,可以用它把这些访问逻辑与真实对象的核心职责分开。
边界
代理的关键是控制对既有对象的访问,而不是改变这个对象承担的业务职责。代理通常保留与真实对象兼容的接口,使调用方不必知道自己访问的是代理还是真实对象。
常见用途包括权限检查、延迟加载、缓存以及远程代理。若新增逻辑已经改变对象提供的能力或语义,就不能仅因为存在一层包装便称为代理。
与装饰器的区别
| 模式 | 主要目的 | 包装后的关注点 |
|---|---|---|
| 代理 | 控制如何访问真实对象 | 是否访问、何时访问、在哪里访问 |
| 装饰器 | 动态增加对象职责 | 为原有能力叠加新行为 |
两者在代码结构上都可能持有同一接口的对象,因此容易混淆。判断时应看设计意图:权限代理先判断调用是否允许,关注的是访问控制;给输出流叠加压缩能力,则更接近装饰器。
最小例子
图片服务的代理可以先检查用户是否有查看权限,通过后才调用真实图片服务。调用方仍使用“读取图片”这一能力,代理没有把真实服务改造成另一种业务对象,只控制请求能否到达它。
常见误解是把所有“外面包一层”的结构都叫代理。包装形式只是实现特征,真正的区分依据是这一层是否主要负责访问控制或访问间接化。
把两个可独立变化的维度拆成抽象与实现组合,避免通过继承产生组合爆炸;适合业务类型与平台实现都需要独立扩展的场景。
桥接
桥接模式把两个需要独立变化的维度拆成各自的类型体系,再通过组合建立联系。遇到“业务类型 × 平台实现”之类的二维扩展问题时,可以分别增加两侧类型,而不必为每种组合建立一个子类。
边界
桥接成立的关键是存在至少两个相对独立的变化维度,并且两侧需要自由组合。抽象侧持有实现侧的接口,通过委托完成具体工作;这里的“实现”是模式中的角色,不等同于某个类的内部实现细节。
如果系统只有一个变化维度,普通组合或策略通常已经足够。桥接也不是为了消除所有继承,而是避免用一棵继承树同时表达多个正交维度。
与策略的区别
| 模式 | 主要问题 | 典型关系 |
|---|---|---|
| 桥接 | 两个维度都需要独立扩展并自由组合 | 抽象体系 × 实现体系 |
| 策略 | 同一任务需要在多个算法或行为间替换 | 上下文 → 可替换策略 |
两者都偏好组合,因此结构可能相似。桥接强调拆开两个长期演化的类型维度;策略更关注运行时替换某项行为,不要求上下文自身也形成独立扩展维度。
最小例子
假设消息分为“普通通知”和“紧急通知”,发送渠道分为“邮件”和“短信”。若使用继承组合,容易出现“普通邮件通知”“普通短信通知”“紧急邮件通知”“紧急短信通知”等类型。桥接可以分别维护通知类型与发送渠道,再组合出所需搭配。

常见误解是只要“接口加组合”就是桥接。只有当组合明确用于分离两个可独立演化的维度,并避免组合数量随着两侧类型相乘增长时,桥接这一设计意图才成立。
把单个对象与对象集合组织成树形结构,并通过共同接口统一处理;适合菜单、组织结构、规则树等需要递归组合和遍历的模型。
组合
组合模式把单个对象与对象集合组织成树形结构,并让调用方通过共同接口一致地处理叶子节点和组合节点。
边界
它适合对象天然存在“部分—整体”层级,而且客户端需要递归遍历或统一执行操作的场景。典型结构包含叶子节点和可容纳子节点的组合节点;两者共享核心接口,因此调用方通常不必在每一层判断当前对象是单个元素还是集合。
组合模式解决的是树形对象结构与统一操作,并不意味着任意集合都应设计成树。若对象之间没有稳定的父子关系,或者业务必须严格区分叶子与容器可执行的操作,强行统一接口反而可能隐藏非法调用。
与装饰器的区别
| 模式 | 主要关系 | 核心目的 |
|---|---|---|
| 组合 | 一个节点包含零个或多个子节点 | 表达部分与整体,并支持递归处理 |
| 装饰器 | 一个包装对象持有一个被包装对象 | 在不修改原对象的情况下叠加职责 |
两者都可能形成递归对象结构,但组合关注层级组织,装饰器关注能力增强。
最小例子
菜单可以由菜单项和子菜单组成。菜单项是叶子节点,子菜单是组合节点;如果二者都提供 render(),调用方就能从根菜单开始递归渲染整棵菜单树,而不必为每层分别编写处理逻辑。
常见误解是把“组合”理解为普通的对象包含关系。只有当单个对象和对象集合需要形成层级,并且共同接口能带来统一递归处理时,组合模式才体现出主要价值。
共享大量对象中可复用的内部状态,把变化状态移到对象外部,从而降低内存开销;适合实例数量巨大且重复状态明显的场景。
享元
享元模式把大量对象中重复且可共享的状态集中复用,并把依赖具体使用场景的变化状态留在共享对象之外,以减少重复对象带来的内存开销。
边界
享元成立的关键不是“对象很多”,而是大量实例中存在占比可观、可安全共享的重复状态。共享部分通常称为内部状态,应尽量稳定且不依赖某个具体使用位置;位置、上下文或其他每次使用都可能不同的信息作为外部状态,由调用方在使用时提供。
如果对象数量不大、重复状态很少,或者为了拆分状态需要引入大量查找与参数传递,享元增加的复杂度可能超过节省的资源。可变共享状态还可能让一个调用方的修改影响其他使用者,因此尤其需要明确共享对象的可变性边界。
与对象池的区别
| 模式 | 复用什么 | 主要目的 |
|---|---|---|
| 享元 | 可同时被多个上下文共享的内部状态或对象 | 减少大量重复状态占用的内存 |
| 对象池 | 有创建或获取成本、通常会被借出和归还的对象 | 控制创建成本与资源数量 |
享元对象可以同时服务多个使用位置;对象池中的实例通常存在获取、占用和归还的生命周期,因此两者的复用语义不同。
最小例子
文本编辑器显示十万个字符时,不必为每个字符对象分别保存相同字体的字体名称、字形或样式数据。多个字符可以共享字体相关对象,而字符在文档中的位置等变化信息由外部保存。
常见误解是认为享元等同于缓存。缓存关注避免重复计算或获取,享元关注让大量逻辑对象共享重复状态;两者都可能使用键查找对象,但解决的问题并不相同。
规则变化与行为选择
把可替换算法封装为统一接口,由上下文按条件选择实现;适合计价、路由、排序和风控规则等存在多种互斥算法的场景。
策略
策略模式把一组可互换的算法或规则封装为具有统一契约的独立实现,让上下文在不改动主流程的前提下选择其中一种行为。
边界
它适合目标相同、算法不同且需要互换的场景,例如同一次计价只能选择会员价、促销价或普通价中的一种计算策略。变化点应当能够形成清晰、稳定的统一接口;如果只是少量固定条件且没有独立演化需求,直接条件分支通常更简单。
策略负责“怎样完成某项计算或决策”,上下文负责准备输入、选择策略并使用结果。策略本身不应为了选择其他策略而重新复制上下文的分派逻辑,否则职责边界会再次混合。
与相邻模式的区别
| 模式 | 主要变化点 | 典型关系 |
|---|---|---|
| 策略 | 同一任务有多种可替换算法 | 上下文组合一个策略并选择实现 |
| 模板方法 | 主流程固定,部分步骤允许变化 | 基类定义骨架,子类覆盖步骤 |
| 状态 | 对象行为随内部状态迁移而变化 | 当前状态通常决定后续行为和状态转换 |
策略的选择通常来自外部条件或配置;状态模式虽然也会把行为拆成多个对象,但重点是表达对象状态及其迁移,而不是单纯替换算法。
最小例子
结算系统定义统一的“计算运费”契约,并分别提供普通配送和加急配送算法。订单上下文根据用户选择使用其中一个策略,两种实现接收相同类型的订单信息并返回运费,但计算规则互不相同。
这里真正被封装的是可替换的运费算法。如果所谓策略不仅计算运费,还各自控制下单、支付、发货整条流程,它们就已经超出了单一算法变化的边界。
在稳定流程骨架中保留若干可覆盖步骤,使不同实现复用主流程;适合整体步骤固定、局部行为变化且继承关系合理的场景。
模板方法
模板方法模式在基类中固定一套算法或业务流程的执行骨架,把允许变化的局部步骤交给子类实现或覆盖,从而复用流程顺序而替换局部行为。
边界
它成立的关键是整体流程稳定、少数步骤变化,并且不同实现之间存在合理的继承关系。例如文件导入都遵循“读取、解析、校验、保存”的顺序,而 CSV 与 JSON 只需要采用不同的解析步骤。
流程顺序应由模板方法集中控制,子类只实现预留的变化点。如果子类需要频繁改变步骤顺序、跳过大量阶段,甚至复制整个模板方法才能工作,通常说明共同骨架并不稳定,不适合继续使用该模式。
与相邻模式的区别
| 模式 | 复用与变化方式 | 典型关系 |
|---|---|---|
| 模板方法 | 复用固定流程,覆盖局部步骤 | 基于继承 |
| 策略 | 替换完整算法或规则 | 基于组合 |
| 工厂方法 | 延迟决定要创建的具体对象 | 子类覆盖创建步骤 |
模板方法强调“流程不变,步骤可变”;策略更适合把一整项可替换行为作为对象注入。当继承关系只是为了复用代码而缺少真正的类型关系时,组合通常比模板方法更合适。
最小例子
一个报表导出基类固定“加载数据 → 格式化 → 写出文件”的顺序,其中加载和写出逻辑可以共用,而格式化步骤由 CSV 报表和 JSON 报表分别实现。调用方只触发统一的导出流程,不负责重新编排这些步骤。
这个例子中,稳定资产是导出流程的执行顺序。若 CSV 和 JSON 连加载方式、处理阶段及输出流程都完全不同,强行抽取共同模板只会制造空方法和条件判断。
把不同状态下的行为分别封装,让对象随状态切换改变响应方式;适合订单、审批和任务等状态多且条件分支持续膨胀的模型。
状态模式
状态模式把对象在不同状态下的行为分别封装到状态对象中,并让上下文通过切换当前状态改变行为,避免大量条件分支持续散落在业务代码里。
成立边界
它适合对象存在有限且明确的状态集合,并且同一操作会随状态产生明显不同的行为。例如订单的待支付、已支付、已取消,可以分别决定“支付”“取消”等操作是否合法以及执行什么逻辑。
状态模式不等于只把状态值换成枚举。如果主要逻辑仍是一个不断增长的 if 或 switch,行为并没有真正随状态封装。状态很少、分支稳定且逻辑简单时,直接条件判断通常更清晰。

与策略模式的区别
| 模式 | 变化来源 | 切换含义 |
|---|---|---|
| 状态 | 对象当前所处状态 | 通常反映生命周期变化,并可能由执行结果触发下一状态 |
| 策略 | 可替换的算法或规则 | 通常由调用方或配置选择,不表示对象生命周期 |
两者结构可能相似,但意图不同:状态模式回答“对象现在处于什么阶段,因此应该怎样响应”,策略模式回答“当前任务选择哪一种算法或规则”。
最小例子
订单处于“待支付”时调用取消操作,可以进入“已取消”;订单已经“已支付”后再次调用取消操作,则由“已支付”状态决定拒绝普通取消或进入另一套退款流程。调用入口可以相同,响应由当前状态决定。
常见误解是看到状态字段就立即使用状态模式。真正的信号是行为随状态显著变化,而且条件分支持续膨胀;只有状态值变化、行为几乎不变时,没有必要引入额外状态对象。
让请求依次经过一组处理节点,每个节点决定处理、拒绝或继续传递;适合过滤器、审批链和校验流水线等可组合处理流程。
责任链模式
责任链模式把多个处理节点按顺序连接起来,让请求沿链传递,每个节点只负责自己的判断与处理,并决定是否终止或继续交给后继节点。
成立边界
它适合处理步骤可以独立组合、顺序有意义,而且调用方不应直接依赖具体处理者的场景,例如请求过滤、权限校验、审批和数据验证。新增或移除节点时,通常只需调整链的组装,而不必改写调用方的主流程。
如果所有步骤都必须固定执行,并且步骤之间共享大量上下文和强顺序依赖,普通流程编排往往更直接。责任链也不保证请求一定被成功处理;链尾仍可能得到拒绝或无人处理的结果。

与固定流水线的区别
| 方式 | 节点职责 | 流程控制 |
|---|---|---|
| 责任链 | 节点相对独立,可组合或替换 | 节点可以决定继续或终止传递 |
| 固定流水线 | 步骤通常属于预先确定的整体流程 | 编排器通常明确控制每一步执行 |
责任链强调处理者之间的解耦和传递决策;仅仅把多个函数按顺序调用,并不自动构成责任链。
最小例子
一次 API 请求先经过“格式校验”,通过后进入“身份校验”,再进入“权限校验”。任何节点发现问题都可以直接拒绝请求;只有前面的节点全部放行,请求才继续到最终业务处理器。
常见误解是认为责任链中的每个节点只能“处理或跳过”。实际设计还要明确终止条件、节点顺序和链尾行为,否则请求可能被重复处理、意外放行,或传到链尾后没有明确结果。
把一次操作及其参数封装成独立对象,使发起者与执行者解耦;适合任务队列、审计、撤销、重试以及操作需要延迟执行的场景。
命令
命令模式把“要执行什么”及其必要参数封装成独立对象,使请求的发起者不必直接依赖具体执行者;当操作需要排队、记录、延迟执行、撤销或受控重试时尤其适用。
成立边界
核心边界是把操作本身对象化。调用方持有命令并触发统一执行入口,命令再调用真正完成业务动作的接收者。仅把一段逻辑抽成普通函数,并不因此构成命令模式。
命令对象可以携带执行所需参数,也可以记录撤销需要的旧状态。但“封装成命令”本身不会自动提供可靠重试、事务或持久化;跨进程任务仍需要队列、存储和幂等机制配合。
与策略模式的区别
| 概念 | 主要封装对象 | 典型目的 |
|---|---|---|
| 命令 | 一次操作及其参数 | 延迟、排队、记录、撤销或重试操作 |
| 策略 | 可互换的算法或规则 | 在多个实现之间选择行为 |
策略通常回答“这件事采用哪种算法做”,命令通常回答“把哪次操作作为对象交给系统执行”。两者都能减少直接依赖,但变化维度不同。
最小例子
下面用 JavaScript 展示最小命令对象:调用方只调用统一的 execute(),不知道接收者具体怎样保存文本。
``js class SaveCommand { constructor(editor, text) { this.editor = editor; this.text = text; }
execute() { // 命令保存本次操作需要的参数,再委托真正的接收者执行。 return this.editor.save(this.text); } }
const editor = {
save(text) {
return saved: ${text};
}
};
const command = new SaveCommand(editor, "draft"); console.log(command.execute()); ``
预期输出:
saved: draft这里 SaveCommand 是命令,editor 是实际执行保存动作的接收者。之后即使调用方把命令放入队列,它仍可通过相同的 execute() 入口执行。
常见误解是认为“用了一个 Command 类”就获得了撤销和可靠重试。撤销需要保存足够的逆操作信息;重试还必须处理重复执行、失败分类和副作用。
对象协作与事件通知
建立一对多通知关系,让主题变化时订阅者获得通知;适合进程内事件传播,但需关注订阅生命周期、执行顺序和失败隔离。
观察者
观察者模式建立主题与多个订阅者之间的一对多通知关系:主题发生约定事件时通知已注册观察者,而不需要逐个依赖具体观察者实现。
成立边界
观察者模式的关键是订阅关系和变化通知,适合界面状态更新、领域对象内部通知等进程内协作。发布者只面向统一通知约定,不负责了解每个订阅者的具体业务。
它不等同于可靠消息系统。经典进程内观察者通常不会天然提供消息持久化、跨进程投递、消费确认或失败重放;这些能力需要事件总线或消息中间件等额外机制。
与发布订阅的区别
| 概念 | 典型关系 | 常见边界 |
|---|---|---|
| 观察者 | 主题维护或可访问观察者订阅关系 | 常用于对象间、进程内通知 |
| 发布订阅 | 发布者与订阅者通常经事件通道或中介解耦 | 可扩展到跨模块、跨进程消息传播 |
两者都包含“一次变化通知多个消费者”,术语在具体框架中也可能混用。判断时应看订阅关系由谁维护、通知是否经过独立中介,以及是否要求可靠投递。
最小例子
假设订单对象在状态改变后通知库存视图和审计记录两个观察者。主题只需要逐个调用统一通知接口,而无需知道观察者内部怎样处理事件。

如果其中一个观察者取消订阅,后续通知不再发送给它,但其他观察者仍保持订阅关系。这正是观察者模式希望隔离的对象协作变化。
常见误解是认为观察者天然异步且互不影响。实际实现完全可以同步逐个调用;此时某个观察者执行缓慢或抛出异常,可能影响后续通知,因此执行顺序、异常隔离和取消订阅生命周期都需要显式设计。
把多个对象之间复杂的直接交互集中到中介对象协调,降低网状依赖;适合参与者较多且交互规则需要集中治理的协作场景。
中介者
中介者模式把多个对象之间的协作集中交给一个中介对象协调,使参与者不必彼此直接持有和调用,从而减少网状依赖。
边界
它适合参与者较多、交互规则复杂,而且这些规则需要集中调整的场景,例如多个界面控件联动或多个协作组件互相影响。中介者负责协调关系,不意味着应该接管参与者自身的业务职责。
当只有两三个对象存在简单、稳定的单向调用时,直接协作通常更清楚。若把所有业务逻辑都塞入中介者,它会逐渐变成难以维护的集中式大对象。

与观察者的区别
| 模式 | 核心关系 | 主要目的 |
|---|---|---|
| 中介者 | 多个参与者通过中介协调 | 减少参与者之间复杂的直接依赖 |
| 观察者 | 发布者向多个订阅者发送变化通知 | 建立一对多的事件通知关系 |
中介者强调谁来协调协作规则;观察者强调状态变化后通知谁。中介者内部可以使用事件通知,但两种模式解决的问题并不相同。
最小例子
对话框中有“用户名输入框”“密码输入框”和“登录按钮”。如果两个输入框分别直接控制按钮,参与者会互相了解;引入中介者后,输入框只报告自身变化,中介者统一判断两个字段是否有效,再决定是否启用登录按钮。
常见误解是把“统一入口”都称为中介者。只有当对象间原本存在需要协调的多方交互,并由中介对象承担这些协作规则时,才体现了中介者模式的核心价值。
在不暴露集合内部表示的前提下提供统一遍历方式,使遍历算法与数据结构解耦;适合自定义集合或需要多种遍历策略的结构。
迭代器
迭代器模式通过独立的遍历接口按顺序访问集合元素,使调用方无需知道集合内部使用数组、链表、树或其他结构保存数据。
边界
迭代器负责维护遍历过程中的位置或状态,而集合负责保存和组织元素。调用方依赖迭代协议取得当前或下一个元素,因此更换集合内部表示时,可以避免同步改写遍历代码。
它尤其适合自定义集合、需要隐藏内部结构,或同一集合需要多种遍历方式的场景。若语言和标准集合已经提供合适的迭代协议,通常直接使用现有机制,不必额外设计一套迭代器抽象。
与直接遍历的区别
| 方式 | 调用方需要知道什么 | 适合场景 |
|---|---|---|
| 迭代器 | 统一的取值与推进协议 | 隐藏集合结构、统一不同集合的遍历方式 |
| 直接按索引遍历 | 集合支持索引及其边界 | 数组、列表等索引语义明确的结构 |
| 直接访问节点 | 节点连接方式等内部结构 | 集合内部实现代码或明确需要结构信息的算法 |
迭代器不是为了让循环写法更复杂,而是把“怎样在结构中移动”从使用集合的代码中分离出来。
最小例子
假设一个自定义集合最初用数组保存任务,调用方通过迭代器依次取得任务。以后内部改成链表,只需调整集合和迭代器的实现;只依赖迭代协议的调用方仍按相同方式遍历,无需知道元素之间如何连接。
常见误解是认为迭代器必须复制整个集合。通常迭代器只保存当前位置等遍历状态;至于遍历期间集合发生修改时如何处理,则取决于具体集合和迭代协议的约定,不能由模式本身统一推断。