设计模式精讲 Day 14：命令模式（Command Pattern）

【设计模式精讲 Day 14】命令模式（Command Pattern）

文章内容

在“设计模式精讲”系列的第14天，我们来学习命令模式（Command Pattern）。命令模式是一种行为型设计模式，它将请求封装为对象，从而使你可以用不同的请求、队列或日志来参数化客户端。这种模式的核心思想是通过解耦请求的发起者和执行者，提升系统的灵活性与可扩展性。

命令模式在实际开发中广泛应用，例如在GUI事件处理、任务调度、事务管理等领域。它能够帮助开发者构建更清晰、更易于维护的系统架构。本篇文章将从理论到实践，深入讲解命令模式的定义、结构、实现方式以及实际应用案例，并结合Java代码展示其具体使用方式。

模式定义

命令模式（Command Pattern）是一种行为型设计模式，它将一个请求封装成一个对象，从而使你可以在不同的请求之间进行参数化传递，或者将请求排队、记录日志、撤销操作等。

核心思想：
将请求的发送者与接收者解耦，使得请求可以被参数化、记录、撤销或重放。

模式结构

命令模式的UML类图包含以下几个关键角色：

• Command（命令接口）：声明执行操作的抽象方法。
• ConcreteCommand（具体命令）：实现Command接口，通常会持有接收者（Receiver）的引用，并调用其业务方法。
• Receiver（接收者）：知道如何执行与请求相关的操作。
• Invoker（调用者）：向客户端提供调用命令的方法，通常不直接与接收者交互。
• Client（客户端）：创建具体的命令对象，并设置其接收者。

类图文字描述

+---------------------+
|     Command         |
+---------------------+
| + execute()         |
+---------------------+
          ^
          |
+---------------------+
| ConcreteCommand     |
+---------------------+
| - receiver: Receiver|
| + execute()         |
+---------------------+
          ^
          |
+---------------------+
|     Receiver        |
+---------------------+
| + action()          |
+---------------------+
          ^
          |
+---------------------+
|     Invoker         |
+---------------------+
| + setCommand()      |
| + executeCommand()  |
+---------------------+

适用场景

命令模式适用于以下几种典型场景：

实现方式

下面是一个完整的Java代码示例，演示了命令模式的基本实现。

1. 定义命令接口

/**
 * 命令接口：定义执行操作的抽象方法
 */
public interface Command {
    void execute();
}

2. 定义接收者类

/**
 * 接收者：执行具体业务逻辑的对象
 */
public class Receiver {
    public void action() {
        System.out.println("Receiver is performing the action.");
    }
}

3. 定义具体命令类

/**
 * 具体命令类：实现Command接口，持有接收者的引用
 */
public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        // 调用接收者的业务方法
        receiver.action();
    }
}

4. 定义调用者类

/**
 * 调用者：负责调用命令对象的execute方法
 */
public class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        if (command != null) {
            command.execute();
        } else {
            System.out.println("No command to execute.");
        }
    }
}

5. 客户端代码

/**
 * 客户端：创建命令对象并设置接收者
 */
public class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();

        invoker.setCommand(command);
        invoker.executeCommand(); // 输出：Receiver is performing the action.
    }
}

工作原理

命令模式通过将请求封装为对象，实现了请求的解耦。调用者（Invoker）不再直接与接收者（Receiver）交互，而是通过命令对象间接调用。这使得系统更加灵活，可以轻松地添加新的命令类型而无需修改现有代码。

此外，由于命令对象是独立的，它们可以被存储、传递、重复使用甚至撤销。例如，在实现撤销功能时，只需要保存命令对象的历史记录即可。

优缺点分析

案例分析：任务调度系统

假设我们正在开发一个任务调度系统，需要支持异步执行任务、记录日志和撤销操作。使用命令模式可以很好地解决这些问题。

问题描述：

• 用户提交任务后，需要异步执行
• 需要记录每条任务的执行日志
• 需要支持撤销最近一次操作

解决方案：

使用命令模式封装每个任务，由调度器统一管理。每次执行任务时，同时记录日志；撤销操作时，只需调用对应的命令对象的undo()方法。

示例代码：

// 扩展命令接口，增加 undo 方法
public interface Command {
    void execute();
    void undo();
}

// 修改接收者
public class TaskReceiver {
    public void executeTask() {
        System.out.println("Executing task...");
    }

    public void undoTask() {
        System.out.println("Undoing task...");
    }
}

// 修改具体命令类
public class TaskCommand implements Command {
    private TaskReceiver receiver;
    private boolean executed = false;

    public TaskCommand(TaskReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        if (!executed) {
            receiver.executeTask();
            executed = true;
        }
    }

    @Override
    public void undo() {
        if (executed) {
            receiver.undoTask();
            executed = false;
        }
    }
}

// 修改调用者
public class TaskScheduler {
    private Command currentCommand;

    public void setCommand(Command command) {
        this.currentCommand = command;
    }

    public void executeCommand() {
        if (currentCommand != null) {
            currentCommand.execute();
        }
    }

    public void undoCommand() {
        if (currentCommand != null) {
            currentCommand.undo();
        }
    }
}

// 客户端测试
public class TaskClient {
    public static void main(String[] args) {
        TaskReceiver receiver = new TaskReceiver();
        Command command = new TaskCommand(receiver);
        TaskScheduler scheduler = new TaskScheduler();

        scheduler.setCommand(command);
        scheduler.executeCommand(); // 执行任务
        scheduler.undoCommand();    // 撤销任务
    }
}

在这个案例中，命令模式不仅提升了系统的可扩展性，还使任务的执行、记录和撤销变得非常简单。

与其他模式的关系

命令模式常与其他设计模式结合使用，以增强系统功能：

总结

今天我们详细学习了命令模式（Command Pattern）。通过将请求封装为对象，命令模式实现了请求的解耦，提高了系统的灵活性和可维护性。我们在Java中通过完整的代码示例展示了该模式的实现方式，并结合任务调度系统的实际案例进行了分析。

命令模式体现了面向对象设计中的单一职责原则（SRP）和开闭原则（OCP），因为每个命令类只关注自己的业务逻辑，且可以通过扩展命令类来满足新需求。

在接下来的Day 15中，我们将进入**解释器模式（Interpreter Pattern）**的学习，探索如何为语言或表达式定义文法并解析其含义。敬请期待！

文章标签

design-patterns, java, command-pattern, software-design, object-oriented-programming

文章简述

本文深入讲解了“设计模式精讲”系列的第14天——命令模式（Command Pattern）。文章从理论出发，介绍了命令模式的核心思想、结构组成和适用场景，并通过完整的Java代码示例展示了其基本实现方式。我们还通过一个任务调度系统的实际案例，说明了命令模式在真实项目中的应用价值。此外，文章还对比了命令模式与其他相关设计模式的关系，并分析了其优缺点。通过对命令模式的全面讲解，读者可以更好地理解如何在实际开发中利用这一模式提高系统的灵活性和可维护性。

进一步学习资料

1. Design Patterns: Elements of Reusable Object-Oriented Software
2. Refactoring Guru - Command Pattern
3. Java Design Patterns - Command Pattern
4. Martin Fowler’s Patterns of Enterprise Application Architecture - Command
5. Java Design Patterns Book - Command Pattern Example

核心设计思想总结

命令模式的核心在于将请求封装为对象，从而实现请求的参数化、记录、撤销等功能。在实际项目中，我们可以使用命令模式来构建任务调度系统、GUI事件处理、事务管理等模块，显著提升系统的可扩展性和可维护性。通过将请求的发起者与执行者解耦，命令模式让系统更加灵活，也更容易应对未来的变化。