常用设计者模式---命令模式

1、定义：将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

类型：行为类模式/

2、类图：

3、命令模式的结构
顾名思义，命令模式就是对命令的封装，首先来看一下命令模式类图中的基本结构：
Command类：是一个抽象类，类中对需要执行的命令进行声明，一般来说要对外公布一个execute方法用来执行命令。
ConcreteCommand类：Command类的实现类，对抽象类中声明的方法进行实现。
Client类：最终的客户端调用类。

 以上三个类的作用应该是比较好理解的，下面我们重点说一下Invoker类和Recevier类。
Invoker类：调用者，负责调用命令。
Receiver类：接收者，负责接收命令并且执行命令。

命令模式的本质是对请求进行封装，一个请求对应于一个命令，将发出命令的责任和执行命令的责任分割开。每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行相应的操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求如何被接收、操作是否被执行、何时被执行，以及是怎么被执行的。
 命令模式的关键在于引入了抽象命令类，请求发送者针对抽象命令类编程，只有实现了抽象命令类的具体命令才与请求接收者相关联。在最简单的抽象命令类中只包含了一个抽象的execute()方法，每个具体命令类将一个Receiver类型的对象作为一个实例变量进行存储，从而具体指定一个请求的接收者，不同的具体命令类提供了execute()方法的不同实现，并调用不同接收者的请求处理方法。

4、命令模式的适用场景：对于大多数请求-响应模式的功能，比较适合使用命令模式，正如命令模式定义说的那样，命令模式对实现记录日志、撤销操作等功能比较方便。

5、命令模式的优缺点
 优点
1.降低对象之间的耦合度。
2.新的命令可以很容易地加入到系统中。
3.可以比较容易地设计一个组合命令。
4.调用同一方法实现不同的功能

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

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

6、简单应用（模拟对电视机的操作有开机、关机、换台命令。代码如下）

//执行命令的接口public interface Command {　　void execute();}

//命令接收者Receiverpublic class Tv {　　public int currentChannel = 0;　　public void turnOn() {　　   System.out.println("The televisino is on.");　　}　　public void turnOff() {　　   System.out.println("The television is off.");　　}　　public void changeChannel(int channel) {　　   this.currentChannel = channel;　　   System.out.println("Now TV channel is " + channel);　　}}

//开机命令ConcreteCommandpublic class CommandOn implements Command {　　private Tv myTv;　　public CommandOn(Tv tv) {　　   myTv = tv;　　}　　public void execute() {　　   myTv.turnOn();　　}}

//关机命令ConcreteCommand  public class CommandOff implements Command {  　　private Tv myTv;    　　public CommandOff(Tv tv) {  　　   myTv = tv;  　　}    　　public void execute() {  　　   myTv.turnOff();  　　}  }

//频道切换命令ConcreteCommand  public class CommandChange implements Command {  　　private Tv myTv;    　　private int channel;    　　public CommandChange(Tv tv, int channel) {  　　   myTv = tv;   　　  this.channel = channel;  　　}    　　public void execute() {  　　   myTv.changeChannel(channel);  　　}  }

//可以看作是遥控器Invoker  public class Control {  　　private Command onCommand, offCommand, changeChannel;    　　public Control(Command on, Command off, Command channel) {   　　  onCommand = on;   　　  offCommand = off;  　　   changeChannel = channel;  　　}    　　public void turnOn() {  　　   onCommand.execute();  　　}    　　public void turnOff() {  　　   offCommand.execute();  　　}    　　public void changeChannel() {   　　  changeChannel.execute();  　　}  }

//测试类Client  public class Client {  　　public static void main(String[] args) {    　　 // 命令接收者Receiver   　　  Tv myTv = new Tv();   　　  // 开机命令ConcreteCommond    　　 CommandOn on = new CommandOn(myTv);    　　 // 关机命令ConcreteCommond    　　 CommandOff off = new CommandOff(myTv);    　　 // 频道切换命令ConcreteCommond   　　  CommandChange channel = new CommandChange(myTv, 2);   　　  // 命令控制对象Invoker  　　   Control control = new Control(on, off, channel);      　　 // 开机    　　 control.turnOn();   　　  // 切换频道   　　  control.changeChannel();   　　  // 关机   　　  control.turnOff();  　　}  }

执行结果

The televisino is on.  Now TV channel is 2  The television is off.

总结
1.命令模式的本质是对命令进行封装，将发出命令的责任和执行命令的责任分割开。
2.每一个命令都是一个操作：请求的一方发出请求，要求执行一个操作；接收的一方收到请求，并执行操作。
3.命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。
4.命令模式使请求本身成为一个对象，这个对象和其他对象一样可以被存储和传递。
5.命令模式的关键在于引入了抽象命令接口，且发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。


7、实例程序

假设某个公司需要设计一个多用功能的遥控器。基本的需求如下：
该遥控器有可以控制风扇，白炽灯，热水器等等的多对开关，而且可能还有其他的电器，暂时不做其功能，但是希望可以保留接口，用的时间可以方便的扩展。除上面的需求之外，还需要有个按钮，可以撤销上一步的操作。基
你要做的是创建一组控制遥控器的API，让每个插槽都能够控制一个或一组装置。请注意，要能够控制目前的装置和任何未来可能出现的装置，这一点很重要。
实现命令接口
首先，让所有的命令对象实现相同的包含一个execute()方法的接口：

public interface Command {    public void execute();}

实现一个打开电灯的命令
现在，假设想实现一个打开电灯的命令。根据产商提供的类，Light类有两个方法：on()和off()。下面是如何将它实现成一个命令：

// 这是一个命令，所以需要实现Command接口public class LightOnCommand implements Command {    Light light;     // 构造器被传入了某个电灯（比方说：客厅的电灯），然后记录在实例变量中。    // 一旦调用execute()，就由这个电灯对象成为接收者，负责接收请求。    public LightOnCommand(Light light){        this.light = light;    }     // 这个execute()方法调用接收对象（我们正在控制的电灯）的on()方法    @Override    public void execute() {        light.on();    }}

使用命令对象
让我们把这一切简化，假设我们的遥控器只有一个按钮和对应的插槽，可以控制一个装置：

public class SimpleRemoteControl {    // 有一个插槽持有命令，而这个命令控制着一个装置    Command slot;     public SimpleRemoteControl(){}     // 这个方法用来设置插槽控制的命令。如果这段代码的客户想要改变遥控器按钮的行为，    // 可以多次调用这个方法。    public void setCommand(Command command){        slot = command;    }     // 当按下按钮时，这个方法就会被调用，使得当前命令衔接插槽，并调用它的execute()方法    public void buttonWasPressed(){        slot.execute();    }}

遥控器使用的简单测试
下面这段代码用来测试上面的简单遥控器：

// 控制器就是调用者，会传入一个命令对象，可以用来发出请求SimpleRemoteControl remote = new SimpleRemoteControl();// 现在创建了一个电灯对象，此对象也就是请求的接收者Light light = new Light();// 在这里创建一个命令，然后将接收者传给它LightOnCommand lightOn = new LightOnCommand(light); // 把命令传给调用者remote.setCommand(lightOn);// 模拟按下按钮remote.buttonWasPressed();

实现遥控器
现在让我们去实现有7个插槽的遥控器。

public class RemoteControl {    // 这个时候，遥控器要处理7个开与关的命令，使用相应数组记录这些命令    Command[] onCommands;    Command[] offCommands;    // 在构造器中，只需实例化并初始化这两个开与关的数组    public RemoteControl() {        onCommands = new Command[7];        offCommands = new Command[7];        Command noCommand = new NoCommand();        for (int i = 0; i < 7; i++) {            onCommands[i] = noCommand;            offCommands[i] = noCommand;        }    }    // setCommand()方法有3个参数，分别是插槽的位置、开的命令和关的命令。    // 这些命令将记录在开关数组中对应的插槽位置，以供稍后使用    public void setCommand(int slot, Command onCommand, Command offCommand) {        onCommands[slot] = onCommand;        offCommands[slot] = offCommand;    }    // 当按下开或关的按钮，硬件就会负责调用对应的方法    public void onButtonWasPushed(int slot){        onCommands[slot].execute();    }    public void offButtonWasPushed(int slot){        offCommands[slot].execute();    }}

加上撤销功能

好了，我们现在需要在遥控器上加上撤销的功能。这个功能使用起来就像是这样的：比如说客厅的电灯是关闭的，然后你按下遥控器上的开启按钮，自然电灯就被打开了。现在如果按下撤销按钮，那么上一个动作将被倒转，在这个例子里，电灯将被关闭。
当命令支持撤销时，该命令就必须提供和execute()方法相反的undo()方法。不管execute()刚才做什么，undo()都会倒转过来。我们需要在Command接口中加入undo()方法。

public interface Command {    public void execute();    public void undo();}

现在让我们深入电灯的命令，并实现undo()方法。

public class LightOnCommand implements Command {    Light light;     public LightOnCommand(Light light){        this.light = light;    }     @Override    public void execute() {        light.on();    }     @Override    public void undo() {        light.off();    }}

要加上撤销按钮，必须对遥控器做一些小修改。

public class RemoteControl {    Command[] onCommands;    Command[] offCommands;    // 前一个命令将被记录在这里    Command undoCommand;     public RemoteControl() {        onCommands = new Command[7];        offCommands = new Command[7];         Command noCommand = new NoCommand();        for (int i = 0; i < 7; i++) {            onCommands[i] = noCommand;            offCommands[i] = noCommand;        }        // 一开始并没有所谓的“前一个命令”，所以将它设置成NoCommand        undoCommand = noCommand;    }     public void setCommand(int slot, Command onCommand, Command offCommand) {        onCommands[slot] = onCommand;        offCommands[slot] = offCommand;    }     // 当按下按钮，我们取得这个命令，并优先执行它，然后将它记录在undoCommand中。    public void onButtonWasPushed(int slot){        onCommands[slot].execute();        undoCommand = onCommands[slot];    }     public void offButtonWasPushed(int slot){        offCommands[slot].execute();        undoCommand = offCommands[slot];    }     // 当按下撤销按钮，我们调用undoCommand实例变量的undo()方法，就可以倒转前一个命令    public void undoButtonWasPushed(){        undoCommand.undo();    }}

本文参考相关链接：http://blog.csdn.net/taozi8023/article/details/51452987

                           http://blog.csdn.net/jason0539/article/details/45110355

                          http://www.importnew.com/23481.html
                          http://blog.csdn.net/aayysyz12345678/article/details/9402403