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)避免重复初始化。

⚠️ 避坑指南 饿汉式虽简单但可能造成资源浪费;懒汉式需处理并发问题;DCL实现需声明volatile字段防止指令重排;反射与序列化可能破坏单例,需重写readResolve()或使用枚举实现(Effective Java推荐)。

枚举单例示例(最安全实现):

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配置。

💡 实战技巧 使用建造者模式时,建议将build()方法设为final防止子类覆盖;可添加校验逻辑(如非空检查)在build()中执行;对于不可变对象,确保返回克隆副本而非原始引用。

订单对象建造者示例:

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接口屏蔽不同数据库驱动的差异。

💡 设计原则 外观模式应遵循“最小知识原则”——仅暴露必要接口;避免外观类成为万能类(God Object);可配合工厂模式动态创建子系统实例。

行为型模式:对象交互的指挥家

行为型模式关注对象间的职责分配与通信,核心是“将行为抽象为对象”,从而实现行为的可配置性与可复用性。

策略模式:算法的灵活切换

策略模式定义一系列算法,将每个算法封装起来,并使它们可互换。其结构包含:策略接口、具体策略实现与上下文。

典型应用:支付网关(微信/支付宝/银联)、排序算法(快速排序/归并排序)、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)。

⚠️ 注意事项 观察者过多可能导致通知性能瓶颈;需考虑异步通知(避免阻塞主题对象);循环依赖可能引发栈溢出;建议使用WeakReference避免内存泄漏。

自定义观察者实现:

@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个)。
  • 模式混淆:将代理模式与装饰者模式混用,导致代码逻辑混乱。
  • 滥用单例:将所有工具类设为单例,忽视其状态管理复杂性。
  • 忽视测试:模式导致类数量激增,但未同步增加单元测试覆盖率。
💡 实用建议 遵循“YAGNI原则”(You Aren't Gonna Need It)——仅在需求明确需要时引入模式;优先使用组合而非继承;通过重构逐步引入模式,而非反向设计。

设计模式与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大高频问题,助您快速解决实战困惑。

Q1: 为什么工厂方法比直接new更好?

A:直接new耦合了创建逻辑与业务逻辑;工厂方法将创建逻辑集中管理,便于统一修改(如更换实现类)、支持延迟初始化、便于单元测试(Mock工厂)。例如:Spring通过FactoryBean实现复杂Bean的创建逻辑封装。

Q2: 代理模式与装饰者模式如何选择?

A:若需增强对象功能(如添加日志、加密),用装饰者模式;若需控制访问(如权限校验、远程调用),用代理模式。核心判断:是否需要“代理对象与目标对象行为一致”。例如:Spring AOP中@Around是代理模式(控制方法执行),而RequestWrapper是装饰者模式(增强请求)。

Q3: 单例模式如何防止反射攻击?

A:枚举单例天然免疫反射攻击;普通单例需在构造器中检查实例是否已存在(若存在则抛异常),或重写clone()方法防止克隆破坏单例。但最推荐方式仍是使用枚举实现(《Effective Java》Item3)。

Q4: 策略模式与状态模式有何区别?

A:策略模式中,策略由客户端选择;状态模式中,状态由对象内部状态自动切换。例如:支付方式选择是策略模式(用户选微信/支付宝);订单状态流转是状态模式(待付款→已付款→已发货,由系统自动流转)。

Q5: 装饰者模式会增加对象数量吗?

A:是的,每个装饰者都是新对象。但通过组合而非继承,避免了类爆炸(若用继承,N个功能需2^N个子类)。JDK的BufferedInputStream通过装饰者包装FileInputStream,仅增加少量对象,换取功能灵活性。

Q6: 责任链模式如何避免无限循环?

A:需确保责任链有终止条件(如最后一个处理器必须处理请求);每个处理器明确声明是否处理请求;避免循环依赖(如Handler A→B→C→A)。Spring的FilterChain通过doFilter()调用next.filter()实现安全传递。

Q7: 建造者模式适合所有对象吗?

A:不建议用于简单对象(字段≤3个)。建造者模式的代码量远超构造器,仅在对象复杂(字段多、可选参数多)时体现价值。例如:Order对象有10个字段,用建造者更清晰;User对象仅3个字段,直接构造器即可。

Q8: 为什么Spring不直接用工厂模式而用IoC容器?

A:工厂模式管理单个类的创建;IoC容器管理整个对象生命周期(创建、初始化、销毁、依赖注入)。Spring的BeanFactory是工厂模式的延伸,而ApplicationContext进一步支持事件发布、AOP等高级功能,是更全面的解决方案。

Q9: 享元模式如何处理共享对象的修改?

A:享元对象应设计为不可变(Immutable);若需修改,采用“外享元”模式——将可变状态分离为外部状态(由客户端管理)。例如:String的value数组是final的(不可变),但StringBuilder通过可变字符数组实现修改。

Q10: 设计模式是否影响性能?

A:合理使用不会显著影响性能,甚至可能优化性能(如单例减少对象创建、享元减少内存占用)。需避免过度设计(如用10个装饰者包装一个简单对象)。建议:用JMH基准测试验证关键路径性能,数据驱动决策。

学习路径建议

  1. 入门阶段:重点掌握单例、工厂、策略、观察者模式,结合Spring源码理解。
  2. 进阶阶段:学习代理、装饰者、责任链模式,实践AOP与拦截器开发。
  3. 专家阶段:研究建造者、状态、访问者模式,参与框架级设计(如自定义ORM、RPC框架)。

推荐资源:《设计模式:可复用面向对象软件的基础》(GoF)、《Effective Java》第3版(Item 1-15)、Spring Framework官方文档。