15 命令模式

定义

命令模式（Command Pattern）：将一个请求封装为一个对象，从而可用不同的请求对客户端进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。

结构

1. Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接受者的相关操作。
2. ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接受者对象的动作绑定其中。具体命令类在实现execute()方法时将调用接收者对象的相关操作(Action)。
3. Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。
4. Receiver（接收者）：接收者执行与请求相关的操作，具体实现对请求的业务处理。

代码

Command

public abstract class Command {

    public abstract void execute();

}

Receiver

public class Receiver {

    public void action() {
        // 具体操作
        System.out.println("action");
    }

}

ConcreteCommand

public class ConcreteCommand extends Command {

    private Receiver receiver;

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

    @Override
    public void execute() {
        receiver.action();
    }

}

Invoker

public class Invoker {

    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    // 业务方法，用于调用命令类的execute()
    public void call() {
        command.execute();
    }

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

}

Test

public class Test {

    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker(command);
        invoker.call();
    }

}

时间命令队列

有时候，当一个请求发送者发送一个请求时有不止一个请求接收者产生响应，这些请求接收者将逐个执行业务方法，完成对请求的处理，此时可以通过命令队列来实现。

CommandQueue：命令队列

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

public class CommandQueue {
    
    /** 定义一个List来存储命令队列 */
    private List<Command> commandList = new ArrayList<>();
    
    public void addCommand(Command command) {
        commandList.add(command);
    }
    
    public void removeCommand(Command command) {
        commandList.remove(command);
    }
    
    public void execue() {
        // 循环调用
        commandList.forEach(Command::execute);
    }
    
}

Invoker:请求发送者

public class Invoker1 {

    // 维持一个命令队列的引用
    private CommandQueue commandQueue;

    // 构造注入
    public Invoker1(CommandQueue commandQueue) {
        this.commandQueue = commandQueue;
    }

    // 调用
    public void call() {
        commandQueue.execue();
    }

}

实现撤销操作

在命令模式中可以通过对命令类进行修改使得系统支持（Undo）操作和恢复（Redo）操作，下面通过一个简单实例来学习如何使用命令模式中实现撤销操作。

设计一个简易计算器，该计算器可以实现简单的数学操作，还可以对运算结果实施撤销操作。

Adder充当请求接收者

public class Adder {

    private int num;

    // 实现加法操作
    public int add(int value) {
        num += value;
        return num;
    }

}

AbstractCommand充当抽象命令，声明了execute()和撤销undo()

public abstract class AbstractorCommand {

    // 执行方法
    public abstract int execute(int value);
    // 撤销
    public abstract int undo();

}

AddCommand充当具体抽象类

public class AddCommand extends AbstractorCommand {

    private Adder adder = new Adder();
    private int value;

    // 调用加法类的加法操作
    @Override
    public int execute(int value) {
        this.value = value;
        return adder.add(value);
    }

    // 加一个相反数实现加法的逆向操作
    @Override
    public int undo() {
        return adder.add(-value);
    }

}

CalculatorForm充当请求发送者

public class CalculatorForm {

    private AbstractorCommand command;

    public CalculatorForm(AbstractorCommand command) {
        this.command = command;
    }

    // 调用命令对象的execute()方法执行运算
    public void compute(int value) {
        int i = command.execute(value);
        System.out.println("运算结果:" + i);
    }

    public void undo() {
        int i = command.undo();
        System.out.println("撤销操作，结果：" + i);
    }

}

客户端调用

public class Client {

    public static void main(String[] args) {
        AbstractorCommand command = new AddCommand();
        CalculatorForm form = new CalculatorForm(command);
        form.compute(10);
        form.compute(5);
        form.compute(10);
        form.undo();
    }

}

运行结果

运算结果:10
运算结果:15
运算结果:25
撤销操作，结果：15

优/缺点与适用环境

1. 优点

• 降低系统的耦合度。由于请求者与接收者之间不存在直接引用，因此请求者与接收者之间实现完全解耦，相同的请求者可以对应不同的接收者，同样相同的接收者也可以供不同的请求者使用，两者之间具有良好的独立性。
• 新的命令可以很容易地加入到系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码，满足开闭原则的要求。
• 可以较容易地设计一个命令队列或宏命令（组合命令）。
• 为请求的撤销（Undo）和恢复（Redo）操作提供了一种设计和实现方案。

2. 缺点

• 使用命令模式可能会导致系统有过多的具体命令类。因此针对每一请求接收者的调用操作都需要设计一个具体命令类，所以在某些系统中可能需要提供大量的具体命令类，这会影响命令模式的使用。

3. 适用环境

• 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。请求调用者无需知道接收者的存在，与无序知道接收者是谁，接收者也无须关心何时被调用。
• 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象的请求的初始调用者可以有不同的生命周期，换而言之，最初的请求发送者可能已经不在了，而命令对象本身仍然是活动的，可以通过该命令对象去调用请求接收者，而且无需关心请求调用者的存在性，可以通过请求日志文件等机制来实现具体操作。
• 系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作
• 系统需要将一组操作组合在一起形成宏命令。