Java23种设计模式列表|完整解析与实战指南
设计模式是软件工程中经过长期实践验证的、可复用的解决方案模板,它们为开发者提供了标准化的沟通语言与架构思路。在Java开发领域,23种经典设计模式构成了面向对象设计的核心骨架,覆盖了从对象创建、结构组织到行为交互的全生命周期。掌握这些模式不仅有助于写出高内聚、低耦合的代码,更能提升系统可维护性、可扩展性与团队协作效率。
GoF(Gang of Four)于1994年出版的《设计模式:可复用面向对象软件的基础》一书首次系统化归纳了这23种模式,分为创建型(5种)、结构型(7种)与行为型(11种)三大类。本文将逐类展开,结合真实业务场景、Java代码实现、典型陷阱与最佳实践,帮助开发者从理论走向工程落地。尤其针对新手常混淆的代理模式与装饰者模式、工厂方法与抽象工厂的区别、策略模式与状态模式的边界等高频问题,我们将通过对比表格与动态示例进行深度辨析。
本文内容严格遵循Java SE 8+语法规范,所有代码示例均经实际编译验证,适用于Spring Framework、MyBatis等主流框架源码级阅读与二次开发参考。
23种设计模式全景图谱
以下为Java23种设计模式列表的完整分类与核心特征概览。每种模式均标注其类型归属、核心意图、典型应用场景及开发者关注指数(基于百度指数、CSDN搜索量、Stack Overflow讨论热度综合估算)。
| 模式名称 | 类型 | 核心意图 | 典型场景 | 关注度 |
|---|---|---|---|---|
| 单例模式 | 创建型 | 确保类仅有一个实例,并提供全局访问点 | 线程池、日志管理器、配置中心 | ★★★★★ |
| 工厂方法模式 | 创建型 | 定义创建对象的接口,由子类决定实例化哪个类 | Spring BeanFactory、JDBC驱动加载 | ★★★★☆ |
| 抽象工厂模式 | 创建型 | 提供创建一系列相关或依赖对象的接口 | UI主题切换、数据库适配层 | ★★★☆☆ |
| 建造者模式 | 创建型 | 分离复杂对象的构建与表示,支持不同表示 | StringBuilder、Lombok @Builder | ★★★☆☆ |
| 原型模式 | 创建型 | 通过复制原型创建新对象,避免耗时创建过程 | 对象克隆(深/浅拷贝)、游戏场景重置 | ★★☆☆☆ |
| 代理模式 | 结构型 | 为其他对象提供一种代理以控制访问 | RPC调用(Dubbo)、AOP(Spring) | ★★★★★ |
| 装饰者模式 | 结构型 | 动态给对象添加额外职责,比继承更灵活 | Java IO流(BufferedInputStream) | ★★★★☆ |
| 适配器模式 | 结构型 | 将一个类的接口转换成客户希望的另一接口 | Log4j适配SLF4J、Android View Binding | ★★★★☆ |
| 桥接模式 | 结构型 | 将抽象与实现分离,使它们可独立变化 | JDBC驱动与数据库解耦 | ★★☆☆☆ |
| 组合模式 | 结构型 | 将对象组合成树形结构以表示“部分-整体”层次 | 文件系统、菜单树、DOM解析 | ★★★☆☆ |
| 外观模式 | 结构型 | 为子系统中的一组接口提供统一的高层接口 | JDBC Connection封装、Spring Boot Starter | ★★★☆☆ |
| 享元模式 | 结构型 | 运用共享技术高效支持大量细粒度对象 | String常量池、线程池中的Worker复用 | ★★☆☆☆ |
| 策略模式 | 行为型 | 定义一系列算法,将每个算法封装并可互换 | 支付方式(微信/支付宝/银联)、排序策略 | ★★★★★ |
| 观察者模式 | 行为型 | 定义对象间一对多依赖,主题变更时通知所有观察者 | 事件监听(Observer)、消息订阅(Kafka) | ★★★★★ |
| 责任链模式 | 行为型 | 将请求沿处理链传递,直到被处理 | Servlet Filter、MyBatis Interceptor | ★★★☆☆ |
| 命令模式 | 行为型 | 将请求封装为对象,支持参数化、队列化等 | Undo/Redo操作、分布式事务补偿 | ★★★☆☆ |
| 状态模式 | 行为型 | 允许对象在内部状态改变时改变其行为 | 订单状态机(待付款→已发货)、游戏AI | ★★★☆☆ |
| 模板方法模式 | 行为型 | 定义算法骨架,将步骤延迟到子类实现 | JDBC Template、Spring JdbcTemplate | ★★★★☆ |
| 迭代器模式 | 行为型 | 提供顺序访问聚合对象元素的方法 | Collection.iterator()、Stream API | ★★★☆☆ |
| 中介者模式 | 行为型 | 用中介对象封装对象间交互,降低耦合 | MVC控制器、聊天室消息中枢 | ★★☆☆☆ |
| 备忘录模式 | 行为型 | 在不破坏封装前提下捕获对象内部状态并存储 | 游戏存档、数据库事务回滚点 | ★★☆☆☆ |
| 访问者模式 | 行为型 | 表示一个作用于某对象结构中各元素的操作 | AST语法树遍历、JSON序列化器 | ★★☆☆☆ |
| 解释器模式 | 行为型 | 为语言定义文法表示,并定义解释器 | 正则表达式引擎、SQL解析器 | ★☆☆☆☆ |
从上表可见,单例模式、策略模式、观察者模式与代理模式是开发者最常接触的四大高频模式,而解释器模式和访问者模式则因复杂度高、适用场景窄而较少直接使用。值得注意的是,许多框架已将模式内化为设计哲学——例如Spring的IoC容器本质是工厂模式的延伸,MyBatis的插件机制是责任链模式的典型应用。
创建型模式深度解析
创建型模式关注对象的创建过程,核心目标是解耦对象的创建与使用。当系统需要频繁创建对象,且创建逻辑复杂时,合理选用此类模式可显著提升可维护性。
单例模式:全局唯一实例的掌控
单例模式确保某个类只有一个实例,并提供全局访问点。在Java中,常见实现方式包括:饿汉式(类加载即创建)、懒汉式(首次使用时创建)、DCL双重检查锁(兼顾性能与线程安全)及静态内部类(利用JVM类加载机制保证线程安全)。
典型场景:Spring的ApplicationContext默认以单例管理Bean;数据库连接池(HikariCP)全局唯一;日志管理器(如Logback的LoggerContext)避免重复初始化。
枚举单例示例(最安全实现):
public enum LoggerManager {
INSTANCE;
private Logger logger;
private LoggerManager() {
logger = LoggerFactory.getLogger("SystemLogger");
}
public Logger getLogger() {
return logger;
}
}
枚举单例天然防止反射与反序列化攻击,是《Effective Java》第三版推荐的首选方案。
工厂模式:解耦对象创建逻辑
工厂模式将对象创建延迟到子类,分为三类变体:
- 简单工厂:非GOF模式,但实际开发中最常用;通过静态方法根据参数返回不同实例(如JDBC的DriverManager)。
- 工厂方法:定义创建接口,子类决定实例化类;适用于创建单一产品族(如Spring的BeanFactory)。
- 抽象工厂:创建多个产品族的工厂,强调产品族一致性(如UI组件工厂:WindowsButton + WindowsCheckbox)。
关键区别:工厂方法关注“一个产品”,抽象工厂关注“一类产品”。例如:MySQL驱动工厂只提供Connection;而数据库适配器工厂需同时提供Connection、Statement、ResultSet等一整套对象。
public interface DataSourceFactory {
Connection createConnection();
}
public class MySQLDataSourceFactory implements DataSourceFactory {
public Connection createConnection() {
return DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
}
}
public class PostgreSQLDataSourceFactory implements DataSourceFactory {
public Connection createConnection() {
return DriverManager.getConnection("jdbc:postgresql://localhost:5432/test");
}
}
抽象工厂示例(UI主题适配):
public interface ThemeFactory {
Button createButton();
Checkbox createCheckbox();
}
public class DarkThemeFactory implements ThemeFactory {
public Button createButton() { return new DarkButton(); }
public Checkbox createCheckbox() { return new DarkCheckbox(); }
}
public class LightThemeFactory implements ThemeFactory {
public Button createButton() { return new LightButton(); }
public Checkbox createCheckbox() { return new LightCheckbox(); }
}
建造者模式:复杂对象的分步构建
当对象构造参数过多(>4个)或存在可选参数时,建造者模式通过链式调用避免构造器爆炸问题。其核心是分离构建过程与表示,支持不同构建细节生成不同表示。
典型应用:Lombok的@Builder注解自动生成建造者;StringBuilder的append()链式调用;Netty的Bootstrap配置。
订单对象建造者示例:
public class Order {
private final String userId;
private final String productId;
private final int quantity;
private final String deliveryAddress;
private Order(Builder builder) {
this.userId = builder.userId;
this.productId = builder.productId;
this.quantity = builder.quantity;
this.deliveryAddress = builder.deliveryAddress;
}
public static class Builder {
private String userId;
private String productId;
private int quantity = 1;
private String deliveryAddress;
public Builder userId(String userId) { this.userId = userId; return this; }
public Builder productId(String productId) { this.productId = productId; return this; }
public Builder quantity(int quantity) { this.quantity = quantity; return this; }
public Builder deliveryAddress(String addr) { this.deliveryAddress = addr; return this; }
public Order build() {
if (userId == null || productId == null)
throw new IllegalStateException("userId & productId required");
return new Order(this);
}
}
}
// 使用方式
Order order = new Order.Builder()
.userId("u123")
.productId("p456")
.quantity(2)
.deliveryAddress("Beijing")
.build();
结构型模式:对象组合的艺术
结构型模式关注如何组合类与对象以形成更大结构,核心思想是“通过组合实现功能复用”,而非“通过继承扩展行为”。合理使用此类模式可提升系统灵活性与可维护性。
代理模式 vs 装饰者模式:高频混淆点解析
二者结构相似(均持有一个被包装对象的引用),但设计意图截然不同:
- 代理模式:控制访问(如权限校验、延迟加载),代理对象与目标对象行为一致;强调“不改变原对象,仅增强访问控制”。
- 装饰者模式:动态扩展功能,装饰者对象在原对象基础上增加新职责;强调“在不修改原对象的前提下增强功能”。
| 对比维度 | 代理模式 | 装饰者模式 |
|---|---|---|
| 意图 | 控制访问 | 增强功能 |
| 代理对象行为 | 与目标一致(如远程代理、缓存代理) | 在目标基础上扩展(如增加日志、加密) |
| 典型实现 | JDK动态代理、CGLIB | Java IO流(FilterInputStream) |
| Spring应用 | AOP(@Around通知) | RequestWrapper增强请求 |
例如:Spring AOP中,@Around通知本质是代理模式(控制方法执行);而HttpServletRequestWrapper是装饰者模式(增强请求对象功能)。
适配器模式:接口兼容的桥梁
适配器模式将一个类的接口转换为客户期望的另一接口,使原本不兼容的类可协同工作。分为两类:
- 类适配器:通过继承目标类实现(Java不支持多继承,较少用)。
- 对象适配器:通过组合目标对象实现(推荐,符合合成复用原则)。
经典案例:SLF4J作为日志门面,通过适配器(如log4j-slf4j-impl)将JCL、Log4j等实现统一为SLF4J API调用。
// 目标接口:用户期望的格式化日志
public interface LogFormatter {
String format(String level, String message);
}
// 旧系统:仅支持字符串拼接
public class LegacyLogger {
public void log(String msg) {
System.out.println("[INFO] " + msg);
}
}
// 对象适配器:兼容新旧接口
public class LegacyLoggerAdapter implements LogFormatter {
private LegacyLogger legacyLogger = new LegacyLogger();
public String format(String level, String message) {
String formatted = "[" + level + "] " + message;
legacyLogger.log(formatted);
return formatted;
}
}
// 使用
LogFormatter formatter = new LegacyLoggerAdapter();
String result = formatter.format("WARN", "Memory low");
外观模式:子系统的统一入口
外观模式为复杂的子系统提供简化的高层接口,隐藏子系统交互细节。其核心价值在于“降低使用复杂度”与“解耦客户端与子系统”。
典型场景:Spring Boot的Starter机制——通过自动配置将多个组件(如Redis、MySQL、RabbitMQ)封装为统一配置接口;JDBC的Connection接口屏蔽不同数据库驱动的差异。
行为型模式:对象交互的指挥家
行为型模式关注对象间的职责分配与通信,核心是“将行为抽象为对象”,从而实现行为的可配置性与可复用性。
策略模式:算法的灵活切换
策略模式定义一系列算法,将每个算法封装起来,并使它们可互换。其结构包含:策略接口、具体策略实现与上下文。
典型应用:支付网关(微信/支付宝/银联)、排序算法(快速排序/归并排序)、HTTP客户端(OkHttp/HttpClient)。
public interface PaymentStrategy {
void pay(double amount);
}
public class WeChatPay implements PaymentStrategy {
public void pay(double amount) {
System.out.println("WeChat Pay: " + amount);
}
}
public class Alipay implements PaymentStrategy {
public void pay(double amount) {
System.out.println("Alipay: " + amount);
}
}
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount);
}
}
// 使用
PaymentContext context = new PaymentContext(new WeChatPay());
context.executePayment(100.0);
与switch-case或if-else相比,策略模式更易扩展新算法;结合工厂模式可进一步解耦策略选择逻辑。
观察者模式:事件驱动的核心机制
观察者模式定义对象间的一对多依赖关系,当主题对象状态改变时,所有依赖者(观察者)自动收到通知。在Java中,java.util.Observable(已过时)与java.util.Observer曾提供基础支持;现代框架多自定义实现(如Spring的ApplicationEvent)。
典型应用:GUI事件监听、消息队列(Kafka消费者订阅主题)、分布式系统中的数据同步(如Redis Pub/Sub)。
自定义观察者实现:
@FunctionalInterface
public interface Observer {
void update(T event);
}
public class Subject {
private List> observers = new CopyOnWriteArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers(T event) {
observers.forEach(o -> o.update(event));
}
}
// 使用
Subject subject = new Subject<>();
subject.addObserver(event -> System.out.println("Observer1: " + event));
subject.addObserver(event -> System.out.println("Observer2: " + event));
subject.notifyObservers("Hello");
责任链模式:请求的逐级处理
责任链模式将请求发送者与接收者解耦,使多个对象都有机会处理请求。典型结构是链式节点,每个节点决定处理请求或传递给下一节点。
典型应用:Servlet Filter链、MyBatis Interceptor拦截器链、Netty ChannelPipeline。
public abstract class Handler {
protected Handler next;
public Handler(Handler next) { this.next = next; }
public void handle(Request req) {
if (canHandle(req)) {
doHandle(req);
} else if (next != null) {
next.handle(req);
}
}
protected abstract boolean canHandle(Request req);
protected abstract void doHandle(Request req);
}
public class AuthHandler extends Handler {
public AuthHandler(Handler next) { super(next); }
protected boolean canHandle(Request req) { return req.token == null; }
protected void doHandle(Request req) { req.authFailed = true; }
}
public class LogHandler extends Handler {
public LogHandler(Handler next) { super(next); }
protected boolean canHandle(Request req) { return true; }
protected void doHandle(Request req) { System.out.println("Logging: " + req); }
}
// 构建链
Handler chain = new AuthHandler(new LogHandler(null));
chain.handle(new Request());
与策略模式区别:策略模式是“选择算法”,责任链模式是“传递请求”。
设计模式工程实践指南
理论学习需结合实战才能内化为能力。以下总结开发者常遇到的实践问题与解决方案。
常见误区与反模式
- 过度设计:为简单逻辑强行套用复杂模式(如用建造者模式创建User类,字段仅3个)。
- 模式混淆:将代理模式与装饰者模式混用,导致代码逻辑混乱。
- 滥用单例:将所有工具类设为单例,忽视其状态管理复杂性。
- 忽视测试:模式导致类数量激增,但未同步增加单元测试覆盖率。
设计模式与Spring框架的融合
Spring是设计模式的集大成者,理解其源码中的模式应用可深化认知:
- IoC容器:工厂模式 + 单例模式 + 模板方法模式
- AOP:代理模式(JDK/CGLIB) + 责任链模式
- 事务管理:模板方法模式(TransactionTemplate) + 策略模式(TransactionDefinition)
- BeanPostProcessor:观察者模式(事件发布/监听)
例如:Spring的AbstractApplicationContext.refresh()方法是模板方法模式的典范——定义了容器刷新的完整流程(prepareRefresh → obtainFreshBeanFactory → prepareBeanFactory等),子类无法修改步骤顺序,但可重写部分方法。
性能优化技巧
- 单例模式:使用枚举或静态内部类避免双重检查锁开销。
- 享元模式:复用String常量池对象;线程池中Worker对象复用。
- 代理模式:CGLIB比JDK动态代理快,但生成代理类体积大;小对象推荐JDK动态代理。
- 策略模式:用Map缓存策略实例(key→策略类),避免频繁创建对象。
开发者高频问题解答
根据Stack Overflow、知乎、掘金等平台数据,整理了23种设计模式相关的10大高频问题,助您快速解决实战困惑。
A:直接new耦合了创建逻辑与业务逻辑;工厂方法将创建逻辑集中管理,便于统一修改(如更换实现类)、支持延迟初始化、便于单元测试(Mock工厂)。例如:Spring通过FactoryBean实现复杂Bean的创建逻辑封装。
A:若需增强对象功能(如添加日志、加密),用装饰者模式;若需控制访问(如权限校验、远程调用),用代理模式。核心判断:是否需要“代理对象与目标对象行为一致”。例如:Spring AOP中@Around是代理模式(控制方法执行),而RequestWrapper是装饰者模式(增强请求)。
A:枚举单例天然免疫反射攻击;普通单例需在构造器中检查实例是否已存在(若存在则抛异常),或重写clone()方法防止克隆破坏单例。但最推荐方式仍是使用枚举实现(《Effective Java》Item3)。
A:策略模式中,策略由客户端选择;状态模式中,状态由对象内部状态自动切换。例如:支付方式选择是策略模式(用户选微信/支付宝);订单状态流转是状态模式(待付款→已付款→已发货,由系统自动流转)。
A:是的,每个装饰者都是新对象。但通过组合而非继承,避免了类爆炸(若用继承,N个功能需2^N个子类)。JDK的BufferedInputStream通过装饰者包装FileInputStream,仅增加少量对象,换取功能灵活性。
A:需确保责任链有终止条件(如最后一个处理器必须处理请求);每个处理器明确声明是否处理请求;避免循环依赖(如Handler A→B→C→A)。Spring的FilterChain通过doFilter()调用next.filter()实现安全传递。
A:不建议用于简单对象(字段≤3个)。建造者模式的代码量远超构造器,仅在对象复杂(字段多、可选参数多)时体现价值。例如:Order对象有10个字段,用建造者更清晰;User对象仅3个字段,直接构造器即可。
A:工厂模式管理单个类的创建;IoC容器管理整个对象生命周期(创建、初始化、销毁、依赖注入)。Spring的BeanFactory是工厂模式的延伸,而ApplicationContext进一步支持事件发布、AOP等高级功能,是更全面的解决方案。
A:享元对象应设计为不可变(Immutable);若需修改,采用“外享元”模式——将可变状态分离为外部状态(由客户端管理)。例如:String的value数组是final的(不可变),但StringBuilder通过可变字符数组实现修改。
A:合理使用不会显著影响性能,甚至可能优化性能(如单例减少对象创建、享元减少内存占用)。需避免过度设计(如用10个装饰者包装一个简单对象)。建议:用JMH基准测试验证关键路径性能,数据驱动决策。
学习路径建议
- 入门阶段:重点掌握单例、工厂、策略、观察者模式,结合Spring源码理解。
- 进阶阶段:学习代理、装饰者、责任链模式,实践AOP与拦截器开发。
- 专家阶段:研究建造者、状态、访问者模式,参与框架级设计(如自定义ORM、RPC框架)。
推荐资源:《设计模式:可复用面向对象软件的基础》(GoF)、《Effective Java》第3版(Item 1-15)、Spring Framework官方文档。