设计模式

本文档用于说明当前整理的 29 个设计模式文档。这套文档面向 JDK 21 + Spring Boot 3 后端项目场景，重点不是背诵模式定义，而是理解每种模式在真实业务代码中的作用、适用场景、边界条件和常见落地方式。

当前文档体系包含：

23 个 GoF 经典设计模式
+ 1 个 Java 项目常用扩展模式：简单工厂模式
+ 5 个 Spring Boot 实战补充模式
= 共 29 个设计模式文档

设计模式是什么

设计模式是软件开发中针对常见设计问题沉淀出来的通用解决思路。它不是固定代码模板，也不是必须强行套用的架构规范，而是一种帮助代码降低耦合、隔离变化、提升扩展性和可测试性的设计方法。

在 Java 和 Spring Boot 项目中，设计模式通常用于解决以下问题：

对象如何创建
对象之间如何协作
业务流程如何复用
复杂分支如何拆分
第三方接口如何适配
多个实现如何扩展
规则如何组合和复用
状态变化如何管理
主流程和扩展动作如何解耦
业务层如何避免直接依赖技术细节

设计模式的价值不在于“用了某个模式”，而在于它是否让代码更清晰、更稳定、更容易维护。对于简单业务，直接、清晰的代码通常比强行引入模式更合适。

文档范围

本套文档共整理 29 个模式，覆盖 GoF 经典设计模式、Java 项目常用扩展模式，以及 Spring Boot 项目中的高频工程实践模式。

<modules>
    <!-- GoF 创建型模式：关注对象如何创建 -->
    <module>singleton</module>
    <module>factorymethod</module>
    <module>abstractfactory</module>
    <module>builder</module>
    <module>prototype</module>

    <!-- Java 项目常用扩展创建型模式：不属于 GoF 23 种，但项目中非常常用 -->
    <module>factory</module>

    <!-- GoF 结构型模式：关注类或对象如何组合 -->
    <module>adapter</module>
    <module>bridge</module>
    <module>composite</module>
    <module>decorator</module>
    <module>facade</module>
    <module>flyweight</module>
    <module>proxy</module>

    <!-- GoF 行为型模式：关注对象之间如何协作 -->
    <module>chain</module>
    <module>command</module>
    <module>interpreter</module>
    <module>iterator</module>
    <module>mediator</module>
    <module>memento</module>
    <module>observer</module>
    <module>state</module>
    <module>strategy</module>
    <module>template</module>
    <module>visitor</module>

    <!-- Spring Boot 实战补充模式：关注工程实践、业务解耦和代码可维护性 -->
    <module>event-driven</module>
    <module>repository</module>
    <module>specification</module>
    <module>nullobject</module>
    <module>dependency-injection</module>
</modules>

其中，factory 表示 简单工厂模式。它不是 GoF 23 种设计模式之一，但在 Java 项目中使用频率很高，适合根据业务类型、枚举、编码或配置创建不同实现对象，因此作为扩展模式单独保留。

event-driven、repository、specification、nullobject、dependency-injection 也不属于 GoF 23 种设计模式，它们更偏向 Spring Boot 项目中的工程实践，适合用于业务解耦、领域建模、规则组合、空值处理和对象装配。

GoF 经典设计模式

GoF 设计模式通常分为三类：创建型模式、结构型模式和行为型模式。

创建型模式：关注对象如何创建
结构型模式：关注对象如何组合
行为型模式：关注对象如何协作

这三类模式分别解决不同层面的设计问题。创建型模式主要处理对象创建过程，结构型模式主要处理类和对象之间的组织关系，行为型模式主要处理职责分配、流程编排、规则扩展和对象协作。

创建型模式

创建型模式用于处理对象创建问题。它们的核心目标是把复杂的创建过程从业务代码中分离出来，让调用方不直接依赖具体实现和创建细节。

模式	模块名	说明
单例模式	singleton	保证一个类在系统中只有一个实例，Spring Bean 默认就是单例
简单工厂模式	factory	根据类型创建对象，适合简单对象分发，不属于 GoF 23 种
工厂方法模式	factorymethod	把对象创建交给具体工厂，适合创建逻辑需要扩展的场景
抽象工厂模式	abstractfactory	创建一组相关对象，适合多产品族、多环境、多渠道对象创建
构建者模式	builder	分步骤构建复杂对象，适合参数多、构造过程复杂的对象
原型模式	prototype	通过复制已有对象创建新对象，适合模板复制、流程复制等场景

创建型模式在 Spring Boot 项目中常见于处理器注册、客户端创建、配置对象构建、复杂请求对象封装、第三方 SDK 对象初始化、业务执行器分发等场景。

结构型模式

结构型模式用于处理类或对象之间的组合关系。它们的核心目标是让系统结构更灵活，减少接口不兼容、类职责过重、功能增强困难、调用链路复杂等问题。

模式	模块名	说明
适配器模式	adapter	把不兼容的接口转换成系统需要的接口
桥接模式	bridge	分离两个独立变化的维度，避免类爆炸
组合模式	composite	用统一方式处理树形结构中的叶子节点和容器节点
装饰器模式	decorator	在不修改原对象的前提下动态增强功能
外观模式	facade	为复杂子系统提供统一入口，简化调用方使用
享元模式	flyweight	共享大量重复对象，减少内存开销
代理模式	proxy	通过代理对象控制真实对象访问，AOP、事务、缓存都与它相关

结构型模式在 Spring Boot 项目中常见于第三方接口适配、服务聚合、AOP 增强、缓存代理、树形菜单、权限结构、组织架构、通知渠道扩展等场景。

行为型模式

行为型模式用于处理对象之间的职责分配和协作方式。它们的核心目标是降低对象之间的耦合，让业务流程、规则、状态、操作和扩展动作更容易维护。

模式	模块名	说明
责任链模式	chain	多个处理器按顺序处理请求，适合校验链、风控链、过滤链
命令模式	command	把请求封装成命令对象，适合任务调度、操作记录、撤销补偿
解释器模式	interpreter	解释简单表达式或 DSL，适合权限表达式、规则表达式
迭代器模式	iterator	统一遍历集合、分页数据或游标数据
中介者模式	mediator	用中心对象协调多个对象协作，减少网状依赖
备忘录模式	memento	保存对象历史状态并支持恢复，适合草稿、配置、版本回滚
观察者模式	observer	对象状态变化后通知观察者，Spring Event 与它关系密切
状态模式	state	把不同状态下的行为封装到状态类中
策略模式	strategy	根据类型选择不同算法或业务处理逻辑
模板方法模式	template	固定流程骨架，把变化步骤交给子类或具体实现
访问者模式	visitor	在不修改对象结构的前提下新增操作逻辑

行为型模式在 Spring Boot 项目中出现频率很高，尤其是策略模式、模板方法模式、责任链模式、观察者模式、状态模式和命令模式。它们适合处理业务流程复杂、分支不断增加、规则频繁变化、扩展动作较多的系统。

Spring Boot 实战补充模式

除了 GoF 经典设计模式，Spring Boot 项目中还有一些非常常见的工程模式。它们不属于 GoF 23 种，但在真实项目中的使用频率很高，尤其适合复杂业务系统、DDD 分层设计、事件驱动架构和可测试代码设计。

模式	模块名	说明
事件驱动模式	event-driven	用事件解耦业务主流程和扩展动作
仓储模式	repository	隔离业务层和持久化层，让业务层面向领域对象编程
规格模式	specification	把业务规则封装成可组合、可复用的规格对象
空对象模式	nullobject	用安全默认对象替代 null，减少空判断和空指针
依赖注入模式	dependency-injection	由外部容器装配对象依赖，是 Spring 的核心基础

这些补充模式更偏工程实践。它们通常不会单独作为“模式案例”存在，而是自然地出现在 Controller、Service、Repository、Domain Service、Application Event、Bean 装配和业务规则封装中。

模式之间的常见区别

很多设计模式看起来相似，但关注点不同。理解它们的边界比记住定义更重要。

容易混淆的模式	核心区别
策略模式 vs 工厂模式	工厂负责创建对象，策略负责选择算法或业务处理
策略模式 vs 状态模式	策略通常由外部选择，状态通常由对象内部状态驱动
模板方法模式 vs 策略模式	模板方法固定流程骨架，策略模式替换某个算法或处理逻辑
装饰器模式 vs 代理模式	装饰器强调功能增强，代理强调访问控制
外观模式 vs 中介者模式	外观简化外部调用，中介者协调内部对象协作
观察者模式 vs 事件驱动模式	观察者偏对象设计，事件驱动偏工程和架构解耦
责任链模式 vs 规格模式	责任链按顺序处理请求，规格模式组合判断条件
解释器模式 vs 规格模式	解释器解析表达式，规格模式用对象表达规则
原型模式 vs 备忘录模式	原型用于复制新对象，备忘录用于保存和恢复历史状态
组合模式 vs 迭代器模式	组合组织树形结构，迭代器负责遍历结构
工厂方法模式 vs 抽象工厂模式	工厂方法创建一种产品，抽象工厂创建一组相关产品
桥接模式 vs 策略模式	桥接强调两个维度独立变化，策略强调算法或行为替换

模式之间没有绝对孤立的边界。实际项目中，一个业务场景经常会同时使用多个模式。关键是先识别变化点，再选择最能降低复杂度的设计方式。

设计模式组合使用

设计模式在实际业务中经常组合使用，但不建议为了组合而组合。组合使用的前提是：业务中确实存在多个不同的变化点，并且这些变化点需要分别隔离。

本章节只说明 GoF 23 种设计模式 + 简单工厂模式 中常见的组合方式，不包含事件驱动模式、仓储模式、规格模式、空对象模式、依赖注入模式等 Spring Boot 实战补充模式。

常用组合	适用场景	组合说明
简单工厂模式 + 策略模式	根据业务类型选择不同处理逻辑	简单工厂负责根据类型获取策略对象，策略模式负责封装具体业务算法
工厂方法模式 + 策略模式	策略对象创建逻辑本身也需要扩展	工厂方法负责扩展对象创建过程，策略模式负责扩展业务处理逻辑
模板方法模式 + 策略模式	主流程固定，局部步骤可替换	模板方法固定业务流程骨架，策略模式封装其中某个可变步骤
模板方法模式 + 责任链模式	主流程固定，但流程中存在多段校验或处理链	模板方法控制整体执行顺序，责任链负责处理其中一组连续处理节点
责任链模式 + 策略模式	多个处理节点中，每个节点内部又有不同处理算法	责任链控制处理顺序，策略模式封装节点内部的可变逻辑
外观模式 + 适配器模式	对外提供统一入口，同时需要兼容多个第三方接口	适配器负责统一外部接口差异，外观模式负责封装复杂调用流程
代理模式 + 装饰器模式	既要控制对象访问，又要增强对象能力	代理模式处理访问控制，装饰器模式处理功能增强
构建者模式 + 简单工厂模式	根据类型创建不同的复杂对象	简单工厂负责选择对象类型，构建者模式负责组装复杂对象
组合模式 + 迭代器模式	处理树形结构，并需要统一遍历	组合模式组织树形结构，迭代器模式提供统一遍历方式
状态模式 + 策略模式	对象状态会变化，不同状态下还存在不同算法	状态模式管理状态行为，策略模式封装具体算法变化

常见业务可以按下面的方式理解：

订单创建场景：
- 使用模板方法模式固定下单流程
- 使用策略模式处理不同订单类型的计价逻辑
- 使用责任链模式执行参数校验、库存校验、风控校验
- 使用状态模式管理订单待支付、已支付、已取消、已完成等状态

第三方支付场景：
- 使用外观模式提供统一支付入口
- 使用适配器模式屏蔽支付宝、微信、银联等接口差异
- 使用策略模式选择不同支付渠道的处理逻辑
- 使用简单工厂模式根据支付渠道获取对应策略对象

权限菜单场景：
- 使用组合模式表达菜单树、按钮权限、目录结构
- 使用迭代器模式统一遍历树形节点
- 使用责任链模式处理权限校验流程

设计模式组合使用时，核心是先识别变化点：

对象创建是否会变化：考虑简单工厂、工厂方法、抽象工厂、构建者
业务算法是否会变化：考虑策略模式
业务流程是否相对固定：考虑模板方法模式
处理步骤是否可以串联：考虑责任链模式
外部接口是否不统一：考虑适配器模式
调用过程是否过于复杂：考虑外观模式
对象结构是否是树形：考虑组合模式
对象状态是否影响行为：考虑状态模式

如果一个组合让代码结构更清晰、职责更明确、扩展点更稳定，就值得使用。 如果只是为了体现设计模式而增加大量接口、抽象类和实现类，反而会降低代码可读性，不建议使用。

常用设计模式排序

由于设计模式数量较多，学习和使用时不建议平均投入精力。更推荐按照 Spring Boot 后端项目中的实际使用频率 进行理解，优先掌握高频模式，再逐步补充中低频模式。

下面的排序更偏向 JDK 21 + Spring Boot 3 业务开发场景，不是设计模式理论上的重要性排名。

推荐顺序	模式	模块名	类型	常见程度	典型场景
1	策略模式	strategy	GoF 行为型	高频	多种业务处理器、支付方式、消息类型、导入导出类型
2	模板方法模式	template	GoF 行为型	高频	固定业务流程，开放部分步骤扩展
3	工厂模式	factory	Java 常用扩展	高频	根据类型创建处理器、转换器、客户端、执行器
4	责任链模式	chain	GoF 行为型	高频	参数校验、风控校验、过滤器链、审批链
5	观察者模式	observer	GoF 行为型	高频	对象状态变化后的通知、监听、回调
6	事件驱动模式	event-driven	Spring Boot 实战补充	高频	下单后通知、积分、日志、异步扩展动作
7	代理模式	proxy	GoF 结构型	高频	AOP、事务、缓存、权限、远程调用代理
8	适配器模式	adapter	GoF 结构型	高频	第三方接口适配、老系统接口兼容
9	外观模式	facade	GoF 结构型	高频	聚合多个服务调用，对外提供统一业务入口
10	构建者模式	builder	GoF 创建型	高频	构建复杂请求对象、配置对象、响应对象
11	依赖注入模式	dependency-injection	Spring Boot 实战补充	高频	Spring Bean 装配、依赖解耦、可测试代码
12	仓储模式	repository	Spring Boot 实战补充	高频	隔离业务层和数据访问层，适合领域模型
13	单例模式	singleton	GoF 创建型	高频	Spring Bean、全局配置、共享服务对象
14	状态模式	state	GoF 行为型	中高频	订单状态、审批状态、任务状态、工作流状态
15	装饰器模式	decorator	GoF 结构型	中高频	动态增强功能，例如日志、加密、压缩、包装响应
16	规格模式	specification	Spring Boot 实战补充	中高频	复杂业务规则判断、组合查询条件、规则复用
17	命令模式	command	GoF 行为型	中频	任务调度、操作封装、异步执行、撤销补偿
18	空对象模式	nullobject	Spring Boot 实战补充	中频	用默认对象替代 null，减少空判断
19	工厂方法模式	factorymethod	GoF 创建型	中频	创建逻辑需要扩展，具体工厂负责具体产品
20	组合模式	composite	GoF 结构型	中频	菜单树、部门树、权限树、分类树
21	迭代器模式	iterator	GoF 行为型	中频	统一遍历集合、分页、游标、批量数据
22	桥接模式	bridge	GoF 结构型	中低频	多维度扩展，例如渠道 + 消息类型
23	抽象工厂模式	abstractfactory	GoF 创建型	中低频	多产品族创建，例如不同云厂商的一组客户端
24	中介者模式	mediator	GoF 行为型	中低频	多对象之间复杂协作，避免网状依赖
25	原型模式	prototype	GoF 创建型	中低频	模板复制、配置复制、流程复制
26	访问者模式	visitor	GoF 行为型	低频	对稳定对象结构增加多种操作
27	备忘录模式	memento	GoF 行为型	低频	草稿保存、历史版本、配置回滚
28	享元模式	flyweight	GoF 结构型	低频	大量重复对象共享，减少内存占用
29	解释器模式	interpreter	GoF 行为型	低频	简单表达式、规则 DSL、权限表达式解析

实际学习时，可以按照下面的节奏推进：

第一阶段：优先掌握策略、模板方法、工厂、责任链、观察者、事件驱动
第二阶段：重点理解代理、适配器、外观、构建者、依赖注入、仓储模式
第三阶段：结合复杂业务学习状态、装饰器、规格、命令、组合、迭代器
第四阶段：了解桥接、抽象工厂、中介者、原型、访问者、备忘录、享元、解释器

对于大多数 Spring Boot 后端项目，最常用的不是所有 29 个模式，而是其中一部分高频模式。优先掌握这些高频模式，通常已经可以解决大部分业务分支扩展、流程复用、系统解耦和代码可维护性问题。

推荐理解方式

学习这些模式时，不建议只看 UML 或定义。更推荐从业务问题出发，先识别当前代码的主要矛盾，再选择对应的设计模式。

对象创建越来越复杂：考虑工厂、工厂方法、抽象工厂、构建者
if else 分支越来越多：考虑策略、状态、规格、责任链
多个步骤流程相似：考虑模板方法
第三方接口不兼容：考虑适配器
多个服务调用太复杂：考虑外观或中介者
主流程和扩展动作耦合：考虑观察者或事件驱动
对象需要增强能力：考虑装饰器或代理
业务对象有历史版本：考虑备忘录
树形结构需要统一处理：考虑组合
对象结构稳定但操作经常增加：考虑访问者
查询不到对象但可以默认处理：考虑空对象
业务层不想直接依赖数据库：考虑仓储模式
规则需要灵活组合：考虑规格模式
依赖对象不应该由业务类自己创建：考虑依赖注入

设计模式应该服务于代码质量，而不是增加代码复杂度。一个模式是否值得使用，主要看它是否能降低耦合、减少重复、提升扩展性、增强可测试性或隔离不稳定的变化点。

当前 29 个模式总结

这套文档最终覆盖以下 29 个模式：

序号	模式	模块名	类型
1	单例模式	singleton	GoF 创建型
2	简单工厂模式	factory	Java 常用扩展
3	工厂方法模式	factorymethod	GoF 创建型
4	抽象工厂模式	abstractfactory	GoF 创建型
5	构建者模式	builder	GoF 创建型
6	原型模式	prototype	GoF 创建型
7	适配器模式	adapter	GoF 结构型
8	桥接模式	bridge	GoF 结构型
9	组合模式	composite	GoF 结构型
10	装饰器模式	decorator	GoF 结构型
11	外观模式	facade	GoF 结构型
12	享元模式	flyweight	GoF 结构型
13	代理模式	proxy	GoF 结构型
14	责任链模式	chain	GoF 行为型
15	命令模式	command	GoF 行为型
16	解释器模式	interpreter	GoF 行为型
17	迭代器模式	iterator	GoF 行为型
18	中介者模式	mediator	GoF 行为型
19	备忘录模式	memento	GoF 行为型
20	观察者模式	observer	GoF 行为型
21	状态模式	state	GoF 行为型
22	策略模式	strategy	GoF 行为型
23	模板方法模式	template	GoF 行为型
24	访问者模式	visitor	GoF 行为型
25	事件驱动模式	event-driven	Spring Boot 实战补充
26	仓储模式	repository	Spring Boot 实战补充
27	规格模式	specification	Spring Boot 实战补充
28	空对象模式	nullobject	Spring Boot 实战补充
29	依赖注入模式	dependency-injection	Spring Boot 实战补充

总结

这套设计模式文档以 JDK 21 + Spring Boot 3 后端项目实践 为核心，覆盖 GoF 经典设计模式、Java 常用扩展模式和 Spring Boot 项目中的高频工程模式。

学习这些模式时，重点不是记住模式名称，而是理解它们分别解决什么问题：

创建型模式解决对象创建问题
结构型模式解决对象组合问题
行为型模式解决对象协作问题
补充模式解决 Spring Boot 工程实践问题

实际项目中，应优先使用能明显提升代码清晰度、扩展性、可测试性和可维护性的模式。对于简单业务，直接表达业务意图的代码通常更好；对于复杂业务，设计模式可以帮助我们把创建、组合、协作、规则、状态和扩展动作拆分到更合理的位置。