[特殊字符]命令模式：代码世界的遥控器，让操作更灵活！-CSDN博客

🚀命令模式：代码世界的遥控器，让操作更灵活！

一、命令模式初体验

在这里插入图片描述

✨在生活中，遥控器是我们的好帮手：按下按钮就能控制电视、空调等设备。在代码世界里，命令模式就像这样的遥控器，将操作封装成 “命令对象”，让调用者与执行者解耦。比如游戏中的 “撤销” 功能、GUI 界面的按钮响应，都能通过命令模式实现！

二、命令模式核心解析

2.1 模式定义与原理

命令模式，简单来说，就是把请求（命令）封装成一个对象。这样做有什么好处呢？一方面，它能让我们用不同请求去参数化其他对象，就像给遥控器设置不同的功能按钮；另一方面，它还支持请求的排队执行、记录日志，甚至撤销操作，就像游戏里可以撤销上一步操作一样。

命令模式的核心原理在于，把函数封装成对象。在很多编程语言里，函数不能直接当参数传递，但通过命令模式，把函数放到类里，再实例化对象，就能像传递对象一样传递函数啦。这样做最大的好处就是方便控制命令执行，比如实现异步、延迟、排队执行命令，还有撤销重做、存储命令、记录日志等等。

我们来举个生活中的例子帮助理解：在餐厅里，顾客点菜，服务员把订单传递给厨师，厨师根据订单做菜。这里，顾客就像是调用者，不用关心厨房内部怎么运作；服务员就像命令对象，负责传递订单；厨师则是接收者，真正执行做菜的操作。顾客和厨师之间通过订单（命令对象）解耦，这就是命令模式的实际体现。

2.2 四大核心角色

命令模式中有四个核心角色，它们各司其职，共同完成命令的传递与执行。下面通过一个简单的遥控器控制电灯的例子，来详细了解一下这四个角色：

抽象命令（Command）：定义命令的接口，声明执行的方法。就像遥控器上的按钮，每个按钮都代表一个抽象的操作命令，但具体做什么还不确定。

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

具体命令（ConcreteCommand）：实现抽象命令接口，绑定接收者，完成具体操作。比如遥控器上的开灯按钮，它实现了抽象命令接口，内部绑定了电灯对象（接收者），调用接收者的开灯方法来完成开灯操作。

// 具体命令：开灯命令
public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

// 具体命令：关灯命令
public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

接收者（Receiver）：真正执行具体操作的对象。在这个例子里，电灯就是接收者，它有自己的开灯和关灯方法，负责实际的动作执行。

// 接收者：电灯
public class Light {
    public void on() {
        System.out.println("灯打开了");
    }

    public void off() {
        System.out.println("灯关闭了");
    }
}

调用者（Invoker）：触发命令的对象，持有命令对象，通过它来执行命令。遥控器就是调用者，它上面有各种按钮（命令对象），用户按下按钮时，遥控器就调用相应命令对象的执行方法。

// 调用者：遥控器
public class RemoteControl {
    private Command command;

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

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

在这个例子中，调用者（遥控器）通过抽象命令（按钮接口）与具体命令（开灯、关灯命令）交互，具体命令持有接收者（电灯）的引用，在执行命令时调用接收者的方法来完成实际操作。这样，调用者和接收者就完全解耦了，增加新的命令或者更换接收者都非常方便。

三、Java 代码实战

3.1 基础案例：灯光控制

接下来，我们通过一个灯光控制的示例来深入理解命令模式在 Java 中的实现。

首先，定义抽象命令接口Command，它声明了执行命令的方法execute。

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

然后，创建接收者Light类，它包含具体的开灯和关灯操作。

// 接收者：电灯
public class Light {
    public void on() {
        System.out.println("灯打开了");
    }

    public void off() {
        System.out.println("灯关闭了");
    }
}

接着，实现具体命令类LightOnCommand和LightOffCommand，它们分别实现了开灯和关灯的具体操作，并且持有接收者Light的引用。

// 具体命令：开灯命令
public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

// 具体命令：关灯命令
public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

最后，创建调用者RemoteControl类，它持有命令对象，并通过pressButton方法来触发命令的执行。

// 调用者：遥控器
public class RemoteControl {
    private Command command;

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

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

测试代码如下：

public class CommandPatternTest {
    public static void main(String[] args) {
        // 创建电灯对象
        Light light = new Light();
        // 创建开灯命令对象
        Command lightOnCommand = new LightOnCommand(light);
        // 创建关灯命令对象
        Command lightOffCommand = new LightOffCommand(light);
        // 创建遥控器对象
        RemoteControl remoteControl = new RemoteControl();
        // 设置遥控器的命令为开灯命令
        remoteControl.setCommand(lightOnCommand);
        // 按下按钮，执行开灯操作
        remoteControl.pressButton();
        // 设置遥控器的命令为关灯命令
        remoteControl.setCommand(lightOffCommand);
        // 按下按钮，执行关灯操作
        remoteControl.pressButton();
    }
}

在上述代码中，调用者（遥控器）不需要知道具体的操作细节，只需要通过命令对象来执行相应的操作，实现了调用者和接收者之间的解耦。

3.2 进阶案例：宏命令（批量操作）

宏命令是命令模式的一种扩展，它允许将多个命令组合成一个更大的命令，从而实现批量操作。比如在游戏中，我们可以将一系列动作组合成一个宏，一键触发。下面是一个简单的宏命令示例：

定义命令接口Command：

public interface Command {
    void execute();
}

创建具体命令类，例如AttackCommand（攻击命令）和DefendCommand（防御命令）：

// 具体命令：攻击命令
public class AttackCommand implements Command {
    @Override
    public void execute() {
        System.out.println("执行攻击动作");
    }
}

// 具体命令：防御命令
public class DefendCommand implements Command {
    @Override
    public void execute() {
        System.out.println("执行防御动作");
    }
}

创建宏命令类MacroCommand，它可以包含多个命令，并在执行时依次执行这些命令：

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

// 宏命令类
public 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();
        }
    }
}

测试宏命令：

public class MacroCommandTest {
    public static void main(String[] args) {
        // 创建攻击命令对象
        Command attackCommand = new AttackCommand();
        // 创建防御命令对象
        Command defendCommand = new DefendCommand();
        // 创建宏命令对象
        MacroCommand macroCommand = new MacroCommand();
        // 将攻击命令和防御命令添加到宏命令中
        macroCommand.addCommand(attackCommand);
        macroCommand.addCommand(defendCommand);
        // 执行宏命令
        macroCommand.execute();
    }
}

在这个示例中，MacroCommand类实现了将多个命令组合成一个宏命令的功能。通过调用macroCommand.execute()，可以依次执行宏命令中包含的所有命令，实现了批量操作。这种方式在需要一次性执行多个相关操作的场景中非常有用，例如游戏中的连招操作、软件中的批量处理任务等。

四、应用场景大揭秘

命令模式在软件开发中应用广泛，能够解决许多实际问题，提升系统的灵活性和可维护性。以下是一些常见的应用场景：

操作记录与撤销：在文本编辑器中，我们经常使用 “Ctrl+Z” 来撤销上一步操作，这背后就可以用命令模式实现。每一个编辑操作（如插入文字、删除文字）都被封装成一个命令对象，当执行操作时，将命令对象加入到命令历史记录中。撤销操作时，从命令历史记录中取出上一个命令对象，并调用其撤销方法，就可以实现撤销功能。这种方式使得操作记录和撤销功能的实现变得非常方便，而且易于扩展。

批处理操作：在游戏中，连招技能是一个很好的例子。玩家按下一个组合键，就能触发一系列的技能释放。这可以通过宏命令来实现，将多个技能释放命令组合成一个宏命令，当玩家触发连招时，执行这个宏命令，就可以依次释放多个技能，实现复杂的连招效果。

异步任务处理：在消息队列中，任务的执行也可以使用命令模式。生产者将任务封装成命令对象，放入消息队列中。消费者从消息队列中取出命令对象，并执行其对应的操作。这样可以实现任务的异步处理，提高系统的响应性能。

GUI 事件响应：在图形用户界面（GUI）中，按钮点击是最常见的交互方式之一。当用户点击按钮时，通常会触发一系列复杂的业务逻辑。使用命令模式，可以将按钮点击事件封装成命令对象，将具体的业务逻辑封装在命令对象的执行方法中。这样，按钮和业务逻辑之间就实现了解耦，当业务逻辑发生变化时，只需要修改命令对象的实现，而不需要修改按钮的代码。

五、优缺点大 PK

命令模式作为一种重要的设计模式，在带来诸多优势的同时，也存在一些不可忽视的缺点。下面我们来详细分析一下它的优缺点。

5.1 优点大放送

解耦利器：命令模式最大的优势就是将调用者与接收者分离，两者之间通过命令对象进行交互。这使得调用者无需了解接收者的具体实现细节，接收者也不用关心请求是如何发起的，从而大大降低了代码的耦合度，提高了代码的可维护性和可扩展性。就像在一个复杂的游戏系统中，玩家操作（调用者）和游戏角色行为（接收者）之间通过各种命令（如移动命令、攻击命令）解耦，玩家只需要发出操作指令，而游戏角色根据相应命令执行动作，两者的修改和扩展都不会相互影响。

扩展性 MAX：新增命令时，只需要定义一个新的具体命令类，实现抽象命令接口即可，无需修改现有代码，完全符合开闭原则。例如在一个图形绘制软件中，如果要新增一种绘制图形的命令（如绘制五角星），只需要创建一个新的绘制五角星命令类，实现绘制命令接口，就可以轻松实现扩展，而不会影响到其他已有的绘制命令和相关代码。

灵活性爆表：支持命令的撤销、重做与批量执行。通过记录命令执行的历史，很容易实现撤销和重做功能；通过宏命令，可以将多个命令组合起来执行，实现复杂的操作序列。比如在文本编辑软件中，我们可以轻松撤销或重做之前的编辑操作；在自动化测试工具中，可以通过宏命令批量执行一系列测试步骤。

5.2 缺点小提醒

类数量激增：每个命令都需要单独定义一个类，当系统中命令较多时，会导致类的数量大幅增加，增加了代码的管理和维护难度。例如在一个大型的企业级应用中，可能存在各种各样的业务操作命令，如果都使用命令模式实现，类的数量会非常庞大。

复杂度提升：在多层命令嵌套的情况下，代码的逻辑和执行流程会变得复杂，增加了理解和维护的成本。比如在一个涉及复杂业务流程的系统中，可能存在多个宏命令嵌套，每个宏命令又包含多个子命令，这种情况下追踪和调试代码会变得比较困难。

在实际应用中，我们需要根据具体的业务需求和系统特点，权衡命令模式的优缺点，合理地选择和使用该模式。

六、避坑指南

在使用命令模式时，以下这些 “坑” 可一定要避开，才能让你的代码更健壮、更高效。

合理设计命令粒度：命令粒度太细，会导致类数量过多，增加代码复杂性；命令粒度太粗，又会使命令功能过于复杂，缺乏灵活性。比如在一个图形绘制系统中，如果将每个像素点的绘制都作为一个命令，命令粒度就太细了；而如果将整个图形的绘制作为一个命令，又太粗了。可以根据实际业务需求，将绘制一条线段、一个图形等作为一个命令，这样既能保证命令的灵活性，又不会使类数量过多。

支持撤销操作：实现undo方法时，一定要确保能正确回滚到操作前的状态。这就要求在执行命令时，记录好相关的状态信息，以便在撤销时恢复。例如在一个文本编辑软件中，执行插入文字命令时，要记录插入的位置和内容，这样在撤销时才能准确删除插入的文字，恢复到原来的文本状态。

线程安全：在多线程环境下，命令的执行可能会出现并发问题。要注意对共享资源的访问控制，比如使用锁机制或原子类来确保命令执行的线程安全。比如在一个多线程的游戏系统中，多个线程可能同时触发攻击命令，如果不进行线程安全处理，可能会导致游戏状态的不一致。

日志记录：记录命令执行历史，不仅能帮助我们排查问题，还能实现撤销、重做等功能。可以使用日志框架，如Log4j、SLF4J等，将命令的执行信息（如命令名称、执行时间、参数等）记录下来。例如在一个电商系统中，记录订单操作的命令历史，当出现订单异常时，就可以通过查看日志来追溯问题。

七、模式对比

在设计模式的大家庭中，不同模式各有所长，下面将命令模式与责任链模式、策略模式进行对比，帮助大家更好地理解它们之间的差异。

模式	核心差异	适用场景
责任链	请求链式传递，多个对象都有机会处理同一个请求，直到有对象处理它为止，请求发送者和接收者解耦	审批流程，如请假审批、订单审批等，一个请求可能会被多个对象依次处理
策略	动态切换算法，将一系列算法封装起来，使它们可以相互替换，算法的变化独立于使用它的客户	支付方式选择，如支付宝、微信、银行卡支付等，根据不同需求选择不同的支付策略
命令	操作封装与解耦，将请求封装成对象，使调用者与接收者解耦，支持命令的排队、记录、撤销等操作	可撤销操作、批处理，如文本编辑器的撤销操作、游戏中的连招操作等