一.什么是命令模式？
命令模式，封装了方法调用细节，以解耦请求者与执行者，具体流程如下：
1.从请求者（客户）的角度看
请求者（客户）发出请求 -> 调用者（系统）构造命令对象封装请求 -> 调用者调用命令对象的指定方法（请求被执行）
很明显，请求者根本不知道执行者是谁，更不知道具体执行细节。当然请求者本身也并不关心这些，它只要知道请求被执行了就好。
2.从执行者（低层组件）的角度看
执行者（低层组件）被调用 -> 执行者调用内部方法（请求被执行）
同样的，执行者根本不知道请求者是谁，甚至不清楚调用者，不过没关系，执行者只要本本分分的做好本职工作就好了，没必要知道领导的情况。
3.从调用者（系统）的角度看
接到请求 -> 创建命令对象封装请求 -> 在适当的时候调用命令对象的动作来执行请求（请求被执行）
调用者不知道执行者是谁，也不清楚请求者，它只负责构造命令并控制命令被执行，这就足够了。
从上面可以看出各个对象之间的低耦合关系：
请求者（客户）与执行者（低层组件）被彻底解耦，作为中间人的调用者也不了解请求者与执行者的具体细节，它们被很好的保护了起来
这正是我们想要的。
二.举个例子
现实世界中任何一个稍微复杂的子系统都应当有一套命令，比如餐馆的运行机制：
顾客A来到餐馆点一碗面（发出请求） -> 柜台服务员记录下来（创建命令） -> 服务员把小票扔给厨房 -> 厨师C很快做好了一碗面（请求被执行）
顾客不知道将由谁来做这碗面，柜台服务员也不知道，厨师不知道是谁点了这碗面，只知道做完面就可以休息了
是不是与命令模式很相像？
不妨用代码来实现上面的机制
首先，我们需要一个命令接口，毕竟命令才是命令模式的核心，没有命令，一切都是空想
package CommandPattern;
/**
* @author ayqy
* 定义Command接口
*/
public interface Command {
public abstract void execute();//只需要定义一个统一的执行方法
}
有了命令还需要执行者，否则只有将军没有小兵，餐馆的执行者当然是厨师：
package CommandPattern;
/**
* @author ayqy
* 定义Chef基类
*/
public abstract class Chef {
//在此定义厨师的公共属性
/**
* 定义烹饪方法
*/
public abstract void cook();
//在此定义其它有用的方法
}
我们还需要实现具体的厨师，术业有专攻：
做面的厨师：
package CommandPattern;
/**
* @author ayqy
* 定义专业做面的厨师
*/
public class NoodlesChef extends Chef{
@Override
public void cook() {
System.out.println("做好了一碗美味的拉面");
}
}
做饼的厨师：
package CommandPattern;
/**
* @author ayqy
* 定义专业做饼的厨师
*/
public class PieChef extends Chef{
@Override
public void cook() {
System.out.println("做好了一块香喷喷的大饼");
}
}
有了小兵，有了将军，我们还需要一套完整的命令：
package CommandPattern;
/**
* @author ayqy
* 实现具体NoodlesCommand
*/
public class NoodlesCommand implements Command{
private NoodlesChef chef;//专业做面的厨师
public NoodlesCommand(){
chef = new NoodlesChef();
}
@Override
public void execute() {
chef.cook();
//调用其它需要的方法
}
}
package CommandPattern;
/**
* @author ayqy
* 实现具体PieCommand
*/
public class PieCommand implements Command{
private PieChef chef;//专业做饼的厨师
public PieCommand(){
chef = new PieChef();
}
@Override
public void execute() {
chef.cook();
//调用其它需要的方法
}
}
准备工作做好了，餐馆可以开张了
三.效果示例
需要一个Test类：
package CommandPattern;
/**
* @author ayqy
* 实现测试类
*/
public class Test {
public static void main(String[] args) {
System.out.println("Command Pattern餐馆开张。。");
System.out.println("第一位客户X先生");
System.out.println("X先生：你好，我需要一碗面，我饿极了");
NoodlesCommand nCmd = new NoodlesCommand();
System.out.println("柜台服务员：好的，我已经记下了，马上就好");
System.out.println("柜台服务员：厨房~~,接单");
nCmd.execute();
System.out.println("X先生：真快啊！");
System.out.println();
System.out.println("第二位客户XX先生");
System.out.println("XX先生：你好，我需要一块饼，20分钟后来取");
PieCommand pCmd = new PieCommand();
System.out.println("柜台服务员：好的，我已经记下了");
System.out.println("15分钟后");
System.out.println("柜台服务员：厨房~~,接单");
pCmd.execute();
System.out.println("XX先生：真准时啊！");
}
}
结果示例：
从例子可以看出：
1.调用者（柜台服务员）可以控制具体执行时机，但对具体执行者（厨师）的细节完全不清楚
2.请求者（顾客）完全不知道餐馆的运行机制，不知道点的餐是厨师做的还是服务员做的或者是从隔壁买的。。
3.执行者（厨师）完全不知道请求者的情况，它只做了本职工作，其它的什么都不知道
四.命令模式的扩展
1.宏命令（多条命令顺序执行）
我们可以定义“命令的命令”来实现（这种特殊的命令的execute方法内部是顺序调用其它若干命令的execute方法。。）
2.撤销
假如来了很多顾客，点了很多份餐点，过了一会儿有几个顾客等不及了需要撤销，我们如何实现？
维护一个命令列表，记录已经创建的命令，撤销时需要找到对应的命令，执行撤销操作
当然，前提是命令对象支持撤销，我们需要做一些修改：
package CommandPattern;
/**
* @author ayqy
* 定义Command接口
*/
public interface Command {
public abstract void execute();//只需要定义一个统一的执行方法
public abstract void undo();//定义统一的撤销方法
}
各个命令的撤销操作可能不同，因此定义为抽象方法，由子类来实现具体操作
*如何支持多步顺序撤销？
餐馆的例子可能不需要这样的功能，不妨想想另一个情景，文本编辑器
用户发出了一系列命令，完成了一些列操作，后来发现并不需要这样做，用户会撤销修改（Ctrl + Z），这时我们需要执行相反的操作对内容作以还原，要如何实现？
还是要先实现各个命令的undo行为（执行与execute相反顺序的操作即可），除此之外，我们还需要一个栈来记录已经被执行过的操作，以支持撤销到初始状态
3.队列请求
我们可以建立一个工作线程，负责所有运算，想象有一个通道，输入是一条条不同命令，输出是命令的执行结果
可能上一刻工作线程在做大饼，下一刻已经出去买菜了。。
*这样做有什么好处？
可以把运算限制在指定的几个线程中，加以控制
4.日志请求
多用于数据库管理系统的实现，我们需要把一系列的操作记录下来（如写在硬盘上），在遇到系统故障时读出来以恢复数据，如何实现？
利用对象的序列化把对象保存起来（记录日志），在需要的时候反序列化（恢复事务）
五.总结
命令模式可以有效地解耦请求者与执行者，还可以提供一些额外的好处（比如支持撤销操作、队列请求、记录日志等等）