8.1 设计模式 (Design Patterns)

文档摘要

深入解析Java设计模式：核心分类、代码实战与架构优化核心摘要：本文全面解析 Java 设计模式（Design Patterns）的核心概念与实战应用。通过深入探讨创建型模式、结构型模式与行为型模式的经典实现（如单例模式、工厂模式、适配器模式、观察者模式等），结合详实的 Java 代码示例与架构流程图，帮助开发者掌握高内聚、低耦合的软件架构设计精髓，有效提升代码的可维护性、可扩展性与系统稳定性。 8.1 设计模式 (Design Patterns) 概述设计模式是软件开发人员在长期实践中总结出来的、用于解决特定场景下常见问题的标准解决方案。它们不仅提供了经过验证的代码结构，还建立了一套通用的技术词汇，极大地提升了团队协作效率。

深入解析Java设计模式：核心分类、代码实战与架构优化

核心摘要：本文全面解析 Java 设计模式（Design Patterns）的核心概念与实战应用。通过深入探讨创建型模式、结构型模式与行为型模式的经典实现（如单例模式、工厂模式、适配器模式、观察者模式等），结合详实的 Java 代码示例与架构流程图，帮助开发者掌握高内聚、低耦合的软件架构设计精髓，有效提升代码的可维护性、可扩展性与系统稳定性。

8.1 设计模式 (Design Patterns) 概述

设计模式是软件开发人员在长期实践中总结出来的、用于解决特定场景下常见问题的标准解决方案。它们不仅提供了经过验证的代码结构，还建立了一套通用的技术词汇，极大地提升了团队协作效率。在 Java 企业级开发中，熟练运用设计模式是构建高可用、易扩展系统的基础。

8.1.1 设计模式的分类

根据《设计模式：可复用面向对象软件的基础》（GoF）的经典定义，设计模式通常分为三大类：

创建型模式 (Creational Patterns)：关注对象的创建过程。将对象的实例化逻辑抽象化并隐藏起来，使得系统在创建、组合和表示对象时更加灵活，降低系统耦合度。
结构型模式 (Structural Patterns)：关注类和对象的组合。通过继承或组合的方式，将类或对象拼装成更大的结构，同时保证结构的灵活性与高复用性。
行为型模式 (Behavioral Patterns)：关注对象之间的交互与责任分配。定义对象之间清晰的通信方式与职责边界，使得系统中的对象可以更好地协作，避免复杂的硬编码依赖。

8.1.2 创建型模式

8.1.2.1 单例模式 (Singleton Pattern)

核心定义：确保一个类在整个应用程序生命周期中只有一个实例，并提供一个全局访问点。

应用场景：数据库连接池、配置管理器、线程池、缓存管理等需要严格控制实例数量的场景。

代码示例（双重检查锁实现）：


public class Singleton {
    // 必须使用 volatile 关键字，防止指令重排序导致获取到未完全初始化的对象
    private static volatile Singleton instance;
    
    // 私有化构造函数，防止外部通过 new 关键字实例化
    private Singleton() {
    }
    
    // 提供全局访问点，使用双重检查锁保证线程安全与高性能
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    public void doSomething() {
        System.out.println("Singleton instance is doing something.");
    }
}

技术解析：

volatile 修饰符：禁止 JVM 指令重排，确保在多线程环境下实例化过程的原子性与可见性。
双重检查锁（Double-Checked Locking）：第一次检查避免不必要的同步开销，第二次检查确保只创建一个实例。

架构流程图：

8.1.2.2 工厂方法模式 (Factory Method Pattern)

核心定义：定义一个用于创建对象的接口，让子类决定实例化哪一个具体类。工厂模式将对象的创建延迟到子类，实现创建逻辑与使用逻辑的解耦。

应用场景：日志记录器（根据环境输出到文件或数据库）、支付网关（根据支付方式创建不同的支付处理类）。

代码示例：


// 产品接口
interface Product {
    void use();
}

// 具体产品 A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品 B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂 A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂 B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

架构流程图：

8.1.2.3 抽象工厂模式 (Abstract Factory Pattern)

核心定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它是工厂方法模式的升级版，用于处理“产品族”的创建。

应用场景：跨平台 UI 组件库（如 Windows 和 Mac 风格下的 Button 和 Checkbox）、多数据库访问层切换。

代码示例：


// 抽象产品 A
interface AbstractProductA { void operationA(); }
// 抽象产品 B
interface AbstractProductB { void operationB(); }

// 具体产品族 1
class ConcreteProductA1 implements AbstractProductA {
    @Override public void operationA() { System.out.println("ConcreteProductA1.operationA()"); }
}
class ConcreteProductB1 implements AbstractProductB {
    @Override public void operationB() { System.out.println("ConcreteProductB1.operationB()"); }
}

// 具体产品族 2
class ConcreteProductA2 implements AbstractProductA {
    @Override public void operationA() { System.out.println("ConcreteProductA2.operationA()"); }
}
class ConcreteProductB2 implements AbstractProductB {
    @Override public void operationB() { System.out.println("ConcreteProductB2.operationB()"); }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂 1（生产产品族 1）
class ConcreteFactory1 implements AbstractFactory {
    @Override public AbstractProductA createProductA() { return new ConcreteProductA1(); }
    @Override public AbstractProductB createProductB() { return new ConcreteProductB1(); }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.operationA();
        productB1.operationB();
    }
}

架构流程图：

8.1.2.4 建造者模式 (Builder Pattern) - 补充

核心定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

应用场景：包含大量可选参数的复杂对象初始化（如 HTTP 请求配置、数据库连接配置），避免“重叠构造函数”带来的代码臃肿。

代码示例：


public class HttpRequest {
    private final String url;
    private final String method;
    private final Map<String, String> headers;
    private final String body;

    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.headers = builder.headers;
        this.body = builder.body;
    }

    public static class Builder {
        private final String url; // 必填参数
        private String method = "GET"; // 默认值
        private Map<String, String> headers = new HashMap<>();
        private String body;

        public Builder(String url) { this.url = url; }
        public Builder method(String method) { this.method = method; return this; }
        public Builder addHeader(String key, String value) { this.headers.put(key, value); return this; }
        public Builder body(String body) { this.body = body; return this; }
        
        public HttpRequest build() { return new HttpRequest(this); }
    }
}

// 客户端链式调用
// HttpRequest request = new HttpRequest.Builder("https://api.example.com")
//     .method("POST")
//     .addHeader("Content-Type", "application/json")
//     .body("{\"key\":\"value\"}")
//     .build();

8.1.3 结构型模式

8.1.3.1 适配器模式 (Adapter Pattern)

核心定义：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以协同工作。

应用场景：集成第三方遗留系统、统一不同数据源的接口、旧系统重构时的接口兼容。

代码示例（对象适配器）：


// 现有不兼容的接口与实现
interface Adaptee { void specificRequest(); }
class ConcreteAdaptee implements Adaptee {
    @Override public void specificRequest() { System.out.println("ConcreteAdaptee.specificRequest()"); }
}

// 客户端期望的目标接口
interface Target { void request(); }

// 适配器：通过组合持有 Adaptee 的引用
class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }
    
    @Override
    public void request() {
        // 转换逻辑
        adaptee.specificRequest();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new ConcreteAdaptee();
        Target target = new Adapter(adaptee);
        target.request(); // 客户端无需关心底层调用的是 specificRequest
    }
}

架构流程图：

8.1.3.2 装饰器模式 (Decorator Pattern)

核心定义：动态地给一个对象添加一些额外的职责。就增加功能而言，装饰器模式比生成子类（继承）更为灵活，符合开闭原则。

应用场景：Java I/O 流的设计（如 BufferedInputStream 装饰 FileInputStream）、动态添加日志、权限校验、事务管理。

代码示例：


// 抽象组件
interface Component { void operation(); }

// 具体组件
class ConcreteComponent implements Component {
    @Override public void operation() { System.out.println("ConcreteComponent.operation()"); }
}

// 抽象装饰器
abstract class Decorator implements Component {
    protected Component component;
    public Decorator(Component component) { this.component = component; }
    @Override public void operation() { component.operation(); }
}

// 具体装饰器 A
class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) { super(component); }
    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorA added behavior.");
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        Component decoratorA = new ConcreteDecoratorA(component);
        decoratorA.operation();
    }
}

架构流程图：

8.1.3.3 代理模式 (Proxy Pattern) - 补充

核心定义：为其他对象提供一种代理以控制对这个对象的访问。

应用场景：Spring AOP 底层实现、RPC 远程调用、延迟加载（虚拟代理）、权限控制（保护代理）。

核心区别：装饰器模式侧重于增强功能，而代理模式侧重于控制访问。

8.1.4 行为型模式

8.1.4.1 观察者模式 (Observer Pattern)

核心定义：定义对象之间的一种一对多的依赖关系。每当一个对象（主题）改变状态时，所有依赖于它的对象（观察者）都会得到通知并自动更新。

应用场景：事件驱动系统、消息队列、GUI 事件监听、Spring 的 ApplicationEvent 机制。

代码示例：


import java.util.ArrayList;
import java.util.List;

// 抽象观察者
interface Observer { void update(String state); }

// 抽象主题
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers(); // 状态改变，触发通知
    }

    @Override public void attach(Observer observer) { observers.add(observer); }
    @Override public void detach(Observer observer) { observers.remove(observer); }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    private String name;
    public ConcreteObserver(String name) { this.name = name; }
    
    @Override
    public void update(String state) {
        System.out.println("Observer " + name + " received state: " + state);
    }
}

架构流程图：

8.1.4.2 策略模式 (Strategy Pattern)

核心定义：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。策略模式使得算法可独立于使用它的客户而变化。

应用场景：多种支付方式选择、不同的促销折扣计算、多种排序算法的动态切换。结合 Java 8+ 的 Lambda 表达式，可以极大简化策略模式的代码量。

代码示例：


import java.util.function.BiFunction;

// 环境类（结合函数式接口简化传统策略接口）
class Context {
    private BiFunction<Integer, Integer, Integer> strategy;

    public Context(BiFunction<Integer, Integer, Integer> strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int a, int b) {
        return strategy.apply(a, b);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 使用加法策略 (Lambda 表达式)
        Context addContext = new Context((a, b) -> a + b);
        System.out.println("10 + 5 = " + addContext.executeStrategy(10, 5));

        // 动态切换为减法策略
        Context subtractContext = new Context((a, b) -> a - b);
        System.out.println("10 - 5 = " + subtractContext.executeStrategy(10, 5));
    }
}

架构流程图：

8.1.4.3 模板方法模式 (Template Method Pattern) - 补充

核心定义：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

应用场景：Spring 中的 JdbcTemplate、RestTemplate，以及各类框架的启动生命周期钩子（Hook）。

8.1.5 设计模式的优势与避坑指南

核心优势

提升代码可重用性：设计模式是业界验证的最佳实践，能够避免“重复造轮子”，提供标准化的解决方案。
增强系统可维护性：通过解耦和模块化设计，使得代码逻辑清晰，局部修改不会引发全局雪崩。
优化架构可扩展性：完美契合“开闭原则（OCP）”，新增业务需求时只需扩展新类，无需修改原有核心代码。
统一团队技术语境：为开发团队提供了一套通用的“设计词汇”，大幅降低沟通成本。

避坑指南（防止过度设计）

拒绝生搬硬套：不要为了使用设计模式而使用。如果简单的 if-else 或基础面向对象设计就能清晰解决问题，强行引入复杂模式会导致代码晦涩难懂。
遵循 YAGNI 原则：(You Aren't Gonna Need It) 只有在明确预见未来会有扩展需求时，才提前引入相应的设计模式。
结合 SOLID 原则：设计模式是手段，SOLID（单一职责、开闭原则、里氏替换、接口隔离、依赖倒置）才是内功。脱离原则谈模式是本末倒置。

8.1.6 总结

设计模式是软件工程领域沉淀的智慧结晶，是构建高质量、企业级 Java 应用不可或缺的工具。掌握创建型、结构型和行为型模式的核心思想，并能够根据实际业务场景灵活变通，是开发者从“代码编写者”向“架构设计师”进阶的关键一步。

在实际开发中，优秀的设计往往不是单一模式的孤立使用，而是多种模式的有机结合（如 Spring 框架中大量融合了工厂、代理、观察者与模板方法模式）。开发者应保持对业务的深刻理解，在实践中不断反思与重构，方能真正领悟设计模式的精髓，打造出优雅、健壮且极具生命力的软件系统。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/133-java%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF%E4%B8%8E%E5%BC%80%E5%8F%91%E5%AE%9E%E6%88%98

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流