模式定义

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

类图

命令模式类图

Command：用来声明执行操作的接口。

abstract class Command {

    Receiver receiver;

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

    abstract void execute();
}

ConcreteCommand：将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现Execute。

class ConcreteCommand extends Command {

    public ConcreteCommand(Receiver receiver){
        super(receiver);
    }

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

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

class Invoker {

    Command command;

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

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

Receiver：知道如何实施与执行一个与请求相关的操作，任何类都可能作为一个接收者。

class Receiver {
    
    public void action(){
        System.out.println("执行请求！");
    }
    
}

客户端代码：

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

    invoker.setCommand(command);
    invoker.ExecuteCommand();
}

撤销和重做

如果需要有命令撤销和重做，Command接口不止需要execute()方法，还要有undo()方法。

abstract class Command {

    //执行命令和重做
    abstract void execute();

    //撤销
    abstract void undo();

}

如果需要实现多次撤销重做，需要调用方维护undo和redo两个盛放Command的栈（用List实现），首次执行一个Command时，执行execute()并将其放入undo栈内，同时要清空redo栈；当执行撤销操作时把undo栈内最上面一个Command拿出来执行undo()，然后将其放入redo栈内；执行重做操作时把redo栈内最上面一个Command拿出来执行execute()，然后将其放入undo栈内。

示例代码：

class Invoker {

    //可撤销的步数
    int undoCount;

    List<Command> undoList = new ArrayList();
    List<Command> redoList = new ArrayList();

    public Invoker(){
        undoCount = 5;
    }

    /**
     * 执行新操作
     * @param command
     */
    public void executeCommand(Command command){
        
        command.execute();

        //保留最近undoCount次操作，删除最早操作
        if (undoList.size() >= undoCount){
            undoList.remove(0);
        }

        undoList.add(command);

        //执行新操作后清空redoList，因为这些操作不能恢复了
        redoList.clear();
    }

    /**
     * 执行撤销
     */
    public void undo(){
        if (undoList.size() <= 0){
            return;
        }

        //undoList中出栈第一个执行
        Command command = undoList.get(undoList.size() - 1);
        command.undo();

        undoList.remove(command);
        redoList.add(command);
    }

    /**
     * 执行重做
     */
    public void redo(){
        if (redoList.size() <= 0){
            return;
        }

        //redoList中出栈第一个执行
        Command command = redoList.get(redoList.size() - 1);
        command.execute();

        redoList.remove(command);
        undoList.add(command);

    }
    
}

如果命令栈中存放很多Command对象会占用大量内存，所以用undoCount做限制。

应用场景

系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
系统需要在不同的时间指定请求、将请求排队和执行请求。
系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。
系统需要将一组操作组合在一起，即支持宏命令。

优缺点

优点

降低对象之间的耦合度。
新的命令可以很容易地加入到系统中。
可以比较容易地设计一个组合命令。

缺点

使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类。

JDK中的命令模式

java.lang.Runnable

看下示例代码

MyRunnable：

class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("开始执行");
    }
}

main:

public static void main(String[] args) {
    //相当与命令模式的Command command = new ConcreteCommand();
    MyRunnable myRunnable = new MyRunnable();

    //相当与命令模式的new Invoker()后执行invoker.setCommand(command)
    Thread thread = new Thread(myRunnable);
    thread.start();
}

这段代码中，

Runnable相当于抽象命令接口Command，run()方法相当于Command的execute()；

MyRunnable对象相当于具体命令对象ConcreteCommand；

Thread对象对应命令模式的Invoker,new Thread(myRunnable)相当于通过setCommand方法传入命令对象。

你可能会说没有找到Receiver，因为MyRunnable已经拥有要执行的具体逻辑了，这里不需要接收者。