java的设计模式教程——系统掌握23种设计模式核心思想与工程实践
在软件工程领域,java的设计模式教程始终是开发者进阶的必经之路。设计模式并非抽象理论,而是经过无数项目验证的、解决常见问题的标准化解决方案。本教程以Java语言为核心载体,深入剖析GOF提出的23种经典设计模式,结合真实业务场景、完整可运行代码示例、UML图解说明与常见误区预警,构建从入门到精通的完整知识体系。
无论您是初学面向对象编程的新人,还是希望重构legacy code的资深工程师,本教程均提供分层递进的学习路径:从基础概念到高阶应用,从单例模式的线程安全到策略模式的组合策略,从装饰者模式的动态扩展到责任链模式的解耦设计,每一种模式均从意图、适用场景、结构组成、优缺点分析、Java标准库对应实现、性能与可维护性权衡等多个维度展开,辅以Spring Framework、MyBatis、JDK核心类库中的实际案例解析,确保学以致用。
特别说明:本教程强调“知其然,更知其所以然”。例如,在讲解工厂模式时,不仅区分简单工厂、工厂方法、抽象工厂,更深入探讨其在Spring IoC容器中的应用机制——BeanFactory与ApplicationContext如何通过FactoryBean接口实现复杂对象的延迟创建与生命周期管理;在讲解观察者模式时,不仅对比java.util.Observer(已过时)与java.beans.PropertyChangeListener、Reactive Streams(Flow接口)的演进路径,更结合Spring ApplicationEvent体系解析事件驱动架构的现代实践。
本页面所有内容均基于Java 17+标准编写,代码示例均经实际编译与运行验证,确保技术栈的先进性与工程实用性。学习路径建议:先通读基础概念与核心模式,再按需深入实战案例与常见问题部分,最后通过综合练习与性能对比巩固提升。祝您学有所成!
网友常见学习路径参考
- 第1阶段:理解面向对象三大特性(封装、继承、多态)与SOLID原则——这是设计模式的基石
- 第2阶段:掌握
单例、工厂、代理、装饰者、策略五大基础模式——高频使用、易上手 - 第3阶段:深入
观察者、责任链、模板方法、命令等中阶模式——理解解耦思想 - 第4阶段:攻克
状态、中介者、备忘录、迭代器等低频但关键模式——应对复杂场景 - 第5阶段:结合框架源码(如Spring、Netty)反向验证模式应用——实现从“知道”到“用好”的跨越
设计模式基础:概念、分类与学习方法
什么是设计模式?为何必须掌握?
设计模式(Design Pattern)是对软件设计中普遍存在(反复出现)的各种问题,所提出的解决方案。该术语由Erich Gamma等人在《Design Patterns: Elements of Reusable Object-Oriented Software》(1994年)中首次系统提出,因此该书被尊称为GOF(Gang of Four)四人帮经典著作。
其核心价值在于:
- ✅ 提升代码复用性:避免重复造轮子,直接复用成熟结构
- ✅ 增强可维护性:降低模块耦合度,使变更影响可控
- ✅ 促进团队协作:统一设计语言,减少沟通成本
- ✅ 支持长期演进:通过组合而非继承实现灵活扩展
需警惕的误区:设计模式不是教条,更非“必须套用”的模板。它们是经验总结,需结合具体上下文(Context)灵活应用。过度设计(Over-engineering)比设计缺失危害更大——例如在仅需一个if-else的场景强行引入策略模式,反而降低可读性。
23种设计模式的分类与定位
按GOF分类法,设计模式分为三大类共23种,其分布如下:
| 类别 | 模式名称 | 核心目的 | 典型场景 |
|---|---|---|---|
| 创建型(5种) | 单例模式、工厂方法、抽象工厂、建造者、原型 | 解耦对象创建与使用 | 资源池管理、复杂对象构建 |
| 结构型(7种) | 适配器、装饰者、代理、外观、桥接、组合、享元 | 组合类与对象形成更大结构 | 接口适配、动态功能增强 |
| 行为型(11种) | 策略、模板方法、观察者、迭代器、责任链、命令、中介者、备忘录、解释器、状态、访问者 | 对象间职责分配与通信 | 算法封装、事件处理、状态机 |
特别提示:本教程按学习优先级而非GOF顺序组织内容。例如,将单例、工厂、策略、观察者等高频模式前置,而将访问者、解释器等低频模式后置,确保学习效率最大化。
设计模式学习的三大黄金法则
- 先场景后模式:遇到问题时,先分析业务本质,再思考“哪种模式能优雅解耦”——而非“我学过哪个模式,能否套用”
- 组合优于继承:优先使用
组合(如装饰者、策略)而非继承,避免继承层次过深导致的脆弱基类问题 - 高内聚低耦合:每个类职责单一,依赖抽象(接口/抽象类)而非具体实现——这是所有模式的共同思想
下面通过单例模式的深度剖析,演示如何将理论转化为工程实践。
核心设计模式详解与代码实现
单例模式:确保唯一实例的线程安全实现
单例模式(Singleton)确保一个类只有一个实例,并提供全局访问点。看似简单,实则暗藏玄机——尤其在多线程环境下,如何兼顾懒加载、性能与安全性是关键挑战。
常见错误实现:基础懒汉式(非线程安全)与同步方法(性能差)均不可取。推荐以下三种工业级方案:
枚举式单例(Java 1.5+)
利用enum天然的单例特性与反序列化保护机制,是最简洁安全的实现:
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("枚举单例执行逻辑");
}
}
优势:线程安全、防反射攻击、防序列化破坏、代码极简;劣势:无法延迟加载(但多数场景无需延迟加载)。
静态内部类方式
利用ClassLoader的类加载机制保证线程安全,同时实现延迟加载:
public class Singleton {
private Singleton() {}
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return Holder.INSTANCE;
}
}
原理:外部类加载时内部类不加载;首次调用getInstance()时才触发Holder加载,JVM保证类加载的线程安全。
登记式单例(Spring风格)
适用于需要管理多个单例对象的场景(如Spring的SingletonObjects缓存):
public class SingletonRegistry {
private static final Map registry = new ConcurrentHashMap<>();
public static <T> T register(String key, T instance) {
return (T) registry.computeIfAbsent(key, k -> instance);
}
public static Object get(String key) {
return registry.get(key);
}
}
扩展:Spring的DefaultSingletonBeanRegistry基于此模式,结合singletonObjects缓存、singletonFactories三级缓存解决循环依赖。
⚠️ 单例常见陷阱
- 反射攻击:通过
Constructor.setAccessible(true)可破解私有构造器——枚举式可防御 - 序列化破坏:需实现
readResolve()方法返回单例实例 - 分布式场景:JVM单例失效——需结合Redis等分布式缓存实现全局唯一
工厂模式:解耦对象创建的核心机制
工厂模式(Factory)将对象创建与使用分离,使系统不依赖具体实现类,符合依赖倒置原则。常见误区是混淆简单工厂(非GOF模式)、工厂方法与抽象工厂的边界。
简单工厂(Static Factory)
通过静态方法根据参数返回不同子类实例,适用于创建逻辑简单、产品族稳定的场景:
public class ShapeFactory {
public static Shape getShape(String type) {
switch (type) {
case "CIRCLE": return new Circle();
case "RECTANGLE": return new Rectangle();
default: throw new IllegalArgumentException("Invalid type");
}
}
}
缺点:违反开闭原则——新增产品需修改工厂类;无法形成继承树。实际开发中,常被Spring的BeanFactory替代。
工厂方法(Factory Method)
定义创建对象的接口,让子类决定实例化哪个类——将工厂也变成抽象,实现可扩展性:
public interface ShapeFactory {
Shape createShape();
}
public class CircleFactory implements ShapeFactory {
public Shape createShape() { return new Circle(); }
}
public class RectangleFactory implements ShapeFactory {
public Shape createShape() { return new Rectangle(); }
}
优势:新增产品只需新增工厂子类;缺点:类数量倍增。Spring的FactoryBean接口即基于此模式。
抽象工厂(Abstract Factory)
提供创建一系列相关或相互依赖对象的接口,无需指定具体类——适用于产品族(Product Family)场景:
public interface GUIFactory {
Button createButton();
Checkbox createCheckbox();
}
public class WindowsFactory implements GUIFactory {
public Button createButton() { return new WindowsButton(); }
public Checkbox createCheckbox() { return new WindowsCheckbox(); }
}
经典案例:Java Swing的javax.swing.plaf.basic.BasicLookAndFeel体系;MyBatis的DataSourceFactory接口。
💡 工厂选择指南:产品单一 → 简单工厂;产品多变 → 工厂方法;产品族稳定 → 抽象工厂;框架级扩展 → 结合IoC容器(如Spring)
观察者模式:事件驱动架构的基石
观察者模式(Observer)定义对象间的一对多依赖关系,当一个对象状态改变时,所有依赖者自动通知更新。是实现事件驱动、发布订阅架构的核心模式。
JDK 1.0 的 java.util.Observable(已过时)
// 注意:Observable是类而非接口,限制继承灵活性
public class WeatherData extends Observable {
private float temperature;
public void setTemperature(float temp) {
this.temperature = temp;
setChanged(); // 标记状态已变
notifyObservers(temp); // 通知所有观察者
}
}
// 观察者需实现 Observer 接口
public class CurrentConditionsDisplay implements Observer {
public void update(Observable o, Object arg) {
if (arg instanceof Float) {
System.out.println("温度更新:" + arg);
}
}
}
缺陷:Observable为类导致单继承限制;notifyObservers()非原子操作;同步阻塞通知易引发死锁。
Spring 的 ApplicationEvent 体系
// 定义事件(继承 ApplicationEvent)
public class UserRegisteredEvent extends ApplicationEvent {
public UserRegisteredEvent(Object source, String username) {
super(source);
this.username = username;
}
private final String username;
// getter...
}
// 定义监听器(@EventListener)
@Component
public class UserEventListener {
@EventListener
public void handleUserRegister(UserRegisteredEvent event) {
System.out.println("用户" + event.getUsername() + "已注册");
}
}
// 发布事件(ApplicationEventPublisher)
@Component
public class UserService {
@Autowired
private ApplicationEventPublisher publisher;
public void registerUser(String username) {
// ... 业务逻辑
publisher.publishEvent(new UserRegisteredEvent(this, username));
}
}
优势:异步支持(@Async)、条件过滤(@Conditional)、事务绑定(@TransactionalEventListener)。
Reactive Streams(Java 9+ java.util.concurrent.Flow)
// 创建发布者(Publisher)
Publisher<String> publisher = Flow.subscribers -> {
subscribers.forEach(subscriber -> {
subscriber.onSubscribe(new Subscription() {
public void request(long n) {
for (int i = 0; i < n; i++) {
subscriber.onNext("msg-" + i);
}
subscriber.onComplete();
}
public void cancel() {}
});
};
};
// 创建订阅者(Subscriber)
Subscriber<String> subscriber = new Subscriber<>() {
private Subscription subscription;
public void onSubscribe(Subscription s) {
this.subscription = s;
s.request(Long.MAX_VALUE); // 请求无限数据
}
public void onNext(String item) {
System.out.println("收到:" + item);
}
// ... onComplete, onError
};
// 订阅
publisher.subscribe(subscriber);
适用场景:高并发流处理(如Netty事件流、Kafka消费);背压(Backpressure)机制避免生产过快导致OOM。
实战演练:从单例到策略模式的综合应用
电商订单系统的状态机设计(状态模式)
订单状态(待支付、已支付、已发货、已完成)的流转是典型的状态模式应用场景。传统if-else实现难以维护,而状态模式将每个状态封装为类,通过上下文对象触发状态转换:
// 上下文:订单状态机
public class OrderContext {
private OrderState currentState;
public OrderContext() {
currentState = new PendingPaymentState(this);
}
public void setCurrentState(OrderState state) {
this.currentState = state;
}
public void pay() { currentState.pay(); }
public void confirmDelivery() { currentState.confirmDelivery(); }
public void complete() { currentState.complete(); }
}
// 抽象状态接口
public interface OrderState {
void pay();
void confirmDelivery();
void complete();
}
// 具体状态实现
public class PendingPaymentState implements OrderState {
private final OrderContext context;
public PendingPaymentState(OrderContext context) { this.context = context; }
public void pay() {
System.out.println("支付成功,订单进入已支付状态");
context.setCurrentState(new PaidState(context));
}
// 其他方法抛出异常
}
public class PaidState implements OrderState {
private final OrderContext context;
public PaidState(OrderContext context) { this.context = context; }
public void confirmDelivery() {
System.out.println("确认收货,订单完成");
context.setCurrentState(new CompletedState(context));
}
}
优势:新增状态(如“已取消”)只需新增类;避免庞大的条件分支;状态转移逻辑清晰可测。
支付系统中的策略模式(多支付方式切换)
支付方式(微信、支付宝、银联)的动态切换是策略模式(Strategy)的经典案例。核心思想:将算法族(支付逻辑)封装为独立策略类,通过组合而非继承实现运行时切换:
// 策略接口
public interface PaymentStrategy {
void pay(double amount);
}
// 具体策略
public class WechatPayStrategy implements PaymentStrategy {
public void pay(double amount) {
System.out.println("微信支付:" + amount + "元");
}
}
public class AlipayStrategy implements PaymentStrategy {
public void pay(double amount) {
System.out.println("支付宝支付:" + amount + "元");
}
}
// 上下文(支付服务)
public class PaymentService {
private PaymentStrategy strategy;
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void checkout(double amount) {
if (strategy == null) throw new IllegalStateException("未设置支付策略");
strategy.pay(amount);
}
}
// 客户端调用
PaymentService service = new PaymentService();
service.setStrategy(new WechatPayStrategy());
service.checkout(199.0);
实际应用:Spring Security的AuthenticationProvider体系、Netty的ChannelHandler链式处理。
日志框架的装饰者模式(动态增强日志功能)
SLF4J + Logback中,ConsoleAppender、FileAppender等通过装饰者模式叠加功能(如格式化、异步、滚动):
// 核心组件:AppenderBase(抽象装饰者)
public abstract class AppenderBase<E> extends AppenderBaseBase<E> {
protected Layout<E> layout;
public void doAppend(E eventObject) {
if (this.started && this.layout != null) {
writeOut(eventObject); // 子类实现具体输出
}
}
}
// 具体装饰者:ConsoleAppender
public class ConsoleAppender<E> extends AppenderBase<E> {
protected void writeOut(E event) {
OutputStream os = this.target.getOutputStream();
os.write(layout.doLayout(event).getBytes(UTF_8));
}
}
// 装饰链构建(Logback配置)
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
优势:运行时动态添加功能(如异步包装AsyncAppender);避免继承爆炸;符合开闭原则。
高频问题与避坑指南
网友最常搜索的5个设计模式问题
Q1:单例模式和静态类(Utility Class)有何区别?
A:静态类仅封装方法,无法继承/实现接口;单例是对象,可多态、可序列化、可懒加载。例如java.lang.Runtime是单例而非静态类。
Q2:代理模式和装饰者模式很像,如何区分?
A:代理模式(Proxy)侧重控制访问(如远程代理、保护代理);装饰者模式(Decorator)侧重增强功能。代理通常不改变被代理对象行为,而装饰者会叠加新行为。
Q3:工厂模式会增加类数量,何时该用?
A:当对象创建逻辑复杂(如涉及配置、依赖注入、条件分支)时使用。若创建逻辑简单(如仅new一个对象),直接new更高效。
Q4:观察者模式会导致内存泄漏吗?
A:会!若观察者未及时注销(removeObserver),会被Subject持有强引用。解决方案:使用弱引用(WeakReference)或框架级自动管理(如Spring的@EventListener自动注销)。
Q5:策略模式如何避免策略类爆炸?
A:可结合模板方法(Template Method)提取共性逻辑;或使用组合模式将策略参数化(如策略枚举+Lambda表达式)。
设计模式使用中的三大红线
- 不滥用:仅在真正需要解耦/扩展时使用,避免为模式而模式
- 不僵化:允许混合使用(如工厂+策略),不拘泥于教科书结构
- 不孤立:需结合设计原则(SOLID)、架构风格(MVC、微服务)综合考量
进阶:设计模式与现代技术栈融合
Spring框架中的设计模式全景
工厂模式(BeanFactory)、单例模式(singleton scope)、代理模式(AOP)
装饰者模式(Advisor链)、观察者模式(ApplicationEvent)
策略模式(HandlerMapping)、模板方法(JdbcTemplate)
观察者模式(Flux/Mono)、适配器模式(Reactor适配器)
设计模式与性能优化的权衡
| 模式 | 性能优势 | 性能风险 | 优化建议 |
|---|---|---|---|
| 单例模式 | 避免重复创建对象 | 锁竞争(非枚举实现) | 优先用枚举;同步块缩小范围 |
| 工厂模式 | 延迟创建(工厂方法) | 反射开销(如Spring) | 结合缓存;非必要不用反射 |
| 代理模式 | 按需增强(如懒加载) | 额外方法调用开销 | 使用CGLIB替代JDK动态代理(JDK 8+) |
| 装饰者模式 | 动态组合功能 | 对象包装层数增加 | 限制装饰层数;用组合替代嵌套 |
工具与资源推荐
UML建模工具对比
| 工具 | 特点 | 适用场景 | 学习成本 |
|---|---|---|---|
| PlantUML | 文本驱动,版本友好 | 开发者文档自动化 | 低(Markdown风格) |
| Visual Paradigm | 功能全面,支持协作 | 团队级建模 | 中 |
| StarUML | 轻量快速,插件丰富 | 个人快速建模 | 低 |
必读经典书籍
- • 《设计模式:可复用面向对象软件的基础》(GOF)——设计模式圣经
- • 《Head First设计模式》——初学者友好,图文并茂
- • 《Spring源码深度解析》(郝佳)——理解模式在框架中的应用
- • 《Effective Java》(Joshua Bloch)——Java开发黄金准则
设计模式常见问题快速解答
网友最关心的10个问题
Q1:设计模式需要背吗?
不需要死记硬背!重点理解:
① 每种模式解决什么问题;
② 结构图中各角色职责;
③ 适用场景与反例。通过写代码实践1-2次即可掌握核心思想。
Q2:面试常考哪些模式?
高频考点:
单例(线程安全)、工厂(简单vs抽象)、代理(JDK vs CGLIB)、观察者(Spring事件)、策略(支付/优惠券)
建议:准备1个实际项目中使用过的模式案例,强调问题背景→模式选择→实现效果三段式。
Q3:如何快速理解抽象概念?
三步法:
① 找生活类比(如单例→总统、工厂→汽车生产线);
② 画UML结构图;
③ 改写JDK源码(如java.util.Collections中的工厂方法)。
Q4:设计模式能提升代码性能吗?
通常不直接提升性能,但:
• 单例→减少对象创建开销
• 装饰者→按需增强(避免无用计算)
• 策略→避免冗长if-else
注意:过度设计(如每处都用代理)反而增加开销。
Q5:微服务架构下设计模式还适用吗?
更适用!微服务强调高内聚低耦合,与设计模式思想一致:
• 单例→服务内资源管理
• 适配器→服务间协议转换
• 策略→灰度发布策略
关键:将模式应用到服务设计层面(而非仅代码层)。
学习资源与练习项目
推荐练习项目(从易到难)
- ① 单例日志管理器:支持文件/控制台双输出,线程安全
- ② 支付策略选择器:支持微信/支付宝/余额,动态切换
- ③ 订单状态机:实现待支付→已支付→已发货→已完成流转
- ④ 日志装饰器链:支持异步、滚动、格式化组合
- ⑤ Spring事件驱动系统:用户注册后触发积分、邮件、日志事件
在线资源推荐
- • Refactoring.Guru 设计模式专题——图解清晰,代码示例丰富
- • iluwatar/java-design-patterns——GitHub高星开源项目
- • Spring Framework API——观察设计模式在框架中的应用
- • source-code-hunter——Spring/MyBatis源码解析
设计模式学习路线图
完成单例日志管理器+简单工厂支付接口
实现日志装饰器链+适配器转换旧API
开发订单状态机+事件驱动通知系统
重构小项目:用设计模式替代if-else,提升可维护性