命令模式

3.1. 结构组成¶

命令模式主要由以下四个角色组成：

1. Command（命令接口）：声明执行操作的接口，通常包含一个执行操作的方法。

2. ConcreteCommand（具体命令）：实现Command接口，定义与接收者之间的绑定关系，调用接收者的相应操作。

3. Receiver（接收者）：知道如何执行与执行请求相关的操作，负责实际的业务逻辑。

4. Invoker（调用者）：持有Command对象，并在适当的时候调用命令对象执行请求。

5. Client（客户端）：创建ConcreteCommand对象，并设定其接收者。

角色关系：

• Client 创建并配置 ConcreteCommand 对象，将接收者传递给它。

• Invoker 持有 Command 对象，并通过调用命令的执行方法来触发操作。

• ConcreteCommand 通过调用 Receiver 的操作来完成请求。

3.2. UML类图¶

以下是命令模式的简化UML类图：

        +----------------+          +---------------------+
        |    Client      |          |       Invoker       |
        +----------------+          +---------------------+
        |                |          | - command: Command  |
        |                |          | + setCommand(cmd)   |
        |                |          | + executeCommand()  |
        +----------------+          +---------------------+
                  |                          |
                  |                          |
                  v                          |
        +----------------+                   |
        |    Command     |                   |
        +----------------+                   |
        | + execute()    |                   |
        +----------------+                   |
                  ^                          |
                  |                          |
    +------------------------+       +-----------------------+
    |   ConcreteCommandA     |       |   ConcreteCommandB    |
    +------------------------+       +-----------------------+
    | - receiver: Receiver   |       | - receiver: Receiver  |
    +------------------------+       +-----------------------+
    | + execute()            |       | + execute()           |
    +------------------------+       +-----------------------+
                  |                          |
                  |                          |
                  v                          v
        +----------------+          +---------------------+
        |   ReceiverA    |          |     ReceiverB       |
        +----------------+          +---------------------+
        | + actionA()    |          | + actionB()         |
        +----------------+          +---------------------+

说明：

• Client 创建具体的命令对象并设置其接收者。

• Invoker 持有命令对象，并在需要时调用命令的execute()方法。

• ConcreteCommand 实现execute()方法，通过调用接收者的操作来完成请求。

• Receiver 执行具体的业务逻辑。

4.1. Java 实现示例¶

以下是一个使用命令模式实现简单的远程控制系统的示例，其中Command作为命令接口，Light作为接收者，LightOnCommand和LightOffCommand作为具体命令，RemoteControl作为调用者，Client作为客户端。

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

// Receiver类
public class Light {
    private String location;

    public Light(String location){
        this.location = location;
    }

    public void on(){
        System.out.println(location + " light is ON");
    }

    public void off(){
        System.out.println(location + " light is OFF");
    }
}

// ConcreteCommand类：打开灯
public class LightOnCommand implements Command {
    private Light light;

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

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

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

// ConcreteCommand类：关闭灯
public class LightOffCommand implements Command {
    private Light light;

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

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

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

// Invoker类
public class RemoteControl {
    private Command slot;
    private Command lastCommand;

    public void setCommand(Command command){
        slot = command;
    }

    public void pressButton(){
        slot.execute();
        lastCommand = slot;
    }

    public void pressUndo(){
        lastCommand.undo();
    }
}

// Client代码
public class CommandPatternDemo {
    public static void main(String[] args) {
        RemoteControl remote = new RemoteControl();

        Light livingRoomLight = new Light("Living Room");
        Command lightOn = new LightOnCommand(livingRoomLight);
        Command lightOff = new LightOffCommand(livingRoomLight);

        // 打开灯
        remote.setCommand(lightOn);
        remote.pressButton();

        // 关闭灯
        remote.setCommand(lightOff);
        remote.pressButton();

        // 撤销关闭灯操作
        remote.pressUndo();
    }
}

输出：

Living Room light is ON
Living Room light is OFF
Living Room light is ON

说明：

• Light 是接收者，负责执行具体的业务逻辑。

• LightOnCommand 和 LightOffCommand 是具体命令，实现了Command接口，绑定了Light接收者。

• RemoteControl 是调用者，持有命令对象，并在适当的时候调用命令的执行方法。

• CommandPatternDemo 是客户端，设置命令对象并发起请求。

4.2. Python 实现示例¶

以下是使用命令模式实现简单的远程控制系统的Python示例。

from abc import ABC, abstractmethod

# Command接口
class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

    @abstractmethod
    def undo(self):
        pass

# Receiver类
class Light:
    def __init__(self, location):
        self.location = location

    def on(self):
        print(f"{self.location} light is ON")

    def off(self):
        print(f"{self.location} light is OFF")

# ConcreteCommand类：打开灯
class LightOnCommand(Command):
    def __init__(self, light: Light):
        self.light = light

    def execute(self):
        self.light.on()

    def undo(self):
        self.light.off()

# ConcreteCommand类：关闭灯
class LightOffCommand(Command):
    def __init__(self, light: Light):
        self.light = light

    def execute(self):
        self.light.off()

    def undo(self):
        self.light.on()

# Invoker类
class RemoteControl:
    def __init__(self):
        self.slot = None
        self.last_command = None

    def set_command(self, command: Command):
        self.slot = command

    def press_button(self):
        if self.slot:
            self.slot.execute()
            self.last_command = self.slot

    def press_undo(self):
        if self.last_command:
            self.last_command.undo()

# Client代码
def command_pattern_demo():
    remote = RemoteControl()

    living_room_light = Light("Living Room")
    light_on = LightOnCommand(living_room_light)
    light_off = LightOffCommand(living_room_light)

    # 打开灯
    remote.set_command(light_on)
    remote.press_button()

    # 关闭灯
    remote.set_command(light_off)
    remote.press_button()

    # 撤销关闭灯操作
    remote.press_undo()

if __name__ == "__main__":
    command_pattern_demo()

输出：

Living Room light is ON
Living Room light is OFF
Living Room light is ON

说明：

• Light 是接收者，负责执行具体的业务逻辑。

• LightOnCommand 和 LightOffCommand 是具体命令，实现了Command接口，绑定了Light接收者。

• RemoteControl 是调用者，持有命令对象，并在适当的时候调用命令的执行方法。

• command_pattern_demo 函数作为客户端，设置命令对象并发起请求。

6.1. 优点¶

1. 解耦请求的发送者与接收者：发送者无需知道具体的接收者和请求如何被处理，增强了系统的灵活性和可扩展性。

2. 支持请求的撤销和重做：通过记录命令对象，可以方便地实现撤销（Undo）和重做（Redo）功能。

3. 支持请求的队列化、日志记录和事务管理：命令对象可以被存储在队列中或记录到日志，以便后续执行或审计。

4. 增加新命令的灵活性：通过添加新的命令类，可以在不修改现有代码的情况下，增加新的操作。

5. 简化调用者代码：调用者只需持有命令对象并执行，而不需要了解具体的业务逻辑。

6.2. 缺点¶

1. 可能导致系统中类数量增多：每个具体命令都需要一个类，可能导致系统中类的数量快速增加，增加了维护成本。

2. 可能需要额外的存储空间：为了支持撤销和重做，可能需要存储命令对象及其状态，增加了内存开销。

3. 系统复杂性增加：引入命令模式可能使系统的设计变得更加复杂，特别是在处理大量命令对象时。

4. 处理依赖关系：某些命令可能依赖于其他命令的执行顺序，管理这些依赖关系可能较为复杂。

7.1. 误区1：过度使用命令模式¶

问题描述： 有时开发者可能倾向于将所有操作都封装为命令对象，导致系统中充斥着大量的命令类，增加了系统的复杂性和维护成本。

解决方案：

• 评估必要性：仅在需要支持撤销、重做、队列化或日志记录等功能时使用命令模式。

• 适度应用：对于简单的操作或不需要上述功能的场景，避免使用命令模式，以保持系统的简洁性。

7.2. 误区2：忽视命令对象的状态管理¶

问题描述： 命令对象在执行时可能需要持有执行所需的状态信息，忽视对这些状态的管理可能导致命令无法正确执行或撤销。

解决方案：

• 合理设计命令对象：确保命令对象持有执行操作所需的所有状态信息，并提供必要的回退（undo）操作。

• 使用备忘录模式：结合备忘录模式（Memento Pattern）来保存和恢复命令执行前后的状态，支持复杂的撤销操作。

7.3. 误区3：命令模式与其他模式混淆¶

问题描述： 开发者可能将命令模式与其他模式（如策略模式、责任链模式）混淆，导致设计不当。

解决方案：

• 明确模式意图：深入理解每种设计模式的核心意图和适用场景，避免混淆。

• 模式组合使用：在适当的情况下，结合使用多个设计模式，以发挥各自的优势。

8.1. 图形用户界面（GUI）中的按钮点击¶

在GUI应用程序中，每个按钮通常绑定一个特定的操作。通过命令模式，可以将按钮的点击事件封装为命令对象，实现操作的灵活管理和扩展。

示例：

• Command接口：定义按钮点击时执行的操作。

• ConcreteCommand类：实现具体的按钮操作，如打开文件、保存文件等。

• Invoker类：GUI按钮，持有命令对象，并在点击时执行命令。

• Receiver类：实际执行操作的对象，如文件管理器。

8.2. 文本编辑器中的撤销和重做功能¶

在文本编辑器中，用户进行的每一步操作（如输入文本、删除文本、格式化等）都可以被封装为命令对象。通过记录命令对象的执行顺序，可以轻松实现撤销和重做功能。

示例：

• Command接口：定义编辑操作的接口，包括execute()和undo()方法。

• ConcreteCommand类：实现具体的编辑操作，如InsertTextCommand、DeleteTextCommand。

• Invoker类：编辑器的操作历史记录，管理命令的执行和撤销。

• Receiver类：文本文档对象，实际执行编辑操作。

8.3. 远程控制系统¶

在家庭自动化或设备控制系统中，遥控器可以通过命令模式控制各种设备（如灯光、空调、电视等）。每个按钮对应一个命令对象，执行不同的设备操作。

示例：

• Command接口：定义设备操作的接口。

• ConcreteCommand类：实现具体的设备操作，如TurnOnLightCommand、TurnOffACCommand。

• Invoker类：遥控器，持有命令对象，并在按下按钮时执行命令。

• Receiver类：具体的设备对象，如Light、AirConditioner。

8.4. 事务管理系统¶

在需要支持事务性操作的系统中，可以将一系列操作封装为命令对象，并通过命令模式管理事务的提交和回滚。

示例：

• Command接口：定义事务操作的接口，包括execute()和undo()方法。

• ConcreteCommand类：实现具体的事务操作，如DepositCommand、WithdrawCommand。

• Invoker类：事务管理器，管理命令的执行和回滚。

• Receiver类：账户对象，实际执行资金操作。

9.1. 命令模式 vs. 策略模式¶

• 命令模式用于封装请求，将请求转化为对象，支持撤销、重做、日志记录等功能。

• 策略模式用于封装算法，定义一系列算法，并使它们可以互相替换，旨在动态地选择算法。

关键区别：

• 目的不同：命令模式关注请求的封装和管理，策略模式关注算法的封装和选择。

• 结构不同：命令模式的命令对象通常包含执行和撤销操作，策略模式的策略对象只包含算法实现。

9.2. 命令模式 vs. 责任链模式¶

• 命令模式用于封装和执行请求，每个命令对象代表一个具体的操作。

• 责任链模式用于请求的传递和处理，多个处理者依次尝试处理请求。

关键区别：

• 目的不同：命令模式关注请求的封装和执行，责任链模式关注请求的传递和处理。

• 使用场景不同：命令模式适用于需要记录、撤销操作的场景，责任链模式适用于需要多个处理者依次处理请求的场景。

9.3. 命令模式 vs. 观察者模式¶

• 命令模式用于封装和执行请求，使请求发送者与接收者解耦。

• 观察者模式用于建立一对多的依赖关系，当一个对象状态发生变化时，所有依赖者都会收到通知并自动更新。

关键区别：

• 目的不同：命令模式关注请求的封装和执行，观察者模式关注对象状态的同步。

• 结构不同：命令模式通过命令对象管理请求，观察者模式通过观察者和被观察者之间的注册关系管理状态变化。

9.4. 命令模式 vs. 备忘录模式¶

• 命令模式用于封装和执行请求，支持撤销和重做操作。

• 备忘录模式用于保存对象的状态，支持对象状态的恢复。

关键区别：

• 目的不同：命令模式关注请求的封装和管理，备忘录模式关注对象状态的保存和恢复。

• 使用场景不同：命令模式适用于需要撤销、重做的操作，备忘录模式适用于需要保存和恢复对象状态的场景。