备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

Java所有设计模式|全面解析23种设计模式及实战应用

深入解析Java中23种经典设计模式,涵盖创建型、结构型、行为型三大类,提供代码示例、适用场景、优缺点对比及实战建议,助开发者构建高质量、可维护的Java系统。

设计模式概览

设计模式(Design Pattern)是软件开发人员在长期开发实践中总结出的、可复用的解决方案。它们不是具体代码,而是解决特定问题的通用模板。Java作为一门成熟、稳定的编程语言,其生态系统广泛支持设计模式的实现,尤其在Spring、MyBatis等主流框架中大量应用了经典设计模式。

在Java开发中,掌握设计模式不仅是面试加分项,更是提升系统可读性、可扩展性与可维护性的关键能力。设计模式起源于建筑学领域,由Christopher Alexander提出,后被面向对象编程领域吸收并演化为23种经典模式,被广泛称为“Gang of Four(GoF)设计模式”。这23种模式按目的可分为三类:创建型(5种)、结构型(7种)、行为型(11种),每种模式都针对特定问题提供了优雅的解法。

值得注意的是,设计模式的使用需结合具体业务场景。盲目套用反而可能导致过度设计、性能下降或维护困难。例如,在高并发场景下,单例模式可能需要考虑线程安全,而简单工厂与抽象工厂的选择则需权衡系统扩展性与复杂度。本页将从开发者的实际需求出发,逐层展开解析。

为什么说设计模式是Java工程师的“内功心法”?

设计模式本质上是面向对象设计原则(如SOLID原则)的具体实践。它帮助开发者:

  • 解耦合:通过接口编程降低模块间依赖,提升模块独立性;
  • 高内聚:让类职责单一,便于测试与复用;
  • 易扩展:开闭原则(对扩展开放,对修改关闭)使新增功能无需修改已有代码;
  • 可维护性:清晰的结构让后期维护者快速理解系统逻辑。

以Spring Framework为例,其核心容器(BeanFactory、ApplicationContext)大量使用了工厂模式、单例模式、模板方法模式;AOP模块依赖代理模式;事件机制基于观察者模式。理解这些模式,才能真正读懂框架源码,实现从“调用者”到“架构者”的跃迁。

⚡ 设计模式的三大核心价值

设计模式的价值远超代码复用本身,其深层意义体现在:

  • 沟通效率:团队成员用统一术语交流(如“这里用策略模式”),减少歧义;
  • 风险预判:提前识别扩展点与变更点,避免后期重构;
  • 设计验证:通过模式反推设计合理性,发现潜在耦合点。

设计模式分类体系

GoF提出的23种设计模式根据其目标可分为三大类,每类解决不同层次的设计问题:

创建型模式(5种)

关注对象创建机制,抽象实例化过程,使系统独立于对象的创建、组合和表示。

  • 单例模式(Singleton)
  • 工厂方法模式(Factory Method)
  • 抽象工厂模式(Abstract Factory)
  • 建造者模式(Builder)
  • 原型模式(Prototype)

适用场景:需要动态配置对象创建逻辑、避免硬编码构造参数、支持多种变体实例的系统。

结构型模式(7种)

关注类与对象的组合,形成更大结构,简化结构关系。

  • 适配器模式(Adapter)
  • 装饰器模式(Decorator)
  • 代理模式(Proxy)
  • 外观模式(Facade)
  • 桥接模式(Bridge)
  • 组合模式(Composite)
  • 享元模式(Flyweight)

适用场景:系统需动态添加功能、接口兼容、树形结构建模、资源池管理等。

行为型模式(11种)

关注对象间的职责分配与通信,描述对象如何交互及分配责任。

  • 观察者模式(Observer)
  • 策略模式(Strategy)
  • 命令模式(Command)
  • 责任链模式(Chain of Responsibility)
  • 状态模式(State)
  • 模板方法模式(Template Method)
  • 访问者模式(Visitor)
  • 中介者模式(Mediator)
  • 迭代器模式(Iterator)
  • 备忘录模式(Memento)
  • 解释器模式(Interpreter)

适用场景:事件驱动系统、算法切换、状态机建模、日志链追踪等复杂交互场景。

1994年
《设计模式:可复用面向对象软件的基础》出版
由Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides(四人帮)合著,首次系统化提出23种设计模式,奠定现代软件工程基石。
2004年
Spring Framework 1.0发布
大量采用工厂模式、单例模式、代理模式,推动设计模式在Java企业级开发中的普及。
2014年
Java 8引入Lambda表达式
简化观察者模式、策略模式等实现,如Runnable、Comparator等函数式接口直接支持模式应用。
2021年
响应式编程兴起
Reactor、RxJava推动观察者模式与装饰器模式在异步流处理中的新应用。
2023年
AOT编译与GraalVM成熟
对代理模式、装饰器模式提出新挑战——需确保运行时反射行为在编译期可分析。

核心模式详解(含实战代码)

单例模式(Singleton)

确保一个类只有一个实例,并提供全局访问点。Java中常见于配置管理、线程池、日志对象等场景。

关键点:私有构造器、静态实例、线程安全、延迟加载(可选)、防止反射/序列化破坏。

实现方式对比

方式 优点 缺点 适用场景
饿汉式 线程安全、实现简单 类加载即实例化,可能浪费资源 实例占用小、启动即需
DCL(双重检查锁) 延迟加载、性能较好 需volatile防重排序,代码复杂 高并发下延迟加载需求
静态内部类 延迟加载、线程安全、实现简洁 JVM依赖强 推荐默认方案
枚举单例 天然防止反射/序列化破坏 无法延迟加载 需要极高安全性的场景
// 静态内部类实现(推荐) public class Logger { private Logger() {} private static class Holder { private static final Logger INSTANCE = new Logger(); } public static Logger getInstance() { return Holder.INSTANCE; } public void log(String msg) { System.out.println("[LOG] " + msg); } }

常见陷阱:在分布式系统中,JVM层面的单例≠全局唯一。需结合Redis、ZooKeeper实现分布式单例,或改用服务级单例(如单节点部署)。

工厂模式(Factory)

定义一个创建对象的接口,但让子类决定实例化哪个类。将对象创建与使用分离,解耦客户端与具体实现。

工厂方法 vs 抽象工厂:

  • 工厂方法:一个工厂生产一种产品(如DBFactory → MySQL/Oracle连接);
  • 抽象工厂:一个工厂生产多种相关产品(如DBFactory → Connection + Statement + ResultSet)。
// 工厂方法示例:数据库连接 interface DBConnection { void connect(); } class MySQLConnection implements DBConnection { public void connect() { System.out.println("MySQL connected"); } } class OracleConnection implements DBConnection { public void connect() { System.out.println("Oracle connected"); } } interface DBFactory { DBConnection createConnection(); } class MySQLFactory implements DBFactory { public DBConnection createConnection() { return new MySQLConnection(); } } // 客户端代码 DBFactory factory = new MySQLFactory(); DBConnection conn = factory.createConnection(); conn.connect(); // 输出:MySQL connected

Spring中的应用:BeanFactory通过getBean()方法隐藏具体类的构造细节,支持依赖注入与生命周期管理,本质是工厂模式的高级变体。

观察者模式(Observer)

定义对象间一对多依赖关系,当一个对象状态改变时,所有依赖者自动通知更新。Java中常见于GUI事件处理、消息订阅系统。

核心角色:Subject(主题)、Observer(观察者)、通知机制。

// Java内置支持(java.util.Observable已过时,推荐自定义) class WeatherData { private List observers = new ArrayList<>(); private float temperature; public void addObserver(Observer o) { observers.add(o); } public void removeObserver(Observer o) { observers.remove(o); } public void setTemperature(float t) { this.temperature = t; notifyObservers(); } private void notifyObservers() { observers.forEach(o → o.update(temperature)); } } interface Observer { void update(float temp); }

响应式扩展:Reactor(Project Reactor)的Flux/Mono、RxJava的Observable均基于观察者模式,但增强为支持背压(Backpressure)、错误处理、异步调度的响应式流。

策略模式(Strategy)

定义一系列算法,将每个算法封装起来,并使它们可互换。让算法独立于使用它的客户端而变化。

典型应用:支付方式选择(微信/支付宝/银联)、排序算法切换、压缩算法(GZIP/ZIP)。

// 支付策略示例 interface PaymentStrategy { void pay(int amount); } class WeChatPay implements PaymentStrategy { public void pay(int amount) { System.out.println("WeChat Pay: " + amount); } } class Alipay implements PaymentStrategy { public void pay(int amount) { System.out.println("Alipay: " + amount); } } class PaymentContext { private PaymentStrategy strategy; public void setStrategy(PaymentStrategy s) { this.strategy = s; } public void executePayment(int amount) { strategy.pay(amount); } } // 客户端 PaymentContext ctx = new PaymentContext(); ctx.setStrategy(new Alipay()); ctx.executePayment(100);

Java 8+增强:通过Lambda表达式,策略类可简化为函数式接口实现,代码更简洁。如Comparator.comparing(User::getName)本质是策略模式的Lambda版本。

代理模式(Proxy)

为其他对象提供一种代理以控制对这个对象的访问。常用于延迟加载、安全控制、远程代理、智能引用。

静态代理 vs 动态代理:

  • 静态代理:编译期生成代理类,代码冗余;
  • 动态代理:运行期生成,Java通过Proxy+InvocationHandler或CGLIB实现。
// JDK动态代理:Spring AOP默认方式 interface UserService { void save(); } class UserServiceImpl implements UserService { public void save() { System.out.println("User saved"); } } class LoggingHandler implements InvocationHandler { private Object target; public LoggingHandler(Object t) { this.target = t; } public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { System.out.println("Before: " + m.getName()); Object result = m.invoke(target, args); System.out.println("After: " + m.getName()); return result; } } // 使用 UserService proxy = (UserService) Proxy.newProxyInstance(..., new LoggingHandler(new UserServiceImpl())); proxy.save();

注意事项:动态代理仅支持接口代理;若需代理类,需使用CGLIB(通过继承实现),但无法代理final类/方法。

关键模式对比表

面对相似需求,不同模式的选择需权衡场景、性能与可维护性。以下为高频对比场景:

对比维度 工厂模式 vs 抽象工厂 策略模式 vs 状态模式 装饰器 vs 代理
核心目的 工厂:创建单一产品族;抽象工厂:创建多产品族 策略:封装算法;状态:封装状态行为,状态改变触发行为变化 装饰器:动态增强功能;代理:控制访问权限
客户端感知 客户端只依赖工厂接口,不关心具体产品 策略:客户端切换策略;状态:对象自身状态驱动行为 装饰器:客户端感知增强功能;代理:客户端可能不知代理存在
Java典型实现 Spring BeanFactory(工厂);JDBC DriverManager(抽象工厂) java.util.Collections.sort()(策略);java.nio.channels.Channel(状态) java.lang.reflect.Proxy(代理);java.io.BufferedInputStream(装饰器)
扩展性 抽象工厂更易扩展产品族;工厂方法更易扩展产品类型 策略:新增算法易;状态:新增状态需修改上下文 装饰器:可链式叠加;代理:通常一对一

⚙️ 实战决策树

面对“需要创建对象”时:

  1. 是否需要隐藏创建逻辑?→ 是 → 工厂模式;否 → 直接new
  2. 是否涉及多种相关产品?→ 是 → 抽象工厂;否 → 工厂方法
  3. 是否需延迟加载?→ 是 → 懒加载单例;否 → 饿汉单例

面对“需要切换算法”时:

  1. 算法是否互斥?→ 是 → 策略模式
  2. 行为是否依赖状态?→ 是 → 状态模式

Java设计模式实战指南

理论需结合实践。以下为高频实战场景及模式应用建议:

〈电商订单系统〉

使用策略模式+工厂模式实现多支付方式:

  • 定义PaymentStrategy接口;
  • 微信/支付宝/银联实现接口;
  • 通过支付类型工厂返回策略;
  • 订单服务调用executePayment(),无需关心实现。

优势:新增支付方式仅需新增类+注册工厂,无需修改订单逻辑。

〈日志系统〉

使用装饰器模式动态添加日志功能:

  • LogWriter接口定义write();
  • FileWriter实现基础写入;
  • EncryptDecorator装饰加密;
  • CompressDecorator装饰压缩;
  • 客户端组合使用:new CompressDecorator(new EncryptDecorator(new FileWriter()))。

优势:功能自由组合,避免继承爆炸。

〈用户认证服务〉

使用责任链模式实现多级认证:

  • AuthHandler抽象类定义next()与handle();
  • TokenHandler、SessionHandler、IPRateHandler实现;
  • 客户端构建链:tokenHandler.setNext(sessionHandler).setNext(ipHandler);
  • 请求进入时,链自动流转,任一环节失败则中断。

优势:解耦认证逻辑,支持动态增删处理节点。

新手常见误区

许多开发者陷入“模式强迫症”,需警惕:

  • 为用而用:在简单场景强行套用模式(如用单例存常量);
  • 过度设计:为未来可能的需求提前扩展,增加复杂度;
  • 忽视性能:如代理模式引入反射,高并发下可能成瓶颈;
  • 忽略语言特性:Java 8+应优先用Lambda简化策略/观察者。

正确做法:先实现功能,再重构;用单元测试验证模式是否真正提升可维护性。

高频问题解答

⑴ 单例模式一定线程安全吗?

否。饿汉式、静态内部类、枚举式线程安全;DCL需volatile;普通懒汉式不安全。分布式系统中需额外机制保证全局唯一。

⑵ 代理模式与装饰器模式区别?

代理:控制访问(权限/延迟/远程);装饰器:增强功能。代理对象与原对象接口一致;装饰器可扩展接口。代理常隐藏原对象;装饰器常暴露增强对象。

⑶ 策略模式如何避免大量if-else?

用Map注册策略:Map。客户端传入key,直接获取策略。结合工厂模式,通过配置中心动态注册策略类。

⑷ 哪些模式易导致性能下降?

代理模式(反射开销)、装饰器(多层包装)、观察者(通知所有订阅者)。需结合缓存、异步通知、选择性订阅优化。

⑸ Java 8+如何简化观察者模式?

用Consumer或Predicate替代Observer接口;Subject用List>存储;通知时forEach(c→c.accept(data))。