1.命令模式定义
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
2.模式结构和说明
Command：
定义命令的接口，声明执行的方法。
ConcreteCommand：
命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
Receiver：
接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
Invoker：
要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
Client：
创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。
3.命令模式示例代码
（1）先来看看命令接口的定义，示例代码如下：
/**
* 命令接口，声明执行的操作
*/
public interface Command {
/**
* 执行命令对应的操作
*/
public void execute();
}（2）再来看看具体的命令实现对象，示例代码如下：
/**
* 具体的命令实现对象
*/
public class ConcreteCommand implements Command {
/**
* 持有相应的接收者对象
*/
private Receiver receiver = null;
/**
* 示意，命令对象可以有自己的状态
*/
private String state;
/**
* 构造方法，传入相应的接收者对象
* @param receiver 相应的接收者对象
*/
public ConcreteCommand(Receiver receiver){
this.receiver = receiver;
}
public void execute() {
//通常会转调接收者对象的相应方法，让接收者来真正执行功能
receiver.action();
}
}（3）再来看看接收者对象的实现示意，示例代码如下：
/**
* 接收者对象
*/
public class Receiver {
/**
* 示意方法，真正执行命令相应的操作
*/
public void action(){
//真正执行命令操作的功能代码
}
}（4）接下来看看Invoker对象，示例代码如下：
/**
* 调用者
*/
public class Invoker {
/**
* 持有命令对象
*/
private Command command = null;
/**
* 设置调用者持有的命令对象
* @param command 命令对象
*/
public void setCommand(Command command) {
this.command = command;
}
/**
* 示意方法，要求命令执行请求
*/
public void runCommand() {
//调用命令对象的执行方法
command.execute();
}
}（5）再来看看Client的实现， 注意这个不是我们通常意义上的测试客户端，主要功能是要创建命令对象并设定它的接收者，因此这里并没有调用执行的代码，示例代码如下：
public class Client {
/**
* 示意，负责创建命令对象，并设定它的接收者
*/
public void assemble(){
//创建接收者
Receiver receiver = new Receiver();
//创建命令对象，设定它的接收者
Command command = new ConcreteCommand(receiver);
//创建Invoker，把命令对象设置进去
Invoker invoker = new Invoker();
invoker.setCommand(command);
}
}4.电脑开机示例
电脑开机主要就这么几个步骤：首先加载电源，然后是设备检查，再然后是装载系统，最后电脑就正常启动了。可是谁来完成这些过程？如何完成？
从客户的角度来看，开机就是按下按钮，不管什么样的主板都是一样的，也就是说，客户只管发出命令，谁接收命令，谁实现命令，如何实现，客户是不关心的
问题抽象描述：客户端只是想要发出命令或者请求，不关心请求的真正接收者是谁，也不关心具体如何实现，而且同一个请求的动作可以有不同的请求内容，当然具体的处理功能也不一样，请问该怎么实现？
示例的结构:
示例代码:
（1）定义主板
根据前面的描述，我们会发现，真正执行客户命令或请求的是主板，也只有主板才知道如何去实现客户的命令，因此先来抽象主板，把它用对象描述出来。
先来定义主板的接口，最起码主板会有一个能开机的方法，示例代码如下：
/**
* 主板的接口
*/
public interface MainBoardApi {
/**
* 主板具有能开机的功能
*/
public void open();
}定义了接口，那就接着定义实现类吧，定义两个主板的实现类，一个是技嘉主板，一个是微星主板，现在的实现是一样的，但是不同的主板对同一个命令的操作可以是不同的，这点大家要注意。由于两个实现基本一样，就示例一个，示例代码如下：
/**
* 技嘉主板类，开机命令的真正实现者，在Command模式中充当Receiver
*/
public class GigaMainBoard implements MainBoardApi{
/**
* 真正的开机命令的实现
*/
public void open(){
System.out.println("技嘉主板现在正在开机，请等候");
System.out.println("接通电源......");
System.out.println("设备检查......");
System.out.println("装载系统......");
System.out.println("机器正常运转起来......");
System.out.println("机器已经正常打开，请操作");
}
} 微星主板的实现和这个完全一样，只是把技嘉改名成微星了。
（2）定义命令接口和命令的实现
对于客户来说，开机就是按下按钮，别的什么都不想做。把用户的这个动作抽象一下，就相当于客户发出了一个命令或者请求，其它的客户就不关心了。为描述客户的命令，现定义出一个命令的接口，里面只有一个方法，那就是执行，示例代码如下：
/**
* 命令接口，声明执行的操作
*/
public interface Command {
/**
* 执行命令对应的操作
*/
public void execute();
}有了命令的接口，再来定义一个具体的实现，其实就是模拟现实中机箱上按钮的功能，因为我们按下的是按钮，但是按钮本身是不知道如何启动电脑的，它需要把这个命令转给主板，让主板去真正执行开机功能。示例代码如下：
/**
* 开机命令的实现，实现Command接口，
* 持有开机命令的真正实现，通过调用接收者的方法来实现命令
*/
public class OpenCommand implements Command{
/**
* 持有真正实现命令的接收者——主板对象
*/
private MainBoardApi mainBoard = null;
/**
* 构造方法，传入主板对象
* @param mainBoard 主板对象
*/
public OpenCommand(MainBoardApi mainBoard) {
this.mainBoard = mainBoard;
}
public void execute() {
//对于命令对象，根本不知道如何开机，会转调主板对象
//让主板去完成开机的功能
this.mainBoard.open();
}
} 由于客户不想直接和主板打交道，而且客户根本不知道具体的主板是什么，客户只是希望按下启动按钮，电脑就正常启动了，就这么简单。就算换了主板，客户还是一样的按下启动按钮就可以了。
换句话说就是：客户想要和主板完全解耦，怎么办呢？
这就需要在客户和主板之间建立一个中间对象了，客户发出的命令传递给这个中间对象，然后由这个中间对象去找真正的执行者——主板，来完成工作。
很显然，这个中间对象就是上面的命令实现对象，请注意：这个实现其实是个虚的实现，真正的实现是主板完成的，在这个虚的实现里面，是通过转调主板的功能来实现的，主板对象实例，是从外面传进来的。
（3）提供机箱
客户需要操作按钮，按钮是放置在机箱之上的，所以需要把机箱也定义出来，示例代码如下：
/**
* 机箱对象，本身有按钮，持有按钮对应的命令对象
*/
public class Box {
/**
* 开机命令对象
*/
private Command openCommand;
/**
* 设置开机命令对象
* @param command 开机命令对象
*/
public void setOpenCommand(Command command){
this.openCommand = command;
}
/**
* 提供给客户使用，接收并响应用户请求，相当于按钮被按下触发的方法
*/
public void openButtonPressed(){
//按下按钮，执行命令
openCommand.execute();
}
}（4）客户使用按钮
抽象好了机箱和主板，命令对象也准备好了，客户想要使用按钮来完成开机的功能，在使用之前，客户的第一件事情就应该是把按钮和主板组装起来，形成一个完整的机器。
在实际生活中，是由装机工程师来完成这部分工作，这里为了测试简单，直接写在客户端开头了。机器组装好过后，客户应该把与主板连接好的按钮对象放置到机箱上，等待客户随时操作。把这个过程也用代码描述出来，示例代码如下:
public class Client {
public static void main(String[] args) {
//1：把命令和真正的实现组合起来，相当于在组装机器，
//把机箱上按钮的连接线插接到主板上。
MainBoardApi mainBoard = new GigaMainBoard();
OpenCommand openCommand = new OpenCommand(mainBoard);
//2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
Box box = new Box();
box.setOpenCommand(openCommand);
//3：然后模拟按下机箱上的按钮
box.openButtonPressed();
}
}你可以给命令对象组装不同的主板实现类，然后再次测试，看看效果。
技嘉主板现在正在开机，请等候 接通电源...... 设备检查...... 装载系统...... 机器正常运转起来...... 机器已经正常打开，请操作
事实上，你会发现，如果对象结构已经组装好了过后，对于真正的客户端，也就是真实的用户而言，任务就是面对机箱，按下机箱上的按钮，就可以执行开机的命令了，实际生活中也是这样的。
（5）小结
如同前面的示例，把客户的开机请求封装成为一个OpenCommand对象，客户的开机操作就变成了执行OpenCommand对象的方法了？如果还有其它的命令对象，比如让机器重启的ResetCommand对象；那么客户按下按钮的动作，就可以用这不同的命令对象去匹配，也就是对客户进行参数化。
用大白话描述就是：客户按下一个按钮，到底是开机还是重启，那要看参数化配置的是哪一个具体的按钮对象，如果参数化的是开机的命令对象，那就执行开机的功能，如果参数化的是重启的命令对象，那就执行重启的功能。虽然按下的是同一个按钮，但是请求是不同的，对应执行的功能也就不同了。
所谓命令模式的参数化配置，指的是：可以用不同的命令对象，去参数化配置客户的请求。
像前面描述的那样：客户按下一个按钮，到底是开机还是重启，那要看参数化配置的是哪一个具体的按钮对象，如果参数化的是开机的命令对象，那就执行开机的功能，如果参数化的是重启的命令对象，那就执行重启的功能。虽然按下的是同一个按钮，相当于是同一个请求，但是为请求配置不同的按钮对象，那就会执行不同的功能。
把这个功能用代码实现出来，一起来体会一下命令模式的参数化配置。
（1）同样先定义主板接口吧，现在想要添加一个重启的按钮，因此主板需要添加一个方法来实现重启的功能，示例代码如下：
/**
* 主板的接口
*/
public interface MainBoardApi {
/**
* 主板具有能开机的功能
*/
public void open();
/**
* 主板具有实现重启的功能
*/
public void reset();
}接口发生了改变，实现类也得有相应的改变，由于两个主板的实现示意差不多，因此还是只示例一个，示例代码如下
/**
* 技嘉主板类，命令的真正实现者，在Command模式中充当Receiver
*/
public class GigaMainBoard implements MainBoardApi{
/**
* 真正的开机命令的实现
*/
public void open(){
System.out.println("技嘉主板现在正在开机，请等候");
System.out.println("接通电源......");
System.out.println("设备检查......");
System.out.println("装载系统......");
System.out.println("机器正常运转起来......");
System.out.println("机器已经正常打开，请操作");
}
/**
* 真正的重新启动机器命令的实现
*/
public void reset(){
System.out.println("技嘉主板现在正在重新启动机器，请等候");
System.out.println("机器已经正常打开，请操作");
}
}（2）该来定义命令和按钮了，命令接口没有任何变化，原有的开机命令的实现也没有任何变化，只是新添加了一个重启命令的实现，示例代码如下：
/**
* 重启机器命令的实现，实现Command接口，
* 持有重启机器命令的真正实现，通过调用接收者的方法来实现命令
*/
public class ResetCommand implements Command{
/**
* 持有真正实现命令的接收者——主板对象
*/
private MainBoardApi mainBoard = null;
/**
* 构造方法，传入主板对象
* @param mainBoard 主板对象
*/
public ResetCommand(MainBoardApi mainBoard) {
this.mainBoard = mainBoard;
}
public void execute() {
//对于命令对象，根本不知道如何重启机器，会转调主板对象
//让主板去完成重启机器的功能
this.mainBoard.reset();
}
}（3）持有命令的机箱也需要修改，现在不只一个命令按钮了，有两个了，所以需要在机箱类里面新添加重启的按钮，为了简单，没有做成集合。示例代码如下：
/**
* 机箱对象，本身有按钮，持有按钮对应的命令对象
*/
public class Box {
private Command openCommand;
public void setOpenCommand(Command command){
this.openCommand = command;
}
public void openButtonPressed(){
//按下按钮，执行命令
openCommand.execute();
}
/**
* 重启机器命令对象
*/
private Command resetCommand;
/**
* 设置重启机器命令对象
* @param command
*/
public void setResetCommand(Command command){
this.resetCommand = command;
}
/**
* 提供给客户使用，接收并相应用户请求，相当于重启按钮被按下触发的方法
*/
public void resetButtonPressed(){
//按下按钮，执行命令
resetCommand.execute();
}
}（4）看看客户如何使用这两个按钮，示例代码如下:
public class Client {
public static void main(String[] args) {
//1：把命令和真正的实现组合起来，相当于在组装机器，
//把机箱上按钮的连接线插接到主板上。
MainBoardApi mainBoard = new GigaMainBoard();
//创建开机命令
OpenCommand openCommand = new OpenCommand(mainBoard);
//创建重启机器的命令
ResetCommand resetCommand = new ResetCommand(mainBoard);
//2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
Box box = new Box();
//先正确配置，就是开机按钮对开机命令，重启按钮对重启命令
box.setOpenCommand(openCommand);
box.setResetCommand(resetCommand);
//3：然后模拟按下机箱上的按钮
System.out.println("正确配置下------------------------->");
System.out.println(">>>按下开机按钮：>>>");
box.openButtonPressed();
System.out.println(">>>按下重启按钮：>>>");
box.resetButtonPressed();
//然后来错误配置一回，反正是进行参数化配置
//就是开机按钮对重启命令，重启按钮对开机命令
box.setOpenCommand(resetCommand);
box.setResetCommand(openCommand);
//4：然后还是来模拟按下机箱上的按钮
System.out.println("错误配置下------------------------->");
System.out.println(">>>按下开机按钮：>>>");
box.openButtonPressed();
System.out.println(">>>按下重启按钮：>>>");
box.resetButtonPressed();
}
}运行一下看看，很有意思，结果如下：
命令模式的优缺点
更松散的耦合
命令模式使得发起命令的对象——客户端，和具体实现命令的对象——接收者对象完全解耦，也就是说发起命令的对象，完全不知道具体实现对象是谁，也不知道如何实现。
更动态的控制
命令模式把请求封装起来，可以动态对它进行参数化、队列化和日志化等操作，从而使得系统更灵活。
能很自然的复合命令
命令模式中的命令对象，能够很容易的组合成为复合命令，就是前面讲的宏命令，从而使系统操作更简单，功能更强大。
更好的扩展性
由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象里面，然后就可以使用这个命令对象，已有的实现完全不用变化。
1：命令模式的本质
命令模式的本质：封装请求。
前面讲了，命令模式的关键就是把请求封装成为命令对象，然后就可以对这个对象进行一系列的处理了，比如上面讲到的参数化配置、可撤销操作、宏命令、队列请求、日志请求等功能处理。
2：何时选用命令模式
建议在如下情况中，选用命令模式：
如果需要抽象出需要执行的动作，并参数化这些对象，可以选用命令模式，把这些需要执行的动作抽象成为命令，然后实现命令的参数化配置
如果需要在不同的时刻指定、排列和执行请求，可以选用命令模式，把这些请求封装成为命令对象，然后实现把请求队列化
如果需要支持取消操作，可以选用命令模式，通过管理命令对象，能很容易的实现命令的恢复和重做的功能
如果需要支持当系统崩溃时，能把对系统的操作功能重新执行一遍，可以选用命令模式，把这些操作功能的请求封装成命令对象，然后实现日志命令，就可以在系统恢复回来后，通过日志获取命令列表，从而重新执行一遍功能
在需要事务的系统中，可以选用命令模式，命令模式提供了对事务进行建模的方法，命令模式有一个别名就是Transaction。
在领会了命令模式本质后，来思考一个命令模式退化的情况。
前面讲到了智能命令，如果命令的实现对象超级智能，实现了命令所要求的功能，那么就不需要接收者了，既然没有了接收者，那么也就不需要组装者了。
（1）举个最简单的示例来说明
比如现在要实现一个打印服务，由于非常简单，所以基本上就没有什么讲述，依次来看，命令接口定义如下：
public interface Command {
public void execute();
}命令的实现示例代码如下：
public class PrintService implements Command{
/**
* 要输出的内容
*/
private String str = "";
/**
* 构造方法，传入要输出的内容
* @param s 要输出的内容
*/
public PrintService(String s){
str = s;
}
public void execute() {
//智能的体现，自己知道怎么实现命令所要求的功能，并真的实现了相应的功能，不再转调接收者了
System.out.println("打印的内容为="+str);
}
}此时的Invoker示例代码如下：
public class Invoker {
/**
* 持有命令对象
*/
private Command cmd = null;
/**
* 设置命令对象
* @param cmd 命令对象
*/
public void setCmd(Command cmd){
this.cmd = cmd;
}
/**
* 开始打印
*/
public void startPrint(){
//执行命令的功能
this.cmd.execute();
}
}最后看看客户端的代码，示例如下：
public class Client {
public static void main(String[] args) {
//准备要发出的命令
Command cmd = new PrintService("退化的命令模式示例");
//设置命令给持有者
Invoker invoker = new Invoker();
invoker.setCmd(cmd);
//按下按钮，真正启动执行命令
invoker.startPrint();
}
}测试结果如下：
打印的内容为=退化的命令模式示例
（2）继续变化
如果此时继续变化，Invoker也开始变得智能化，在Invoker的startPrint方法里面，Invoker加入了一些实现，同时Invoker对持有命令也有意见，觉得自己是个傀儡，要求改变一下，直接在调用方法的时候传递命令对象进来，示例代码如下：
public class Invoker {
public void startPrint(Command cmd){
System.out.println("在Invoker中，输出服务前");
cmd.execute();
System.out.println("输出服务结束");
}
}看起来Invoker退化成一个方法了。
这个时候Invoker很高兴，宣称自己是一个智能的服务，不再是一个傻傻的转调者，而是有自己功能的服务了。这个时候Invoker调用命令对象的执行方法，也不叫转调，改名叫“回调”，意思是在我Invoker需要的时候，会回调你命令对象，命令对象你就乖乖的写好实现，等我“回调”你就可以了。
事实上这个时候的命令模式的实现，基本上就等同于Java回调机制的实现，可能有些朋友看起来感觉还不是佷像，那是因为在Java回调机制的常见实现上，经常没有单独的接口实现类，而是采用匿名内部类的方式来实现的。
（3）再进一步
把单独实现命令接口的类改成用匿名内部类实现，这个时候就只剩下命令的接口、Invoker类，还有客户端了。
为了使用匿名内部类，还要设置要输出的值，对命令接口做点小改动，增加一个设置输出值的方法，示例代码如下：
public interface Command {
public void execute();
/**
* 设置要输出的内容
* @param s 要输出的内容
*/
public void setStr(String s);
}此时Invoker就是上面那个，而客户端会有些改变，客户端的示例代码如下：
public class Client {
public static void main(String[] args) {
//准备要发出的命令，没有具体实现类了
//匿名内部类来实现命令
Command cmd = new Command(){
private String str = "";
public void setStr(String s){
str = s;
}
public void execute() {
System.out.println("打印的内容为="+str);
}
};
cmd.setStr("退化的命令模式类似于Java回调的示例");
//这个时候的Invoker或许该称为服务了
Invoker invoker = new Invoker();
//按下按钮，真正启动执行命令
invoker.startPrint(cmd);
}
}运行测试一下，结果如下：
在Invoker中，输出服务前 打印的内容为=退化的命令模式类似于Java回调的示例 输出服务结束
（4）现在是不是看出来了，这个时候的命令模式的实现，基本上就等同于Java回调机制的实现。这也是很多人大谈特谈命令模式可以实现Java回调的意思。
当然更狠的是连Invoker也不要了，直接把那个方法搬到Client中，那样测试起来就更方便了。在实际开发中，应用命令模式来实现回调机制的时候，Invoker通常还是有的，但可以智能化实现，更准确的说Invoker充当客户调用的服务实现，而回调的方法只是实现服务功能中的一个或者几个步骤。
命令模式和组合模式
这两个模式可以组合使用。
在命令模式中，实现宏命令的功能，就可以使用组合模式来实现。前面的示例并没有按照组合模式来做，那是为了保持示例的简单，还有突出命令模式的实现，这点请注意。
命令模式和备忘录模式
这两个模式可以组合使用。
在命令模式中，实现可撤销操作功能时，前面讲了有两种实现方式，其中有一种就是保存命令执行前的状态，撤销的时候就把状态恢复回去。如果采用这种方式实现，就可以考虑使用备忘录模式。
如果状态存储在命令对象里面，那么还可以使用原型模式，把命令对象当作原型来克隆一个新的对象，然后把克隆出来的对象通过备忘录模式存放。
命令模式和模板方法模式
这两个模式从某种意义上有相似的功能，命令模式可以作为模板方法的一种替代模式，也就是说命令模式可以模仿实现模板方法模式的功能。
如同前面讲述的退化的命令模式可以实现Java的回调，而Invoker智能化后向服务进化，如果Invoker的方法就是一个算法骨架，其中有两步在这个骨架里面没有具体实现，需要外部来实现，这个时候就可以通过回调命令接口来实现。
而类似的功能在模板方法里面，一个算法骨架，其中有两步在这个骨架里面没有具体实现，是先调用抽象方法，然后等待子类来实现。
可以看出虽然实现方式不一样，但是可以实现相同的功能。
转载至:http://sishuok.com/forum/blogPost/list/97.html
本文出自 “ciyo技术分享” 博客，请务必保留此出处http://ciyorecord.blog.51cto.com/6010867/1945508
原文地址：http://ciyorecord.blog.51cto.com/6010867/1945508
