设计模式：构建高效且可维护的软件系统的基石

文章目录

• 一、引言
• [二、创建型模式（Creational Patterns）](#二、创建型模式（Creational Patterns）)
• • [1. 单例模式 (Singleton Pattern)](#1. 单例模式 (Singleton Pattern))
  • [2. 工厂方法模式 (Factory Method Pattern)](#2. 工厂方法模式 (Factory Method Pattern))
  • [3. 抽象工厂模式 (Abstract Factory Pattern)](#3. 抽象工厂模式 (Abstract Factory Pattern))
  • [4. 建造者模式 (Builder Pattern)](#4. 建造者模式 (Builder Pattern))
  • [5. 原型模式 (Prototype Pattern)](#5. 原型模式 (Prototype Pattern))
• [三、结构型模式（Structural Patterns）](#三、结构型模式（Structural Patterns）)
• • [1. 适配器模式 (Adapter Pattern)](#1. 适配器模式 (Adapter Pattern))
  • [2. 装饰者模式 (Decorator Pattern)](#2. 装饰者模式 (Decorator Pattern))
  • [3. 代理模式 (Proxy Pattern)](#3. 代理模式 (Proxy Pattern))
  • [4. 桥接模式 (Bridge Pattern)](#4. 桥接模式 (Bridge Pattern))
  • [5. 组合模式 (Composite Pattern)](#5. 组合模式 (Composite Pattern))
  • [6. 外观模式 (Facade Pattern)](#6. 外观模式 (Facade Pattern))
• [四、行为型模式（Behavioral Patterns）](#四、行为型模式（Behavioral Patterns）)
• • [1. 策略模式 (Strategy Pattern)](#1. 策略模式 (Strategy Pattern))
  • [2. 观察者模式 (Observer Pattern)](#2. 观察者模式 (Observer Pattern))
  • [3. 命令模式 (Command Pattern)](#3. 命令模式 (Command Pattern))
  • [4. 责任链模式 (Chain of Responsibility Pattern)](#4. 责任链模式 (Chain of Responsibility Pattern))
  • [5. 状态模式 (State Pattern)](#5. 状态模式 (State Pattern))
  • [6. 迭代器模式 (Iterator Pattern)](#6. 迭代器模式 (Iterator Pattern))
  • [7. 模板方法模式 (Template Method Pattern)](#7. 模板方法模式 (Template Method Pattern))
  • [8. 中介者模式 (Mediator Pattern)](#8. 中介者模式 (Mediator Pattern))
  • [9. 解释器模式 (Interpreter Pattern)](#9. 解释器模式 (Interpreter Pattern))
• 五、结语

一、引言

在软件开发的世界里，设计模式是经过验证的最佳实践，它们为解决常见的软件设计问题提供了模板。通过应用这些模式，开发者不仅可以提高代码的质量和可读性，还能增强系统的灵活性和可扩展性。本文将深入探讨几种最为常用的设计模式，并结合实际应用场景，帮助读者理解如何恰当地运用它们来优化自己的项目。

二、创建型模式（Creational Patterns）

创建型模式关注于对象的创建机制，旨在提供一种灵活的方式来实例化类或组合对象。

1. 单例模式 (Singleton Pattern)

确保一个类只有一个实例，并提供一个全局访问点。它非常适合用于管理共享资源，如数据库连接池、日志记录器等。例如，在多线程环境中，使用单例模式可以保证每次调用都指向同一个对象实例，从而避免了重复创建带来的开销。

• 饿汉式

饿汉式是最简单的单例模式实现，它在类加载时就创建了单例对象。这种方式保证了线程安全，但缺点是无论是否需要，都会提前创建对象，浪费内存资源。

/**
 * @description: 饿汉式单例/Eager Initialization
 * @author: HaleyHu
 * @date: 2025/1/19 18:22
 */
public class Singleton {
    /** 类加载时创建实例 */
    private static final Singleton SINGLETON = new Singleton();
    /** 私有构造方法防止外部实例化 */
    private Singleton() {}

    /** 提供全局访问入口 */
    public static Singleton getInstance() {
        return SINGLETON;
    }
}

• 懒汉式（Lazy Initialization）

懒汉式是在第一次调用 getInstance() 方法时才创建单例对象，从而实现了延迟初始化。然而，简单的懒汉式不是线程安全的，在多线程环境下可能会导致多个实例被创建。

/**
 * @description: 懒汉式
 * @author: HaleyHu
 * @date: 2025/1/19 18:29
 */
public class Singleton {
    private static Singleton instance;
    private Singleton() { }

    public static Singleton getSINGLETON() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

为了确保线程安全，可以采用双重检查锁定机制（Double-Checked Locking）或者同步整个 getInstance() 方法。以下是使用双重检查锁定的例子：

/**
 * @description: 双重检查
 * @author: HaleyHu
 * @date: 2025/1/19 18:31
 */
public class Singleton {
    private static volatile Singleton instance;
    private Singleton() { }

    /**
     * 双重检查锁定机制
     * @return
     */
    public static Singleton getSINGLETON() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

同步方法如下：

/**
 * @description: 同步方法
 * @author: HaleyHu
 * @date: 2025/1/19 18:33
 */
public class Singleton {
    private static Singleton instance;
    private Singleton() { }

    public static synchronized Singleton getSINGLETON() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

• 静态内部类（Static Inner Class）
  静态内部类的方式结合了饿汉式和懒汉式的优点，既实现了延迟初始化，又保持了线程安全性。JVM会保证当且仅当首次访问内部类时才会加载并初始化其中的对象。

/**
 * @description:
 * @author: HaleyHu
 * @date: 2025/1/19 18:37
 */
public class Singleton {
    // 静态内部类，且在首次调用getInstance()时初始化
    private static class SingletonHolder {
        private static final Singleton SINGLETON = new Singleton();
    }
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.SINGLETON;
    }
}

• 枚举类型（Enum Singleton）

从Java 5开始，枚举类型也可以用来实现单例模式，这是最简洁且天然线程安全的方式。此外，枚举类型的单例还具有防止反序列化破坏单例性的特点。

/**
 * @description:
 * @author: HaleyHu
 * @date: 2025/1/19 19:14
 */
public enum Singleton {
    INSTANCE;
    public void doSomething() {

    }
}

2. 工厂方法模式 (Factory Method Pattern)

定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。此模式适用于需要根据条件动态创建不同类型的对象的情况。比如在一个图形编辑器中，用户可以选择不同的形状工具（矩形、圆形等），而具体的形状对象则由相应的工厂方法负责创建。

3. 抽象工厂模式 (Abstract Factory Pattern)

提供了一种创建一系列相关或相互依赖对象的接口，而不指定它们具体的类。这有助于保持代码的一致性和兼容性，特别是在跨平台的应用中。例如，在GUI库中，抽象工厂可以用来创建一组协调工作的控件集（按钮、文本框等），确保无论是在Windows还是macOS上都能获得一致的用户体验。

4. 建造者模式 (Builder Pattern)

允许分步骤构建复杂对象，使得同样的构造过程可以创建不同的表示。这对于具有许多可选属性的对象特别有用。以文档生成为例，建造者模式可以帮助我们逐步添加内容元素，最终生成一份完整的报告或合同。

StringBuilder 和 StringBuffer不是严格意义上的建造者模式实现，但这些类提供了一种逐步构建字符串的方式，允许通过连续调用来添加字符或子串，最终生成一个完整的字符串对象。

5. 原型模式 (Prototype Pattern)

通过复制现有对象来创建新对象，而不是从头开始构造。这种方法能显著减少初始化成本，尤其适合那些创建成本较高的对象。在游戏开发中，原型模式常被用来快速生成大量相似的敌人单位。

三、结构型模式（Structural Patterns）

结构型模式处理类或对象的组合方式，帮助简化结构并增强功能。

1. 适配器模式 (Adapter Pattern)

使原本由于接口不兼容而不能一起工作的类可以协同工作。当需要集成第三方库或遗留代码时，适配器模式能够充当桥梁，转换不同的接口标准。例如，为了使旧版API与新版系统兼容，我们可以编写适配器来调整数据格式。

2. 装饰者模式 (Decorator Pattern)

动态地给一个对象添加一些额外的职责，而不改变原有代码。它非常适合用于实现灵活的功能扩展，如权限控制、性能监控等。想象一下，你可以在不修改核心逻辑的前提下，轻松地为某个服务加上一层缓存层或安全检查。

3. 代理模式 (Proxy Pattern)

为其他对象提供一种代理以控制对这个对象的访问。它可以用于远程服务调用、延迟加载、权限验证等多种场景。例如，在网络请求中，代理可以拦截并处理错误响应，或者在加载大型图片之前先显示缩略图。

4. 桥接模式 (Bridge Pattern)

将抽象部分与实现部分分离，使它们都可以独立变化。这有助于降低模块间的耦合度，便于维护和升级。考虑一个图形渲染引擎，桥接模式可以让绘图算法与具体设备驱动程序解耦，方便针对不同硬件平台进行优化。

5. 组合模式 (Composite Pattern)

将对象组合成树形结构以表示"部分-整体"的层次结构。对于文件系统、菜单项等层级关系明确的数据结构来说，组合模式可以使操作更加直观易懂。例如，用户可以通过相同的接口遍历单个文件或整个目录树。

6. 外观模式 (Facade Pattern)

为子系统中的一组接口提供一个一致的界面，简化高层模块对子系统的调用。在复杂的系统中，外观模式能够隐藏内部细节，提供更简洁的API。JDBC API就是一个很好的例子，它封装了多种数据库操作，让用户无需关心底层协议。

四、行为型模式（Behavioral Patterns）

行为型模式专注于对象之间的责任分配以及通信协议，促进协作和交互。

1. 策略模式 (Strategy Pattern)

定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。策略模式非常适合用于实现可插拔的业务逻辑，如排序算法的选择。开发者可以根据需求随时切换不同的实现，而无需改动调用方的代码。

2. 观察者模式 (Observer Pattern)

定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式广泛应用于事件驱动系统、发布/订阅模型等领域。例如，在股票交易平台中，多个客户端可以订阅某只股票的价格变动，一旦价格更新，所有订阅者都会即时收到通知。

3. 命令模式 (Command Pattern)

将请求封装成对象，从而使你可以用不同的请求对客户进行参数化。命令模式有助于支持撤销、重做等功能，如文本编辑器中的操作历史记录。每个命令对象代表一个特定的动作，可以轻松地执行、撤销或排队等待执行。

4. 责任链模式 (Chain of Responsibility Pattern)

让多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。它适用于需要按顺序处理请求的工作流程，如审批流程。每个处理器负责一部分决策，如果无法处理当前请求，则将其传递给下一个处理器。

5. 状态模式 (State Pattern)

允许一个对象在其内部状态改变时改变它的行为。状态模式适用于对象的行为依赖于其状态并且在运行时可能发生变化的情景，如有限状态机。通过将每个状态定义为单独的类，我们可以清晰地表达出各种状态下允许的操作。

6. 迭代器模式 (Iterator Pattern)

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露其内部表示。迭代器模式简化了集合数据结构的遍历操作，如列表、数组等。它不仅提高了代码的通用性，还保护了数据结构的隐私。

7. 模板方法模式 (Template Method Pattern)

定义一个操作中的算法框架，而将一些步骤延迟到子类中实现。模板方法模式非常适合用于框架开发，其中某些步骤是固定的，而另一些则留给具体实现。例如，在Web应用中，模板方法可以定义页面加载的基本流程，但具体的渲染逻辑由各页面自行实现。

8. 中介者模式 (Mediator Pattern)

用一个中介对象来封装一系列对象的交互。它减少了对象之间的直接依赖，降低了系统的复杂度。聊天室应用是一个典型的例子，所有消息都通过中介者转发给适当的参与者，而不是让每个成员直接与其他成员通信。

9. 解释器模式 (Interpreter Pattern)

给定一个语言，定义它的文法表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。解释器模式适用于需要解析和执行简单表达式的场景，如查询语言。虽然它不是最高效的解决方案，但对于小型DSL（领域特定语言）来说已经足够。

五、结语

设计模式不仅是解决问题的工具，更是交流思想的语言。掌握这些经典模式，可以帮助我们在面对复杂问题时找到正确的方向，写出既优雅又实用的代码。当然，选择合适的设计模式应当基于项目的实际情况和技术背景。希望本文能为你理解和应用设计模式提供有价值的参考。