〈设计模式Java手册〉 ● www.xservx.com

设计模式java手册|Java开发者的系统化设计模式指南

在现代软件工程实践中,设计模式早已超越了理论范畴,成为企业级应用开发的基石。对于Java开发者而言,掌握从Singleton到Command、从Observer到Strategy的23种经典模式,是构建可维护、可扩展、高内聚系统的关键能力。

本手册以Java 17+为技术基线,结合Spring Framework、MyBatis、Netty等主流框架源码中的模式应用,系统梳理设计模式的核心思想、实现细节、适用边界与反模式警示,帮助开发者在真实项目中做到“知其然更知其所以然”。

为何需要系统学习设计模式?

  • 面对复杂业务逻辑时,避免“上帝类”与“面条式代码”蔓延,提升代码可读性
  • 在多人协作开发中,统一模式语言,降低沟通成本与集成风险
  • 应对高并发、高可用系统时,为架构决策提供模式级支撑(如ThreadLocal实现单例安全)
  • 通过模式组合(如Strategy + Factory)构建弹性架构,快速响应需求变更

尤其在微服务架构盛行的今天,设计模式成为解耦服务间依赖、设计领域模型、实现领域驱动设计(DDD)的重要方法论。例如:Spring中@Transactional背后是Template Method与Proxy模式的协同;Netty的事件驱动模型大量使用Observer与Chain of Responsibility模式。

本手册不仅覆盖《设计模式:可复用面向对象软件的基础》(GoF)中的全部23种模式,更结合Java生态特性,深入解析:

我们坚持“原理→实现→反例→扩展”四步教学法,每个模式均配有完整可运行的JUnit测试用例与UML类图解析,确保开发者学完即用。

基础篇|理解设计模式的底层逻辑

设计模式的本质:面向对象设计的“语法糖”

设计模式并非独立于语言的抽象概念,而是对OOP三大特性(封装、继承、多态)与五大原则(SOLID)的实践提炼。Java作为强类型静态语言,其编译期类型检查与运行时多态特性,为模式的稳定实现提供了天然优势。

六大核心设计原则

  1. 单一职责原则(SRP):一个类只负责一个职责。违反此原则易导致“大杂烩类”,如UserManager既处理数据库操作又负责邮件通知,应拆分为UserRepository与EmailService。
  2. 开闭原则(OCP):对扩展开放,对修改关闭。通过接口隔离与策略模式实现,如Comparator接口允许新增排序策略而不修改原有集合类。
  3. 里氏替换原则(LSP):子类对象可替换父类对象。违反示例:正方形继承矩形时,修改宽高导致行为不一致。
  4. 接口隔离原则(ISP):客户端不应依赖其不需要的接口。如Animal接口拆分为Runnable、Flyable,避免“胖接口”。
  5. 依赖倒置原则(DIP):高层模块不依赖低层模块,二者都依赖抽象。Spring的@Autowired本质是DIP的实现。
  6. 迪米特法则(LoD):只与直接朋友通信。避免在Service中直接调用DAO内部细节,应通过封装方法暴露。

设计模式的分类与演进脉络

GoF将23种模式分为三类,每类对应不同的设计关注点:

创建型模式(5种)|关注对象创建机制

  • Singleton:确保唯一实例(含懒汉/饿汉/静态内部类/枚举实现)
  • Factory Method:定义创建对象的接口,子类决定实例化类
  • Abstract Factory:提供创建一系列相关或依赖对象的接口
  • Builder:分离构建与表示,支持复杂对象的逐步构造
  • Prototype:通过复制原型创建新对象(Java中通过clone()实现)

结构型模式(7种)|关注类与对象的组合

  • Adapter:将一个类的接口转换成客户端期待的另一个接口
  • Decorator:动态地给对象添加额外职责(I/O流即典型应用)
  • Proxy:为其他对象提供代理以控制访问(远程代理、虚拟代理)
  • Facade:为子系统提供统一的高层接口(JDBC的DriverManager)
  • Bridge:将抽象与实现解耦,使二者可独立变化
  • Composite:组合对象树形结构以表示“部分-整体”层次(AWT容器体系)
  • Flyweight:共享技术,减少创建大量细粒度对象的开销(String常量池)

行为型模式(11种)|关注对象间的职责分配

  • Observer:定义对象间一对多依赖(java.beans.PropertyChangeListener)
  • Strategy:定义一系列算法并使其可互换(Comparator、Collectors)
  • Command:将请求封装为对象(Runnable、Callable)
  • Template Method:定义算法骨架,子类实现具体步骤(AbstractList)
  • Iterator:提供遍历集合的统一接口(Iterator、Spliterator)
  • Chain of Responsibility:请求沿处理者链传递(FilterChain、Handler)
  • State:允许对象在内部状态改变时改变行为(State机)
  • Visitor:表示作用于某对象结构中的各元素的操作
  • Memento:在不破坏封装的前提下捕获并保存对象内部状态
  • Mediator:用中介者对象封装一系列对象间的交互(EventBus)
  • Interpreter:定义语言的文法表示,并定义解释器

Java生态中的模式“原生支持”

Java标准库与主流框架大量内置设计模式实现,开发者无需重复造轮子:

掌握这些原生模式,能显著提升代码理解力与调试效率。例如,调试Spring事务失效时,需理解@Transactional背后Proxy与Template Method的协作机制。

核心模式详解|Java实现与深度解析

单例模式(Singleton)|多线程安全的终极方案

单例模式看似简单,实则暗藏玄机。Java中常见的实现方式及其缺陷如下:

饿汉式
懒汉式
枚举式
静态内部类

饿汉式(类加载即实例化)

public enum Singleton {
    INSTANCE;
    public void doSomething() { System.out.println("饿汉式单例"); }
}
// 线程安全,类加载时创建,但可能提前占用资源

双重检查锁(DCL)懒汉式

public class Singleton {
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
// 必须用volatile防止指令重排,适用于复杂初始化

枚举式(推荐)

public enum Singleton {
    INSTANCE;
    private final String value = "枚举单例";
    public String getValue() { return value; }
}
// 天然防止反射与反序列化攻击,JVM级线程安全

静态内部类

public class Singleton {
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() { return Holder.INSTANCE; }
}
// 延迟加载,线程安全,推荐用于非序列化场景

反模式警示:在分布式系统中,单例仅对单个JVM有效。需结合ZooKeeper或Redis实现分布式单例,或改用Spring的@Singleton作用域。

工厂模式(Factory)|解耦对象创建的核心机制

工厂模式将“创建对象”与“使用对象”解耦,是Spring依赖注入的基石。

工厂方法 vs 抽象工厂

工厂方法(Factory Method)
适用于单一产品等级。如MessageProducer接口,实现类EmailProducer、SMSProducer,通过ProducerFactory选择具体实现。
抽象工厂(Abstract Factory)
适用于多产品族。如UIFactory生产Button与TextField,再细分为WindowsUIFactory与MacUIFactory。
// Spring中工厂模式的典型应用 public class UserServiceFactory { public static UserService createUserService(String type) { return switch (type) { case "database" -> new DatabaseUserService(); case "cache" -> new CacheUserService(); default -> throw new IllegalArgumentException("Unknown type: " + type); }; } }

在MyBatis中,SqlSessionFactory是抽象工厂的典型应用:通过Configuration对象创建SqlSession,而SqlSession又进一步创建Executor、StatementHandler等对象,形成多层工厂链。

观察者模式(Observer)|事件驱动架构的基石

Java 8+中,观察者模式已进化为更优雅的函数式风格:

Java标准库
Spring事件
Reactor响应式

Java标准实现(已废弃)

// java.util.Observable 已废弃,因线程安全差
public class WeatherData extends Observable {
    private float temperature;
    public void setMeasurements(float temp) {
        temperature = temp;
        setChanged(); // 标记状态已变更
        notifyObservers(temp); // 通知所有观察者
    }
}
// 推荐使用PropertyChangeSupport替代

Spring ApplicationEvent

@Component
public class OrderCreatedPublisher {
    @Autowired
    private ApplicationEventPublisher publisher;
    public void publish(Order order) {
        publisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}
@Component
public class OrderCreatedListener {
    @EventListener
    public void handle(OrderCreatedEvent event) {
        System.out.println("订单创建:" + event.getOrder().getId());
    }
}
// 异步处理需加@Async,支持事务回滚时用TransactionSynchronization

Project Reactor(Flux/mono)

Flux.fromIterable(orders)
    .map(Order::getId)
    .filter(id -> id > 100)
    .doOnNext(id -> log.info("处理订单ID: {}", id))
    .subscribe(id -> System.out.println("订阅成功: " + id));
// 响应式流天然支持背压,适用于高并发事件流

典型应用:电商系统中,订单创建后触发库存扣减、积分发放、消息推送等异步操作,使用观察者模式可避免主流程阻塞,提升用户体验。

策略模式(Strategy)|消除if-else的利器

策略模式将算法封装为独立类,通过组合替代继承,使系统更灵活。以下对比if-else与策略模式的差异:

反模式:冗长的if-else

public double calculateShipping(String type, double weight) {
    if ("standard".equals(type)) return weight * 5;
    else if ("express".equals(type)) return weight * 10;
    else if ("overnight".equals(type)) return weight * 20;
    else throw new IllegalArgumentException("Unknown type");
}
// 难以扩展,违反开闭原则

策略模式实现

public interface ShippingStrategy {
    double calculate(double weight);
}
public class StandardStrategy implements ShippingStrategy {
    public double calculate(double weight) { return weight * 5; }
}
public class ExpressStrategy implements ShippingStrategy {
    public double calculate(double weight) { return weight * 10; }
}
public class ShippingContext {
    private ShippingStrategy strategy;
    public void setStrategy(ShippingStrategy strategy) { this.strategy = strategy; }
    public double calculate(double weight) { return strategy.calculate(weight); }
}
// 通过Context动态切换策略,支持组合策略(如折扣叠加)

Spring中HandlerMapping、ViewResolver等均采用策略模式,允许开发者自定义实现并注入Spring容器。

实战案例|企业级项目中的模式应用

案例1:电商订单状态机(State模式)

订单状态流转:待支付→已支付→已发货→已签收→已完成/取消

状态模式实现

public abstract class OrderState {
    protected OrderContext context;
    public OrderState(OrderContext context) { this.context = context; }
    public abstract void pay();
    public abstract void ship();
    public abstract void deliver();
    public void cancel() {
        throw new IllegalStateException("当前状态不允许取消");
    }
}
public class PaidState extends OrderState {
    public PaidState(OrderContext context) { super(context); }
    public void ship() {
        System.out.println("订单已发货");
        context.setState(new ShippedState(context));
    }
    public void cancel() {
        System.out.println("订单已取消");
        context.setState(new CancelledState(context));
    }
    // 其他方法保持默认异常
}
public class OrderContext {
    private OrderState state;
    public OrderContext() { state = new PendingState(this); }
    public void setState(OrderState state) { this.state = state; }
    public void pay() { state.pay(); }
    public void ship() { state.ship(); }
    public void deliver() { state.deliver(); }
    public void cancel() { state.cancel(); }
}

优势:新增状态(如“退款中”)只需新增类,无需修改原有逻辑;状态转换清晰可追溯;支持状态持久化与重放。

案例2:日志系统(Decorator + Strategy)

需求:支持多种日志输出目标(控制台、文件、数据库),且可组合功能(如加密+压缩+异步写入)。

组合Decorator实现

public interface LogAppender {
    void append(String message);
}
public class ConsoleAppender implements LogAppender {
    public void append(String msg) { System.out.println(msg); }
}
public abstract class LogDecorator implements LogAppender {
    protected LogAppender delegate;
    public LogDecorator(LogAppender delegate) { this.delegate = delegate; }
}
public class EncryptedAppender extends LogDecorator {
    public EncryptedAppender(LogAppender delegate) { super(delegate); }
    public void append(String msg) {
        delegate.append(encrypt(msg)); // 先加密再输出
    }
}
// 使用示例
LogAppender appender = new EncryptedAppender(
    new AsyncAppender(
        new FileAppender("app.log")
    )
);
appender.append("用户登录成功");

此设计遵循开闭原则:新增功能(如压缩)只需新增Decorator类,不修改原有逻辑。

案例3:Spring Boot自动配置(Template Method + Factory)

Spring Boot通过@EnableAutoConfiguration触发自动配置,其核心流程如下:

  1. AutoConfigurationImportSelector读取META-INF/spring.factories中的EnableAutoConfiguration列表
  2. 通过@Conditional注解(如@ConditionalOnClass)过滤不满足条件的配置类
  3. 使用BeanPostProcessor对配置类进行后处理(Template Method)
  4. 最终通过BeanFactory注册Bean(Factory Method)
// 示例:RedisAutoConfiguration的简化版 @Configuration(proxyBeanMethods = false) @ConditionalOnClass(RedisOperations.class) @EnableConfigurationProperties(RedisProperties.class) public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean(name = "redisTemplate") public RedisTemplate redisTemplate(RedisConnectionFactory factory) { RedisTemplate template = new RedisTemplate<>(); template.setConnectionFactory(factory); return template; } }

这体现了Template Method(定义配置骨架)与Factory(创建Bean)的协同应用。

工具与实践|提升模式应用效率

模式识别工具链

反模式警示(Anti-Patterns)

常见误用场景

  • 过度设计:在简单CRUD中强行使用Decorator或Visitor,增加维护成本
  • 模式误判:将Adapter与Decorator混淆(Adapter改变接口,Decorator增强功能)
  • 线程安全陷阱:单例模式未考虑多线程竞争,导致重复初始化
  • 状态管理失控:State模式中状态转换逻辑散落在各处,未统一管理

设计模式与微服务架构

在微服务场景下,设计模式的应用需结合分布式特性:

核心原则:本地单例 ≠ 分布式单例;本地策略 ≠ 分布式策略。需根据场景选择适配方案。

高频答疑|开发者最常问的10个问题

Q1:单例模式与静态类有什么区别?

A:静态类无法继承、无法实现接口、无法延迟加载,且线程安全需手动处理。单例可通过接口抽象、支持懒加载、兼容多线程(如枚举)。例如:Spring中ApplicationContext是单例,而非静态类。

Q2:工厂模式是否会导致类爆炸?

A:是的!当产品种类超过10种时,建议用注册表模式(Registry Pattern)结合Map存储工厂,或使用反射动态创建实例。Spring的FactoryBean即为此类场景的解决方案。

Q3:如何判断该用策略模式还是状态模式?

A:关键看状态是否依赖上下文。策略模式中策略独立于上下文;状态模式中行为依赖当前状态。例如:订单支付用策略(支付方式独立),订单状态流转用状态(行为随状态变化)。

Q4:观察者模式会导致内存泄漏吗?

A:会!若观察者未及时注销,会导致其无法被GC回收。解决方案:使用WeakReference包装观察者,或在onDestroy中主动移除监听。

Q5:装饰者模式与继承相比有哪些优势?

A:装饰者支持运行时动态扩展,避免继承导致的类爆炸(如BufferedInputStream可包装FileInputStream、ByteArrayInputStream等),且符合组合优于继承原则。

Q6:Spring中为什么推荐使用构造器注入而非set注入?

A:构造器注入确保依赖不可变(final)、避免循环依赖、便于单元测试。这本质上是Template Method模式的应用:父类定义构造器模板,子类填充具体依赖。

Q7:命令模式如何实现撤销操作?

A:为每个命令实现undo()方法,并维护命令历史栈。Spring中TransactionTemplate的回滚即基于此思想:将SQL操作封装为命令,失败时执行undo。

Q8:适配器模式与装饰者模式有何区别?

A:适配器改变接口,装饰者增强功能。例如:InputStreamReader是适配器(将字节流适配为字符流),BufferedInputStream是装饰者(增加缓冲功能)。

Q9:模板方法模式中如何避免“钩子方法”滥用?

A:钩子方法应仅用于可选步骤。若必须实现,应改用抽象方法;若完全可选,则提供空实现。例如:AbstractList中add(int index, E element)默认抛异常,子类可选择重写。

Q10:设计模式是否适用于所有项目?

A:否!小型项目或快速原型开发中,简单if-else可能更高效。设计模式的价值在于长期维护性与扩展性。建议:核心业务模块使用模式,辅助功能可简化。

网友还关心

以下内容与设计模式java手册强相关:

设计模式学习路线图

  1. 掌握SOLID原则与UML类图基础
  2. 精读GoF 23种模式,理解动机与适用场景
  3. 结合Java标准库源码验证模式实现
  4. 在项目中实践1-2种高频模式(如Strategy、Factory)
  5. 学习框架源码中的模式变体(如Spring、MyBatis)
  6. 研究模式组合与反模式规避

坚持以上步骤,您将从“模式使用者”进阶为“模式设计者”,在复杂系统中游刃有余。