设计模式之命令模式

让我们从一个简单的项目（遥控器）了解命令模式，然后再给出他的定义：

此项目地址：

          https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/command/simpleremote

实现命令接口：

首先，让所有的命令对象实现相同的包含一个方法的接口。我们暂且使用一贯的名称execute（）。

这就是命令接口（Command.java）： 

1 public interface Command {
2     public void execute();  //简单，只须一个方法 execute()
3 }

实现一个打开电灯的命令：

现在，假设想实现一个打开电灯的命令。有已知我们的Light类有两个方法：on()和off()。下面是如

何将它实现成一个命令（LightOnCommand.java）：

 1 //这是一个命令，所以要实现Command接口
 2 public class LightOnCommand implements Command{
 3     Light light;
 4 
 5 //    构造器被传入某个电灯（比如客厅的电灯），以便让这
 6 //    个命令控制。一旦调用execute()，就有这个电灯对象
 7 //    成为接收者。负责接收请求。
 8     public LightOnCommand(Light light){
 9         this.light = light;
10     }
11 
12 //    这个execute()方法调用接收对象（我们正在控制的电灯）的on()方法
13     public void execute(){
14         light.on();
15     }
16 }

现在有了LightOnCommand类，接下来让我们看一下如何使用它（SimpleRemoteController.java）：

 1 public class SimpleRemoteControl {
 2     //有一个插槽持有命令，而这个命令控制着一个装置
 3     Command slot;
 4     
 5     public SimpleRemoteControl(){};
 6     
 7     //这个方法用来设置插槽控制的命令。如果想改变遥
 8     // 控器按钮的行为，可以多次调用这个方法
 9     public void setCommand(Command command){
10         slot = command;
11     }
12     
13     //当按下按钮时，这个方法就会被调用，使得当前命
14     // 令衔接插槽，并调用方法execute()
15     public void buttonWasPressed(){
16         slot.execute();
17     }
18 }

现在让我们测试一下（Main.java）：

 1 public class Main {
 2 
 3     public static void main(String[] args) {
 4         SimpleRemoteControl remote = new SimpleRemoteControl();
 5         Light light = new Light();
 6         LightOnCommand lightOn = new LightOnCommand(light);
 7 
 8         remote.setCommand(lightOn);
 9         remote.buttonWasPressed();
10     }
11 }

结果：

 

好啦！通过如上例子，现在我们该给出命令模式的定义了：

    命令模式：将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令

                     模式也支持撤销的操作。

    来看看他的类图：

    

上面完成了简单遥控，但是要知道，一个遥控器可不止有一个插槽（每个插槽都具备了“开”和“关”

按钮），所以我们现在就要用到数组，作如下工作：

1 onCommand[0] = onCommand;
2 offCommand[0] = offCommand;

实现遥控器(RemoteController.java）:

 1 public class RemoteControl {
 2     //这时候，遥控器要处理7个开宇关的命令，使用相应的数组记录这些命令
 3     Command[] onCommands;
 4     Command[] offCommands;
 5  
 6     public RemoteControl() {
 7         //在构造器中，只需实例化并初始化这两个开与关的数组
 8         onCommands = new Command[7];
 9         offCommands = new Command[7];
10  
11         Command noCommand = new NoCommand();
12         for (int i = 0; i < 7; i++) {
13             onCommands[i] = noCommand;
14             offCommands[i] = noCommand;
15         }
16     }
17   
18     //这个方法需要有3个参数，分别是插槽的位置，开的命令、关的命令。这些命令将记录
19     // 在开关数组中对应的插槽位置、以供稍后使用
20     public void setCommand(int slot, Command onCommand, Command offCommand) {
21         onCommands[slot] = onCommand;
22         offCommands[slot] = offCommand;
23     }
24  
25     //当按下开或关的按钮，硬件就会负责调用相应的方法，也就是onButtonWasPushed
26     // 或offButtonWasPushed
27     public void onButtonWasPushed(int slot) {
28         onCommands[slot].execute();
29     }
30  
31     public void offButtonWasPushed(int slot) {
32         offCommands[slot].execute();
33     }
34   
35     public String toString() {
36         StringBuffer stringBuff = new StringBuffer();
37         stringBuff.append("\n------ Remote Control -------\n");
38         for (int i = 0; i < onCommands.length; i++) {
39             stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
40                 + "    " + offCommands[i].getClass().getName() + "\n");
41         }
42         return stringBuff.toString();
43     }
44 }

实现命令：

LightOffCommand.java:

 1 public class LightOffCommand implements Command {
 2     Light light;
 3  
 4     public LightOffCommand(Light light) {
 5         this.light = light;
 6     }
 7  
 8     public void execute() {
 9         light.off();
10     }
11 }

还有很多命令就不一一列举了，原理都一样，相当于很多机械操作。

开始测试遥控器：

 1 public class RemoteLoader {
 2  
 3     public static void main(String[] args) {
 4         RemoteControl remoteControl = new RemoteControl();
 5  
 6         Light livingRoomLight = new Light("Living Room");
 7         Light kitchenLight = new Light("Kitchen");
 8         CeilingFan ceilingFan= new CeilingFan("Living Room");
 9         GarageDoor garageDoor = new GarageDoor("");
10         Stereo stereo = new Stereo("Living Room");
11   
12         LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
13         LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
14         LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);
15         LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
16   
17         CeilingFanOnCommand ceilingFanOn = new CeilingFanOnCommand(ceilingFan);
18         CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);
19  
20         GarageDoorUpCommand garageDoorUp = new GarageDoorUpCommand(garageDoor);
21         GarageDoorDownCommand garageDoorDown = new GarageDoorDownCommand(garageDoor);
22  
23         StereoOnWithCDCommand stereoOnWithCD = new StereoOnWithCDCommand(stereo);
24         StereoOffCommand  stereoOff = new StereoOffCommand(stereo);
25  
26         remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
27         remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
28         remoteControl.setCommand(2, ceilingFanOn, ceilingFanOff);
29         remoteControl.setCommand(3, stereoOnWithCD, stereoOff);
30   
31         System.out.println(remoteControl);
32  
33         remoteControl.onButtonWasPushed(0);
34         remoteControl.offButtonWasPushed(0);
35         remoteControl.onButtonWasPushed(1);
36         remoteControl.offButtonWasPushed(1);
37         remoteControl.onButtonWasPushed(2);
38         remoteControl.offButtonWasPushed(2);
39         remoteControl.onButtonWasPushed(3);
40         remoteControl.offButtonWasPushed(3);
41     }
42 }

注：在遥控器中，我们不想每次都检查是否某个插槽都加载了命令。比方说，在这个onButtonWasP-

      ushed()方法中，我们可能需要这样的代码：

1 public void onButtonWasPushed(int slot){
2       if(onCommands[slot] != null){
3             onCommands[slot].execute();
4       }
5 }

       So，为了避免上述做法，我们实现一个不做事前的命令：

1 public class NoCommand implements Command {
2     public void execute() { }
3 }

       这么一来，在RemoteControl构造器中，我们将个每个插槽都预先制定或NoCommand对象，以便

      确定每个插槽永远都有名命令对象。

1         Command noCommand = new NoCommand();
2         for (int i = 0; i < 7; i++) {
3             onCommands[i] = noCommand;
4             offCommands[i] = noCommand;
5         }

        所以在测试的输出中，没有被明确指定命令的插槽，其命令将是默认的NoCommand对象。

第二个项目代码地址：

          https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/command/remote  

还记得我们之前说的undo操作嘛？现在我们来实现它：

代码地址：https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/command/undo

我们只需要在Command.java，我们只需加上第三行代码就好:

1 public interface Command {
2     public void execute();
3     public void undo();
4 }

然后再从LightOnCommand开始下手：

 1 public class LightOnCommand implements Command {
 2     Light light;
 3     int level;
 4     public LightOnCommand(Light light) {
 5         this.light = light;
 6     }
 7  
 8     public void execute() {
 9         level = light.getLevel();
10         light.on();
11     }
12  
13     //加上
14     public void undo() {
15         light.dim(level);
16     }
17 }

最后是RemoteControllerWithUndo.java:

 1 public class RemoteControlWithUndo {
 2     Command[] onCommands;
 3     Command[] offCommands;
 4     Command undoCommand;
 5  
 6     public RemoteControlWithUndo() {
 7         onCommands = new Command[7];
 8         offCommands = new Command[7];
 9  
10         Command noCommand = new NoCommand();
11         for(int i=0;i<7;i++) {
12             onCommands[i] = noCommand;
13             offCommands[i] = noCommand;
14         }
15         undoCommand = noCommand;
16     }
17   
18     public void setCommand(int slot, Command onCommand, Command offCommand) {
19         onCommands[slot] = onCommand;
20         offCommands[slot] = offCommand;
21     }
22  
23     public void onButtonWasPushed(int slot) {
24         onCommands[slot].execute();
25         undoCommand = onCommands[slot];
26     }
27  
28     public void offButtonWasPushed(int slot) {
29         offCommands[slot].execute();
30         undoCommand = offCommands[slot];
31     }
32  
33     public void undoButtonWasPushed() {
34         undoCommand.undo();
35     }
36   
37     public String toString() {
38         StringBuffer stringBuff = new StringBuffer();
39         stringBuff.append("\n------ Remote Control -------\n");
40         for (int i = 0; i < onCommands.length; i++) {
41             stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
42                 + "    " + offCommands[i].getClass().getName() + "\n");
43         }
44         stringBuff.append("[undo] " + undoCommand.getClass().getName() + "\n");
45         return stringBuff.toString();
46     }
47 }

测试类（RemoteLoader.java）:

 1 public class RemoteLoader {
 2  
 3     public static void main(String[] args) {
 4         RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();
 5  
 6         Light livingRoomLight = new Light("Living Room");
 7  
 8         LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
 9         LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
10  
11         remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
12  
13         remoteControl.onButtonWasPushed(0);
14         remoteControl.offButtonWasPushed(0);
15         System.out.println(remoteControl);
16         remoteControl.undoButtonWasPushed();
17         remoteControl.offButtonWasPushed(0);
18         remoteControl.onButtonWasPushed(0);
19         System.out.println(remoteControl);
20         remoteControl.undoButtonWasPushed();
21 22     }
23 }

好了，实现电灯的撤销很简单。但是，通常，想要实现撤销的功能，需要记录一些状态。让我们是一个更有

趣的例子，比方说厂商类中的天花板的吊扇。吊扇允许有多种转动速度，当然也允许被关闭。

吊扇源码如下：

 1 public class CeilingFan {
 2     public static final int HIGH = 3;
 3     public static final int MEDIUM = 2;
 4     public static final int LOW = 1;
 5     public static final int OFF = 0;
 6     String location;
 7     int speed;
 8  
 9     public CeilingFan(String location) {
10         this.location = location;
11         speed = OFF;
12     }
13   
14     public void high() {
15         speed = HIGH;
16         System.out.println(location + " ceiling fan is on high");
17     } 
18  
19     public void medium() {
20         speed = MEDIUM;
21         System.out.println(location + " ceiling fan is on medium");
22     }
23  
24     public void low() {
25         speed = LOW;
26         System.out.println(location + " ceiling fan is on low");
27     }
28   
29     public void off() {
30         speed = OFF;
31         System.out.println(location + " ceiling fan is off");
32     }
33   
34     public int getSpeed() {
35         return speed;
36     }
37 }

加入撤销到吊扇的命令类（CeilingFanHighCommand.java）：

 1 public class CeilingFanHighCommand implements Command {
 2     CeilingFan ceilingFan;
 3     int prevSpeed;
 4   
 5     public CeilingFanHighCommand(CeilingFan ceilingFan) {
 6         this.ceilingFan = ceilingFan;
 7     }
 8  
 9     public void execute() {
10         prevSpeed = ceilingFan.getSpeed();
11         ceilingFan.high();
12     }
13  
14     public void undo() {
15         if (prevSpeed == CeilingFan.HIGH) {
16             ceilingFan.high();
17         } else if (prevSpeed == CeilingFan.MEDIUM) {
18             ceilingFan.medium();
19         } else if (prevSpeed == CeilingFan.LOW) {
20             ceilingFan.low();
21         } else if (prevSpeed == CeilingFan.OFF) {
22             ceilingFan.off();
23         }
24     }
25 }

添加测试类（RemoteLoader.java）：

 1 public class RemoteLoader {
 2 
 3     public static void main(String[] args) {
 4         CeilingFan ceilingFan = new CeilingFan("Living Room");
 5 
 6         CeilingFanMediumCommand ceilingFanMedium = new CeilingFanMediumCommand(ceilingFan);
 7         CeilingFanHighCommand ceilingFanHigh = new CeilingFanHighCommand(ceilingFan);
 8         CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);
 9 
10         remoteControl.setCommand(0, ceilingFanMedium, ceilingFanOff);
11         remoteControl.setCommand(1, ceilingFanHigh, ceilingFanOff);
12 
13         remoteControl.onButtonWasPushed(0);
14         remoteControl.offButtonWasPushed(0);
15         System.out.println(remoteControl);
16         remoteControl.undoButtonWasPushed();
17 
18         remoteControl.onButtonWasPushed(1);
19         System.out.println(remoteControl);
20         remoteControl.undoButtonWasPushed();
21     }
22 }

最后，我们相同时弄暗灯光、打开音响和电视、设置好DVD，并让热水器开始加温：

代码地址： https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/command/party

MacroCommand.java:

 1 public class MacroCommand implements Command {
 2     Command[] commands;
 3  
 4     public MacroCommand(Command[] commands) {
 5         this.commands = commands;
 6     }
 7  
 8     public void execute() {
 9         for (int i = 0; i < commands.length; i++) {
10             commands[i].execute();
11         }
12     }
13     
14     public void undo() {
15         for (int i = commands.length -1; i >= 0; i--) {
16             commands[i].undo();
17         }
18     }
19 }

使用宏命令（RemoteLoader.java）：

 1 public class RemoteLoader {
 2 
 3     public static void main(String[] args) {
 4 
 5         RemoteControl remoteControl = new RemoteControl();
 6 
 7         //首先创建想要进入宏的命令集合
 8         Light light = new Light("Living Room");
 9         TV tv = new TV("Living Room");
10         Stereo stereo = new Stereo("Living Room");
11         Hottub hottub = new Hottub();
12  
13         LightOnCommand lightOn = new LightOnCommand(light);
14         StereoOnCommand stereoOn = new StereoOnCommand(stereo);
15         TVOnCommand tvOn = new TVOnCommand(tv);
16         HottubOnCommand hottubOn = new HottubOnCommand(hottub);
17         LightOffCommand lightOff = new LightOffCommand(light);
18         StereoOffCommand stereoOff = new StereoOffCommand(stereo);
19         TVOffCommand tvOff = new TVOffCommand(tv);
20         HottubOffCommand hottubOff = new HottubOffCommand(hottub);
21 
22         //接下来创建两个数组，其中一个用来记录开启命令，另一个用来记录关闭命令，并在数组内放入对应的命令
23         Command[] partyOn = { lightOn, stereoOn, tvOn, hottubOn};
24         Command[] partyOff = { lightOff, stereoOff, tvOff, hottubOff};
25   
26         MacroCommand partyOnMacro = new MacroCommand(partyOn);
27         MacroCommand partyOffMacro = new MacroCommand(partyOff);
28  
29         //然后将宏命令指定给我们所希望的按钮
30         remoteControl.setCommand(0, partyOnMacro, partyOffMacro);
31   
32         //最后，按一按按钮，测试一下
33         System.out.println(remoteControl);
34         System.out.println("--- Pushing Macro On---");
35         remoteControl.onButtonWasPushed(0);
36         System.out.println("--- Pushing Macro Off---");
37         remoteControl.offButtonWasPushed(0);
38     }
39 }