编程模式·命令模式

将函数调用封装成命令对象，从而支持各种后续管理：传递，保存，延后处理，撤销重做等

---

经典命令模式解析

命令模式的5个角色：

1. Command：命令接口，定义execute/undo之类的接口方法。
2. ConcreteCommand：具体的命令，实现命令接口。调用Receiver执行具体命令，也可以直接执行命令。
3. Receiver：接收者，命令的实际执行者。
4. Invoker：请求者，持有命令对象，要求命令对象执行请求。
5. Client：创建命令对象，设置命令对象的接受者，把命令对象添加给请求者。驱动Invoker执行请求。

命令模式的UML图

伪代码例子：

// 命令接口
interface Command{
    execute();
}
// 具体action命令
class ConcreteCommandAction : Command{
   receiver = null; 
   _construct(Receiver receiver){
        this.receiver = receiver;
   }
   execute(){
        this.receiver->action();
   }
}
// 接收者
class Reveiver{
    action(){
        // do some action
    }
}
// 请求者
class Invoker{
    command = null;
    setCommand(Command command){
        this.command = command;    
    }
    runCommand(){
       this.command->execute(); 
    }
}
// 客户端组装调用
client(){
    receiver = getRecevier();
    command = new ConcreteCommandAction(receiver);
    invoker = getInvoker();
    invoker->seCommand(command);
    invoker->runCommand();
}

上面一堆代码实现了：请求receiver执行action。等效代码如下：

client(){
    recevier = getReceiver();
    receiver->action();
}

这。。。

---

对命令模式的简单分析

封装调用，完成解耦

ConcreteCommandAction封装了action的调用，invoker与recevier完全解耦了。
封装调用，这个大家都喜欢用。一般用到第三方库时，会针对性的做一层封装，统一逻辑，简化接口，屏蔽细节。这在多平台适配时几乎是必须的。

增加命令很方便

如果我们要给Receiver增加新的行为。

1. 简单实现：修改Receiver的定义，增加新的方法。（违反关闭原则，Reveiver会越来越大）
2. 命令模式：新加命令，在execute里实现新的行为。（当然新的行为要能使用Receiver的公开接口组合实现）

如：加个新行为，按需执行action多次，可以定义个新的Command

class ConcreteCommandRepeatAction : Command{
   receiver = null; 
   times = 0;// 执行次数
   _construct(Receiver receiver, int times){
        this.receiver = receiver;
        this.times = times;
   }
   execute(){
        while(times > 0){
            this.receiver->action();
            this.times -= 1;
        }
   }
}

这个很有诱惑力，相当于不改类定义，而给类增加新的方法。
一个极端的例子，Recevier就是个数据结构，每个具体命令操作Recevier的数据。
相当于把数据和操作分离，然后按需组合成为想要的对象。（好像面向对象就是为了把数据和操作组合在一起的）

函数调用封装成命令对象

简单的调用被封装成命令对象后，有了自己的生命周期。这个有需要好处。

1. 可以暂存下来，延后调用。
   像网络请求这类情景，经常请求转换成命令对象，在单独的线程里排队执行。
2. 可以序列化成数据，进行网络传送，录像保存。
   帧同步游戏的网络同步和录像保存就可以这样实现。
3. 方便管理，很容易实现撤销和重做。

简单实现撤销和重做

修改下接口Command

interface Command{
    execute();
    undo();
    redo();
}

保存命令成队列，设置记录当前命令index

// 撤销
command_queue[index--].undo();
// 重做
command_queue[index++].redo();

---

使用小结

模式的重点：

1. 对函数调用做封装，完成解耦。
2. 把函数调用转换成命令对象，相当于把调用执行转换成数据指令，方便后续各种管理。

不要使用的情况：

1. 如果只是要解耦下，做一层调用封装就行了。
2. 想要扩展命令，多定义几个调用分装也就行了。
3. 如果是立即调用执行，没必要转成命令模式使用。

使用的情况：只在有后续管理需求时使用

1. 需要延后调用，如网络请求，文件加载等耗时长的任务。使用异步线程处理命令队列比较好。
2. 需要保存，做分发传输记录。
3. 需要撤销重做的功能。