设计模式-命令模式（Command）

1. 概念

• 命令模式（Command Pattern）是一种行为型设计模式，也被称为动作模式或事务模式。它的核心思想是将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化。对请求排队或记录，以及支持可撤销的操作。命令模式的主要目的是将发出请求的对象和执行请求的对象解耦。

2. 原理结构图

文章来源地址https://www.toymoban.com/news/detail-860267.html

• Command：这是一个接口，它声明了执行操作的方法。这个接口是所有具体命令类的基础，确保它们具有统一的执行方法调用方式。
• ConcreteCommand：这是实现了Command接口的具体类。它定义了接收者如何进行具体的操作执行。一个具体的命令类通常会持有一个对接收者的引用，并通过调用接收者的方法来完成请求的处理。
• Receiver：这是知道如何实施与执行请求相关的操作的类，也就是实际执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
• Invoker：这是负责调用命令对象执行请求的类，它会持有一个命令对象，并在某个时间点触发命令的执行。调用者作为一个中介，将发起请求的对象和执行请求的对象解耦。

3. 代码示例

3.1 示例1–在线购物系统

• 实现一个在线购物系统。以下是一个简单的Java代码实现：

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

// 命令接口
interface Command {
    void execute();
}

// 具体命令类：添加商品到购物车
class AddToCartCommand implements Command {
    private ShoppingCart cart;
    private Product product;

    public AddToCartCommand(ShoppingCart cart, Product product) {
        this.cart = cart;
        this.product = product;
    }

    @Override
    public void execute() {
        cart.addProduct(product);
    }
}

// 具体命令类：从购物车中移除商品
class RemoveFromCartCommand implements Command {
    private ShoppingCart cart;
    private Product product;

    public RemoveFromCartCommand(ShoppingCart cart, Product product) {
        this.cart = cart;
        this.product = product;
    }

    @Override
    public void execute() {
        cart.removeProduct(product);
    }
}

// 接收者类：购物车
class ShoppingCart {
    private List<Product> products = new ArrayList<>();

    public void addProduct(Product product) {
        products.add(product);
        System.out.println("Added " + product.getName() + " to the shopping cart.");
    }

    public void removeProduct(Product product) {
        products.remove(product);
        System.out.println("Removed " + product.getName() + " from the shopping cart.");
    }
}

// 调用者类：用户
class User {
    private Command command;

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

    public void executeCommand() {
        command.execute();
    }
}

// 产品类
class Product {
    private String name;

    public Product(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class ShoppingSystemDemo {
    public static void main(String[] args) {
        // 创建用户、购物车和产品对象
        User user = new User();
        ShoppingCart cart = new ShoppingCart();
        Product product1 = new Product("Apple");
        Product product2 = new Product("Banana");

        // 添加商品到购物车
        user.setCommand(new AddToCartCommand(cart, product1));
        user.executeCommand();

        // 从购物车中移除商品
        user.setCommand(new RemoveFromCartCommand(cart, product1));
        user.executeCommand();
    }
}

• 输出

Added Apple to the shopping cart.
Removed Apple from the shopping cart.

• 在这个例子中，定义了一个命令接口Command，以及两个具体的命令类AddToCartCommand和RemoveFromCartCommand。这些命令类实现了Command接口，并在execute()方法中执行相应的操作。接收者类ShoppingCart负责处理添加和移除商品的操作。调用者类User负责设置命令并执行命令。最后，在main方法中创建了用户、购物车和产品对象，并通过命令模式实现了添加和移除商品的功能。

3.2 示例2

• 实现一个支持撤销功能的文本编辑器。以下是一个简单的Java代码实现：

// 命令接口
interface Command {
    void execute();
    void undo();
}

// 具体命令类：添加文本
class AddTextCommand implements Command {
    private TextEditor editor;
    private String text;

    public AddTextCommand(TextEditor editor, String text) {
        this.editor = editor;
        this.text = text;
    }

    @Override
    public void execute() {
        editor.addText(text);
    }

    @Override
    public void undo() {
        editor.deleteText(editor.getContentLength() - text.length(), editor.getContentLength());
    }
}

// 具体命令类：删除文本
class DeleteTextCommand implements Command {
    private TextEditor editor;
    private int startIndex;
    private int endIndex;
    private String deletedText;

    public DeleteTextCommand(TextEditor editor, int startIndex, int endIndex) {
        this.editor = editor;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
        this.deletedText = editor.getSubstring(startIndex, endIndex);
    }

    @Override
    public void execute() {
        editor.deleteText(startIndex, endIndex);
    }

    @Override
    public void undo() {
        editor.addText(deletedText);
    }
}

// 接收者类：文本编辑器
class TextEditor {
    private StringBuilder content = new StringBuilder();

    public void addText(String text) {
        content.append(text);
        System.out.println("Added text: " + text);
    }

    public void deleteText(int startIndex, int endIndex) {
        if (startIndex >= 0 && endIndex < content.length()) {
            content.delete(startIndex, endIndex);
            System.out.println("Deleted text from index " + startIndex + " to " + endIndex);
        } else {
            System.out.println("Invalid index range for deletion");
        }
    }

    public int getContentLength() {
        return content.length();
    }

    public String getSubstring(int startIndex, int endIndex) {
        return content.substring(startIndex, endIndex);
    }
}

// 调用者类：用户
class User {
    private Command command;

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

    public void executeCommand() {
        command.execute();
    }

    public void undoCommand() {
        command.undo();
    }
}

public class TextEditDemo {
    public static void main(String[] args) {
        // 创建用户、文本编辑器对象
        User user = new User();
        TextEditor editor = new TextEditor();

        // 添加文本到文本编辑器
        user.setCommand(new AddTextCommand(editor, "Hello, world!"));
        user.executeCommand();

        // 删除文本从文本编辑器
        user.setCommand(new DeleteTextCommand(editor, 0, 5));
        user.executeCommand();

        // 撤销操作
        user.undoCommand();
    }
}

• 将看到如下输出：

Added text: Hello, world!
Deleted text from index 0 to 5
Added text: Hello

• 在这个例子中，定义了一个命令接口Command，以及两个具体的命令类AddTextCommand和DeleteTextCommand。这些命令类实现了Command接口，并在execute()方法中执行相应的操作。同时，它们还实现了undo()方法，用于撤销操作。接收者类TextEditor负责处理添加和删除文本的操作。调用者类User负责设置命令并执行命令。最后，在main方法中创建了用户和文本编辑器对象，并通过命令模式实现了添加和删除文本的功能，并支持撤销操作。

4. 优缺点

• 主要作用
  • 实现调用操作和实现操作的解耦，以及提供记录、撤销/重做和事务等功能处理。
• 优点
  • 降低系统耦合度：命令模式通过将请求调用者和接收者解耦，使得双方不必相互依赖，从而降低了系统各部分之间的直接联系。
  • 良好的封装性：每个命令都被封装成对象，客户端只需调用相应的命令对象而无需关心具体的执行细节，增强了代码的模块性和复用性。
  • 高扩展性：在命令模式中，新增命令通常不需要从零开始编写，可以利用现有的接收者类和命令类，通过组合或继承来实现，这使得扩展新功能变得简单方便。
  • 方便实现撤销/重做：命令模式可以与备忘录模式结合使用，便于实现对已执行命令的撤销（Undo）和重做（Redo）操作，这对于很多交互式应用程序来说是非常重要的功能。
• 缺点
  • 实现复杂性：相比直接调用操作，命令模式引入了命令对象和接收者对象之间的额外间接层，这增加了系统的实现复杂性。
  • 维护成本：随着命令类数量的增加，维护成本可能会上升，特别是在命令种类非常多的情况下，管理这些命令可能会变得繁琐。
  • 性能影响：每次调用命令都会产生新的命令对象，这可能会增加内存占用和垃圾回收的频率，从而对系统性能产生一定的影响。
  • 使用限制：如果一个请求的执行需要多个接收者参与，那么命令模式可能需要额外的工作来协调多个接收者之间的交互。
  • 过度设计：对于简单的系统或者不需要解耦请求发起者和执行者的系统，使用命令模式可能会导致设计过度。

5. 应用场景

5.1 主要包括以下几个方面

1. 自动化操作：在需要程序自动执行一系列步骤的情境中，命令模式可以显著减少用户的手动操作。例如，在计算机安装程序中，程序可以根据用户的选择自动执行一系列操作，而无需用户手动输入每一步的指令。
2. 多线程操作：在多线程环境中，多个线程可以发出操作命令，而程序可以在后台自动处理这些命令，无需等待线程完成。这有助于提高系统的响应速度和效率。
3. 存储与回放：命令模式也常用于存储一系列操作，如用户操作数据库的一系列命令。这些命令可以被存储起来，并在需要时重新加载执行，从而让用户能够继续之前的操作，无需重新输入指令。
4. 请求调用者与接收者解耦：当需要将请求发送者和接收者解耦，使得发送者不需要知道接收者的具体实现细节时，命令模式非常适用。这有助于降低系统的耦合度，提高代码的可读性和可维护性。
5. 支持撤销和重做操作：命令模式可以记录命令的执行历史，从而支持撤销和重做操作。这在文本编辑器、绘图工具等需要频繁修改和回退的应用中非常有用。
6. 实现事务性操作：通过将多个命令组合成一个复合命令，命令模式可以实现事务性操作。这确保了要么所有命令都成功执行，要么在发生错误时所有命令都不执行，从而保证了数据的完整性和一致性。

5.2 实际应用

1. 文本编辑器：在文本编辑器中，用户的操作如复制、粘贴、撤销等都可以被视作命令。使用命令模式可以方便地实现这些操作的记录和撤销。
2. GUI按钮与操作：图形用户界面中的按钮通常对应特定的操作，例如“保存”按钮会触发保存操作。使用命令模式可以将每个按钮的行为封装成具体的命令对象，使得按钮与实际执行的操作解耦。
3. 事务处理系统：在数据库事务处理中，一个事务可能包含多个操作步骤。使用命令模式可以将这些步骤封装成命令对象，确保事务的原子性。
4. 宏命令：在软件系统中，用户可能需要通过一个操作来触发一系列行为。命令模式可以用来创建一个宏命令，该命令包含多个子命令，从而简化用户操作。
5. 调度系统：在任务调度系统中，可以使用命令模式来表示待执行的任务，这些任务可以被安排在特定时间执行或按照某种规则进行排队。
6. 游戏：在游戏中，角色的每一个动作（如移动、攻击、跳跃）都可以被抽象为命令，游戏循环可以作为调用者来执行这些命令。
7. 遥控器：在智能家居系统中，遥控器发送的命令（如开灯、调整温度）可以通过命令模式来实现，使得命令的发送者和接收者可以独立变化。
8. 工作流引擎：在工作流引擎中，业务流程的各个步骤可以被设计为命令对象，工作流引擎负责调用这些命令来驱动流程的前进。

6. JDK中的使用

• Runnable接口和Callable接口：Runnable和Callable接口是JDK中线程任务执行的基础，它们都体现了命令模式的思想。
  • 请求封装为对象：Runnable和Callable接口的实例代表了一个可以被线程执行的任务（即命令）。这些任务可以是任何逻辑，只要实现了相应的接口方法。
  • 解耦：通过传递Runnable或Callable对象给线程（如Thread类或线程池），我们实现了任务提交者和任务执行者之间的解耦。提交者不需要知道任务的具体实现细节，只需要关心任务的执行。
  • 灵活性：由于任务被封装为对象，我们可以轻松地将任务传递给不同的线程或线程池执行，也可以将任务存储在队列中等待执行，从而实现更高的灵活性。
• Comparator接口：Comparator接口用于定义对象的比较逻辑，它常被用于集合的排序操作
  • 请求封装：Comparator的实例代表了一种比较命令，它定义了如何比较两个对象。通过传递不同的Comparator对象给排序方法，我们可以实现不同的排序逻辑。
  • 灵活性：由于比较逻辑被封装为对象，我们可以轻松地为同一个集合定义多种排序方式，而无需修改集合本身或对象的内部状态。
  • 解耦：排序方法和比较逻辑之间的解耦使得代码更加清晰和易于维护。排序方法只需要关注如何根据提供的比较逻辑来排序对象，而不需要关心比较逻辑的具体实现。

7. 注意事项

1. 注意解耦：确保请求发送者与接收者之间解耦，提高系统灵活性。
2. 控制命令类数量：避免创建过多的具体命令类，防止系统复杂化。
3. 考虑撤销与重做：如果需要，实现命令的撤销和重做功能，增强用户体验。
4. 安全性与权限：确保命令执行的安全性，并进行必要的权限检查。
5. 命令命名与封装：命令命名应清晰，封装完整的请求信息，确保一致性和完整性。

8. 命令模式 VS 外观模式

到了这里，关于设计模式-命令模式（Command）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！