【设计模式深度剖析】【2】【行为型】【命令模式】| 以打开文件按钮、宏命令、图形移动与撤销为例加深理解

👈️上一篇:模板方法模式    |   下一篇:职责链模式👉️

设计模式-专栏👈️

命令模式

命令模式（Command Pattern）又称为行动（Action）模式或交易（Transaction）模式。

命令模式就像是一个魔法卷轴。在这个奇幻的世界里，魔法师（请求者）不需要亲自施展复杂的法术（接收者），他们可以将法术的咒语和步骤记录在魔法卷轴上（命令对象）。

当魔法师需要施展某个法术时，他们只需挥动魔法卷轴，卷轴上的咒语就会自动激活，释放出强大的魔法力量。这样，魔法师就可以轻松地使用各种法术，而无需每次都记住复杂的咒语和步骤。

魔法卷轴的存在让魔法师的技能得以扩展和保存。他们可以将自己创造的独特法术记录在卷轴上，与他人分享或传授。此外，魔法卷轴还具有撤销和重做的能力，如果魔法师在施展法术时出现了错误，他们可以简单地收回卷轴并重新施展。

因此，命令模式就像是一个魔法卷轴，它让魔法的施展变得更加简单、高效和可控，为魔法师们带来了无尽的便利和乐趣。

本文源码，点击查看👈️

定义

英文原话

Encapsulate a request as an object, allowing you to parameterize clients with different requests, queue or log requests, and support undoable operations.

直译

将请求封装为一个对象，使得你可以使用不同的请求对客户端进行参数化；可以对请求进行排队或记录请求日志，并支持可撤销的操作。

在这个定义中，“Encapsulate a request as an object”指的是将请求（或操作）封装为对象的形式，

这样做的好处是可以将请求与其执行者解耦，提高系统的灵活性和可维护性。同时，通过封装请求为对象，还可以实现诸如请求队列、日志记录、撤销/重做等功能。

如何理解呢？

理解命令模式（Command Pattern）的关键在于认识到它如何帮助我们将请求（或操作）封装为对象，并将请求的发送者和接收者解耦。以下是对命令模式的详细理解：

1. 请求封装为对象：
   在命令模式中，一个请求被封装为一个对象，即命令对象。这个命令对象包含了执行特定操作的必要信息。通过封装请求为对象，我们可以将请求视为与其他对象一样的实体，并对其进行操作，如传递、存储和组合。

2. 发送者与接收者解耦：
   命令模式允许我们将请求的发送者（客户端）与请求的接收者（执行者）解耦。发送者不需要直接调用接收者的方法，而是通过命令对象来间接地触发接收者的操作。这种解耦提高了系统的灵活性和可扩展性。

   例如，我们可以轻松地更换接收者（执行不同的操作）或添加新的命令对象（执行新的操作），而无需修改发送者的代码。

3. 支持撤销、重做和日志记录：
   由于命令对象封装了请求的信息，我们可以轻松地实现撤销、重做和日志记录等功能。通过存储之前执行的命令对象，我们可以在需要时重新执行它们（实现重做）或反向执行它们（实现撤销）。此外，我们还可以记录命令的执行日志，以便后续的分析和调试。

4. 排队和调度：
   由于命令对象是可存储和可传递的，我们可以将它们放入队列中并按顺序执行（如命令队列），或者根据一定的调度策略来执行它们（如时间调度器）。这允许我们更灵活地控制操作的执行顺序和频率。

5. 简化客户端代码：
   通过引入命令对象作为中间层，我们可以简化客户端代码。客户端只需要知道如何创建和发送命令对象，而无需关心命令的具体执行细节。这使得客户端代码更加简洁和易于维护。

命令模式通过封装请求为对象并将发送者与接收者解耦，提供了一种灵活的方式来处理请求和操作。它支持撤销、重做、日志记录、排队和调度等功能，并简化了客户端代码。这些特性使得命令模式在许多场景中都非常有用，如GUI操作、数据库事务、游戏开发等。

四个角色

命令模式涉及以下几个主要角色：

1. Command（命令接口）

声明了一个执行操作的接口。

2. ConcreteCommand（具体命令类）

将一个接收者对象绑定于一个动作

通过调用接收者相应的操作，来实现Commond接口的抽象方法。

实现了Command接口，持有接收者（Receiver）对象，并调用接收者的功能来完成命令要执行的操作。

3. Client（客户端）

创建一个具体命令对象并设定它的接收者。

4. Invoker（调用者）

要求该命令执行这个请求。

5. Receiver（接收者）

知道如何实施与执行一个请求的相关的操作。

真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求的功能。

类图

类图分析

从类图中可以分析出：

调用者Invoker持有命令对象，ConcreteCommand具体命令持有接收者Receiver对象。

因此，调用者Invoker对象就可以间接执行接收者Receiver对象的动作，通过调用具体命令的执行方法execute()，而该方法实现方式是通过调用接收者Receiver对象的动作action()方法。

通过Command接口将调用者与接收者解耦，发送者不需要直接调用接收者的方法，而是通过命令对象来间接地触发接收者的操作。这种解耦提高了系统的灵活性和可扩展性。

代码示例

命令接口Command

package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 命令接口Command：命令（Command）角色
 */
public interface Command {
    // 执行命令的方法
    void execute();
}

具体命令ConcreteCommand

package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 具体命令ConcreteCommand：具体命令（Concrete Command）角色
 */
public class ConcreteCommand implements Command {
    private Receiver receiver;

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

    // 执行方法
    @Override
    public void execute() {
        this.receiver.action();
    }
}

客户端Client

package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 创建一个具体命令对象并设定它的接收者
 */
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.callCommand();
    }
}

调用者Invoker

package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 调用者Invoker
 */
public class Invoker {
    private Command command;

    // 构造函数初始化该命令
    public void setCommand(Command command) {
        this.command = command;
    }

    // 执行命令
    public void callCommand() {
        this.command.execute();
    }
}

接收者Receiver

package com.polaris.designpattern.list3.behavioral.pattern02.command.proto;

/**
 * 接收者Receiver
 */
public class Receiver {
    // 行动方法
    public void action() {
        System.out.println("Command executed.");
    }
}

输出打印

Command executed.

在这个示例中，

Receiver 是知道如何执行请求的对象，ConcreteCommand 是实现了 Command 接口的具体命令类，它持有一个 Receiver 对象并在 execute 方法中调用其 action 方法。

Invoker 是调用者，它持有 Command 对象并在需要时调用其 execute 方法。

Client 是客户端，负责创建和设置命令对象及其接收者。

应用

命令模式的应用

命令模式广泛应用于许多需要执行命令、撤销命令、记录命令历史或实现宏命令的系统中。以下是几个具体的应用场景：

1. 图形用户界面 (GUI) 中的按钮：每个按钮可以关联一个命令对象，当按钮被点击时，执行该命令。
2. 文本编辑器：撤销和重做功能可以通过命令模式实现，每个编辑操作（如插入、删除、剪切、粘贴等）都可以是一个命令。
3. 请求队列：系统可以接收多个命令请求，并将它们存储在一个队列中，然后按照先进先出（FIFO）的顺序执行这些命令。
4. 事务处理：在金融系统中，交易可以被封装为命令，从而可以轻松地回滚（撤销）事务。
5. 宏录制：用户可以录制一系列命令，然后在需要时重新执行这些命令，以实现自动化操作。

命令模式的优点

1. 解耦：命令模式将请求者与执行者解耦，使得请求者不需要知道如何执行命令，只需要知道如何发送命令。
2. 易于扩展：由于请求者和执行者之间的解耦，可以在不修改现有代码的情况下添加新的命令。
3. 支持撤销/重做：通过保存命令的历史记录，可以很容易地实现撤销和重做功能。
4. 易于实现事务：可以将多个命令组合成一个事务，从而确保所有命令都成功执行或全部回滚。
5. 易于记录日志和监控：可以轻松地记录每个命令的执行情况和结果，以便于后续的分析和监控。

命令模式的缺点

1. 可能导致过多的具体命令类：对于复杂的系统，可能需要大量的具体命令类来实现各种功能，这可能会增加系统的复杂性。
2. 可能增加系统的开销：由于命令对象通常包含对接收者的引用，并且在执行过程中可能需要额外的内存来存储命令历史记录，因此可能会增加系统的内存开销。

命令模式的使用场景

当需要满足以下条件时，可以考虑使用命令模式：

1. 请求者和执行者需要解耦：当请求者不需要知道如何执行请求，或者执行者不需要知道请求的来源时，可以使用命令模式。
2. 支持撤销/重做：如果系统需要支持撤销和重做功能，那么命令模式是一个很好的选择。
3. 需要记录请求的历史：如果系统需要记录每个请求的执行情况和结果，以便于后续的分析和监控，那么可以使用命令模式。
4. 需要实现事务：如果需要将多个操作组合成一个事务，以确保它们要么全部成功执行，要么全部回滚，那么命令模式是一个很好的选择。

示例解析1：菜单按钮（UI 控件）- 打开文件按钮

在这个示例中，我们有一个 UI 控件（比如一个按钮），当用户点击这个按钮时，它应该执行某个操作（打开文件）。

我们可以使用命令模式来解耦按钮和它所执行的操作。

类图

类图分析

这个类图可以对比之前的角色分析时候的类图，没错，可以发现是一致的结构，是一种场景的具化，为的是通过该具体示例进一步理解命令模式的各个角色。

1. Button调用者角色，持有一个命令对象，至于什么具体的命令对象，看用户给他传入什么命令对象，这里是要给它的构造器传入OpenFileCommand，用来初始化持有的命令对象，即该按钮的意图是要打开文件。而如何打开，打开哪个文件，由命令决定，调用者只需要负责按照自己的需要传入相应的命令即可；
2. OpenFileCommand具体命令，构造器初始化了它持有的接收者FileManager对象，以及要打开的文件名，即该命令的目的就是为了打开该指定的文件。该命令的操作方法execute()通过调用接收者打开文件的方法openFile(String)来实现的；
3. 从上面两步分析，可知，接收者FileManager并不知道谁会用到它，不知道谁是调用者，而调用者Button它只持有命令，具体谁（哪个接收者）来处理这个命令，它不直接关心，或者说它并不关心，他只直接知道我使用这个命令能完成这个事情，而具体这个命令如何操作的，由具体命令进行了封装，调用相应的接收者处理调用者的需求。因此，通过命令接口，解耦了调用者与接收者。
4. 客户端就是按照上面分析过程中，调用者需要持有一个具体命令对象，具体命令封装了调用哪个接收者的方法来处理调用者的需求，因此客户端Client实例化接收者，作为参数构造出具体命令，然后将具体命令对象作为参数构造出调用者对象，然后就是执行，调用者要求该命令执行这个请求。

代码示例

看完类图，然后把类图分析完，下面的代码就了然了。

package com.polaris.designpattern.list3.behavioral.pattern02.command.openfileuidemo;

// 命令接口
interface Command {  
    void execute();  
}  
  
// 打开文件的具体命令  
class OpenFileCommand implements Command {  
    private FileManager fileManager;  
    private String fileName;  
  
    public OpenFileCommand(FileManager fileManager, String fileName) {  
        this.fileManager = fileManager;  
        this.fileName = fileName;  
    }  
  
    @Override  
    public void execute() {  
        fileManager.openFile(fileName);  
    }  
}  
  
// 文件管理器（接收者）  
class FileManager {  
    public void openFile(String fileName) {  
        System.out.println("打开文件: " + fileName);  
    }  
    // ... 其他文件管理操作  
}  
  
// UI 控件（调用者）  
class Button {  
    private Command command;  
  
    public Button(Command command) {  
        this.command = command;  
    }  
  
    public void onClick() {  
        command.execute();  
    }  
}  
  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        FileManager fileManager = new FileManager();  
        Command openCommand = new OpenFileCommand(fileManager, "example.txt");  
        Button openButton = new Button(openCommand);  
  
        // 假设这是用户点击按钮的事件  
        openButton.onClick(); // 输出：打开文件: example.txt  
    }  
}

/* Output"
打开文件: example.txt
*///~

示例解析2：宏命令（组合多个命令）

在这个示例中，我们将展示如何使用命令模式来组合多个命令，形成一个宏命令。

注意一点即可，宏命令是组合了多个命令，它是要一次执行一组操作的。

类图

类图分析

除了接收者宏命令MacroCommand持有多个命令对象外，和示例1结构无差别。重点理解一组操作的概念，从类图也可以反映出来。

该示例与示例1的区别，我们模拟宏命令即组合多个命令，可以看到调用者MacroCommand持有一个命令列表，通过addCommand(Command)方法可以添加具体命令进去，它的需求就是一次将这一组命令依次执行，因此需要遍历执行每个命令。

代码示例

主要关注组合对象的实现即可，当然也可以再次重复理解一下命令模式的各个角色，及他们间的关系。

package com.polaris.designpattern.list3.behavioral.pattern02.command.macrocommand;


import com.polaris.designpattern.list3.behavioral.pattern02.command.proto.Command;

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

// 命令接口
interface Command {
    // 执行命令的方法
    void execute();
}

// 宏命令（组合多个命令）
// 宏命令（也是命令的一种，可以包含多个子命令）
class MacroCommand implements Command {
    private List<Command> commands = new ArrayList<>();

    public void addCommand(Command command) {
        commands.add(command);
    }

    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

// 接收者 TextEditor 类，用于编辑文本
class TextEditor {
    private String text; // 假设这是编辑器中的文本内容

    public TextEditor() {
        this.text = "";
    }

    // 获取编辑器中的文本
    public String getText() {
        return text;
    }

    // 设置编辑器中的文本（通常这不会是一个直接设置的方法，但为了简化示例）
    public void setText(String text) {
        this.text = text;
    }

    // 调整字体大小的方法（这里只是模拟，实际上可能需要更复杂的逻辑）
    public void adjustFontSize(int size) {
        // 在真实应用中，这里可能会更新编辑器的UI或状态来反映新的字体大小
        // 但在这个示例中，我们只是简单地打印一条消息
        System.out.println("字体大小已调整为: " + size);
    }

    // 其他可能的文本编辑方法...
}

// 具体的命令（比如调整字体大小）  
class AdjustFontSizeCommand implements Command {
    private TextEditor textEditor;
    private int size;

    public AdjustFontSizeCommand(TextEditor textEditor, int size) {
        this.textEditor = textEditor;
        this.size = size;
    }

    @Override
    public void execute() {
        textEditor.adjustFontSize(size);
    }
}

// 客户端代码  
public class Client {
    public static void main(String[] args) {
        TextEditor textEditor = new TextEditor(); // 假设 TextEditor 是接收者，用于编辑文本  

        // 创建具体的命令  
        Command fontSizeUp = new AdjustFontSizeCommand(textEditor, 12); // 增大字体  
        Command fontSizeDown = new AdjustFontSizeCommand(textEditor, 10); // 减小字体  

        // 创建宏命令，并添加具体的命令  
        MacroCommand macroCommand = new MacroCommand();
        macroCommand.addCommand(fontSizeUp);
        macroCommand.addCommand(fontSizeDown); // 注意：这里只是示例，通常不会连续执行增大和减小字体  

        // 执行宏命令  
        macroCommand.execute(); // 首先执行 fontSizeUp，然后执行 fontSizeDown  
    }
}

/* Output:
字体大小已调整为: 12
字体大小已调整为: 10
*///~

示例解析3：图形移动/撤销(重做功能)（丐版）

命令模式也可以用来实现撤销和重做功能。每个命令对象都可以存储其执行前的状态，以便在需要时撤销操作。

这里是一个简化的示例，图形的状态信息，这里主要关注图形的位置，在这里给简化省略了，我们只是通过打印文字模拟了一下。因此省略掉了接收者角色，直接在具体命令的方法中进行打印。

带有图形位置状态信息，且由接收者处理请求的示例见示例解析4

在这个示例，适应一下一个简单的变体：缺少接收者。

类图

类图分析

撤销，重做需要记录之前的状态信息，在这个示例我们简化了状态信息的记录，执行命令，与撤销命令通过在具体命令中进行打印，因此省略了接收者处理请求逻辑，因此在类图就省略了接收者角色；

UndoManager调用者，持有一个命令执行记录栈，当需要撤销，从栈中弹出一个上一次操作的命令执行该命令的撤销方法。

这里的命令接口的定义，分了两层，一层是基础命令，用来执行命令，另外扩展的带撤销功能的命令接口，定义了撤销方法，具体命令实现接口，也就实现了执行/撤销的逻辑。

代码示例

package com.polaris.designpattern.list3.behavioral.pattern02.command.undodemo.simple;

import java.util.Stack;

// 基础的命令接口
interface Command {
    void execute(); // 执行命令  
}

// 带有撤销功能的命令接口  
interface UndoableCommand extends Command {
    void undo(); // 撤销操作  
}

// 具体命令：具体的撤销命令（比如移动图形）
class MoveShapeCommand implements UndoableCommand {
    // 假设这里包含移动图形所需的状态信息  
    // 例如：起始位置、目标位置等  

    @Override
    public void execute() {
        // 执行移动操作  
        System.out.println("执行移动操作");
        // ... 实际移动图形的代码 ...  
    }

    @Override
    public void undo() {
        // 撤销移动操作，将图形移回原来的位置  
        System.out.println("撤销移动操作");
        // ... 实际撤销移动的代码 ...  
    }
}

// 撤销管理器（调用者）  
class UndoManager {
    private Stack<UndoableCommand> undoStack = new Stack<>();

    public void executeCommand(UndoableCommand command) {
        command.execute();
        undoStack.push(command); // 将命令添加到撤销栈中  
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            UndoableCommand command = undoStack.pop();
            command.undo(); // 调用命令的撤销方法  
            System.out.println("撤销成功");
        } else {
            System.out.println("没有可撤销的命令");
        }
    }

    // 可能还需要一个检查是否有可撤销命令的方法  
    public boolean canUndo() {
        return !undoStack.isEmpty();
    }

    // 如果需要重做功能，可以添加相应的栈和逻辑  
}

// 示例使用  
public class Client {
    public static void main(String[] args) {
        UndoManager undoManager = new UndoManager();
        UndoableCommand moveCommand = new MoveShapeCommand();

        // 执行命令  
        undoManager.executeCommand(moveCommand);

        // 撤销命令  
        if (undoManager.canUndo()) {
            undoManager.undo();
        }
    }
}
/* Output:
执行移动操作
撤销移动操作
撤销成功
*///~

示例解析4：图形移动/撤销(重做功能)

相较于上一个示例（示例3），通过增加接收者Shape类用来处理图形移动逻辑与Point类用来记录图形的位置信息。

类图

类图分析

1. UndoManager调用者在执行命令时候会将执行的命令压栈到栈中，当需要撤销操作时候，出栈弹出上一次的命令，执行撤销动作
2. 由于需要支持撤销，因此调用者必须持有的具体命令必须带有可撤销能力，因此需要持有 UndoableCommand 类型对象
3. 接收者 Shape 构造函数需要指定 Point对象，用来记录它的位置，它有一个获取图形当前所在位置的方法 getPositon() 和 移动到指定位置的方法 moveTo(Point)该方法需要传入一个目标位置
4. 具体命令构造器需要参数接收者 Shape 对象用来完成移动/撤销移动操作，同时获取该图形的当前位置信息，即原始位置，记录下来 ，用于撤销时候使用
5. 具体命令构造器需要参数接收者 Point 对象 targetPosition 用来表示需要移动到的位置

代码示例

package com.polaris.designpattern.list3.behavioral.pattern02.command.undodemo.complex;


import java.util.Stack;

// 基础的命令接口（如果不需要，可以省略）
interface Command {
    void execute(); // 执行命令  
}

// 带有撤销功能的命令接口  
interface UndoableCommand extends Command {
    void undo(); // 撤销操作  
}

// 图形类：用于记录移动图形所需的状态信息
class Shape {
    Point position; // 假设有一个Point类表示位置  

    Shape(Point position) {
        this.position = position;
        System.out.println("图形原位置：" + position);
    }

    // ... 其他图形相关的方法 ...  

    void moveTo(Point newPosition) {
        this.position = newPosition;
        System.out.println("图形移动到: " + newPosition);
    }

    Point getPosition() {
        return position;
    }
}

// 点类，表示位置：用于记录移动图形所需的状态信息
class Point {
    int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

// 具体命令：具体的撤销命令（比如移动图形）
class MoveShapeCommand implements UndoableCommand {
    private Shape shape;
    private Point originalPosition; // 原始位置  
    private Point targetPosition; // 目标位置  

    public MoveShapeCommand(Shape shape, Point targetPosition) {
        this.shape = shape;
        this.originalPosition = new Point(shape.getPosition().x, shape.getPosition().y); // 保存原始位置  
        this.targetPosition = targetPosition;
    }

    @Override
    public void execute() {
        // 执行移动操作  
        System.out.println("执行移动操作");
        shape.moveTo(targetPosition); // 实际移动图形的代码  
    }

    @Override
    public void undo() {
        // 撤销移动操作，将图形移回原来的位置  
        System.out.println("撤销移动操作");
        shape.moveTo(originalPosition); // 实际撤销移动的代码  
    }
}

// 撤销管理器（调用者）
class UndoManager {
    private Stack<UndoableCommand> undoStack = new Stack<>();

    public void executeCommand(UndoableCommand command) {
        command.execute();
        undoStack.push(command); // 将命令添加到撤销栈中
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            UndoableCommand command = undoStack.pop();
            command.undo(); // 调用命令的撤销方法
            System.out.println("撤销成功");
        } else {
            System.out.println("没有可撤销的命令");
        }
    }

    // 可能还需要一个检查是否有可撤销命令的方法
    public boolean canUndo() {
        return !undoStack.isEmpty();
    }

    // 如果需要重做功能，可以添加相应的栈和逻辑
}

// 示例使用
public class Client {
    public static void main(String[] args) {
        UndoManager undoManager = new UndoManager();
        Shape shape = new Shape(new Point(0, 0)); // 创建一个在(0, 0)位置的图形  
        UndoableCommand moveCommand = new MoveShapeCommand(shape, new Point(10, 10)); // 移动到(10, 10)位置  

        // 执行命令
        undoManager.executeCommand(moveCommand);

        // 撤销命令
        if (undoManager.canUndo()) {
            undoManager.undo();
        }
    }
}
/* Output:
图形原位置：(0, 0)
执行移动操作
图形移动到: (10, 10)
撤销移动操作
图形移动到: (0, 0)
撤销成功
*///~

在这个示例中，我们添加了一个Shape类来表示图形，以及一个Point类来表示位置。MoveShapeCommand现在保存了图形的原始位置和目标位置，以便在execute和undo方法中使用。在Main类的示例中，我们创建了一个在(0, 0)位置的图形，并创建了一个命令来将其移动到(10, 10)位置。然后，我们通过UndoManager执行该命令并撤销它。

👈️上一篇:模板方法模式    |   下一篇:职责链模式👉️

设计模式-专栏👈️