设计模式之命令模式（Command Pattern）

一.什么是命令模式？

命令模式，封装了方法调用细节，以解耦请求者与执行者，具体流程如下：

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.日志请求

多用于数据库管理系统的实现，我们需要把一系列的操作记录下来（如写在硬盘上），在遇到系统故障时读出来以恢复数据，如何实现？

利用对象的序列化把对象保存起来（记录日志），在需要的时候反序列化（恢复事务）

五.总结

命令模式可以有效地解耦请求者与执行者，还可以提供一些额外的好处（比如支持撤销操作、队列请求、记录日志等等）