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

一、命令模式的定义

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

命令接口–ICommand

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

定义统一的接口，所有的命令类都需要实现该接口。

命令类–ConcreteCommand

public class ConcreteCommand implements ICommand {    private Reciever reciever;    public ConcreteCommand(Reciever receiver) {        this.reciever = receiver;    }    public void execute() {        reciever.action();    }    public void undo() {        reciever.undo();    }}

将某一个具体的“请求”封装成具体的命令类，实现ICommand接口。命令模式的核心目的是将发出请求的对象和执行请求的对象解耦，被解耦的两者之间是通过命令对象进行沟通的，命令对象封装了接受者及其一个或多个动作。比如：开灯命令，可以是LightOnCommand；

命令执行者—Reciever

public class Reciever {    private String recieverName;    pubic Reciever(String name) {        this.recieverName = name;    }    public void action() {        System.out.println("do action...");    }    public void undoAction() {        System.out.println("undo action ...");    }}

该类是真正执行命令的类，实质上它根本不知道ICommand和Command的存在，所以它只要纯粹完成自己的逻辑。比如一个电灯类（Light），就只需要实现开关电灯的逻辑，并暴露出调用接口就行了。

调用者–Invoker

public class Invoker {    private ICommand command;    public Invoker() {}    public void setCommand(ICommand command) {        this.command = command;    }    // 调用创建时就设置好的命令对象    public invokeCommand() {        this.command.execute();    }    // 动态调用通过参数传过来的命令对象    public invokeCommand(ICommand command) {        command.execute();    }    public invokeUndo() {        this.command.undo();    }}

命令的调用者，它持有一个或者多个命令对象，在某个时间点调用命令对象的execute方法，将请求付诸执行。

客户端–Client

public class Client {        Receiver reciever = new Reciever();           ICommand c = new ConcreteCommand(reciever);            Invoker invoker = new Invoker();           invoker.setCommand(c);           invoker.invokeCommand(); }

负责创建具体的命令对象，并设置命令的执行者。

宏命令

public class MacroCommand implements ICommand {    ICommands[] commands;    public MacroCommand(ICommand[] commands) {        this.commands = commands;    }    public void execute() {        for (int i=0; i<commands.length; i++) {            commands[i].execute();        }    }    public void undo() {        for (int i=0; i<commands.length; i++) {            commands[i].undo();        }    }}

宏命令的目的是，制造一种新的命令来执行其他一堆命令。这样这个宏命令也是一个实现了ICommand的命令对象，因此可以普通的命令对象一样被执行。

二、一个具体的例子

实现一个控制电灯开关的遥控器，有三个功能：开、关、撤销操作。

/** * 命令真正执行者，对应类图中的Reciever */public class Light {    public void onLight() {        System.out.println("light on...");    }    public void offLight() {        System.out.println("light off...");    }    public void undo() {        System.out.println("light undo...")    }}/** * 开灯命令，对应类图中的ConcreteCommand */public class LightOnCommand implements ICommand{    private Light light;    public LightOnCommand(Light light) {        this.light = light;    }    public void execute() {        light.onLight();    }    public void undo() {        light.undo();    }}/** * 关灯命令,对应类图中的ConcreteCommand */public class LightOffCommand implements ICommand{    private Light light;    public LightOffCommand(Light light) {        this.light = light;    }    public void execute() {        light.offLight();    }    public void undo() {        light.undo();    }}/** * 定义一个空命令对象，它是一个空对象，不做任何事情。可能遥控器在出厂时并没有 * 设置真正有效的命令对象，就可以用空对象代替，以便后续在设置真正的命令对象。 */public class NoCommand implements ICommand {    public void execute(){}    public void undo(){}}/** * 命令调用者,对应类图中的Invoker */public class LightController {    // 持有多个命令对象    private ICommand[] commands;    // 记录前一个命令对象，用于“撤销”操作    private ICommand undoCommand;    public LightController() {        // 用于保存开和关两个命令对象        this.commands = new ICommand[2];        // 初始化        ICommand noCommand = new NoCommand();        for（int i=0; i<2; i++）{            command[i] = noCommand;        }        undoCommand = noCommand;    }    public void setCommands(ICommand onCommand, ICommand offCommand) {        // 第一个元素被设为开命令对象        commands[0] = onCommand;        commands[1] = offCommand;    }    // 按下打开电灯的按钮（请求打开电灯）    public void onButtonPushed() {        commands[0].execute();        undoCommand = commands[0];    }    // 按下打关电灯的按钮（请求关掉电灯）    public void offButtonPushed() {        commands[1].execute();        undoCommand = commands[1];    }    // 按下撤销按钮，由对应的命令对象执行其撤销操作    pubic void undoButtonPushed() {        undoCommand.undo();    }    // ...其他代码}/** * 创建者，对应类图中的Client类 */public class LightControllerTest {    public void static main(String[] args) {        // 创建命令对象及其执行者        Light light = new Light();        LightOnCommand onCommand = new LightOnCommand(light);        LightOffCommand offCommand = new LightOffCommand(light);        LightController lightController = new LightController();        lightController.setCommands(onCommand, offCommand);        // 测试        lightController.onButtonPushed();        lightController.offButtonPushed();        lightController.undoButtonPushed();    }}

三、优缺点

优点

• 将发出请求的对象与执行请求的对象解耦。
• 调用者可以执行通过参数传过来的命令对象，因而可以在运行时动态执行命令。
• 命令的发送者和命令执行者有不同的生命周期。命令发送了并不是立即执行。
• 可以使用宏命令任意组合一些命令，比如实现“一键式家居控制”的需求，就可以将各种家电的命令对象组合成一组。
• 因为将“请求”封装成了对象，使得命令可以被传递，被延时执行。比如，将命令对象发送到远程服务进行执行；也可以将命令对象扔到队列中，由专门的执行命令线程进行执行，执行命令的线程不需要知道具体命令内容，只要是实现了ICommand接口的对象，它都可以执行。
• 因为将“请求”封装成了对象，从而使得可以对请求的执行过程进行一些控制。比如“撤销”操作可以让命令执行失败之后，进行撤销，可用于事务执行。
• 可将命令记录到日志，系统故障后恢复等。

缺点

• 每一个命令都封装为命令对象，导致类太多。
• 对于这一点，个人感觉不需要如此细的粒度，比如LightOnCommand，LightOffCommand，只要设计一个合适的数据结构，通过数据来表达，就可以省掉很多类，代码的灵活和可扩展性也不受影响。

四、应用场景

队列

命令对象扔到队列中，由专门的执行命令线程进行执行，执行命令的线程不需要知道具体命令内容，只要是实现了ICommand接口的对象，它都可执行。因为命令模式下请求者和执行者可以有不同的生命周期，所以命令对象在创建很久以后，仍然可以被执行。另外，可以使用线程池来执行这些命令，只要这些命令实现Runable接口。

日志

因为命令对象可以对命令自身进行管理，比如可以输出命令日志，所以可以用于“容灾”等需要记录所有命令的应用。在这些应用中，命令对象中新增记录日志将命令存储到磁盘中，一旦系统崩溃或死机，重启后可以重新加载命令，再批次执行命令对象的execute方法。比如数据库事务处理，电子表格等应用。

状态条

如果假如系统需要按顺序执行一系列的命令操作，并且需要了解命令执行进度和状态，则可以让每个命令对象都提供一个获取命令执行状态的方法，系统调用该方法显示状态。

需要多级撤销或重做操作

可以在Invoker中用一个栈来存储执行过的命令对象，一旦需要撤销或重做操作，可以通过pop出最近的一个命令对象，并执行其undo方法。

web服务请求处理

将每个web请求封装成一个命令对象。比如struts框架中，就用到了命令模式： Struts框架中，在模型层都要继承一个Action接口，并实现execute方法，其实这个Action就是命令类。为什么Struts会应用命令模式，是因为Struts的核心控制器ActionServlet只有一个，相当于Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的Command。这样，就需要在ActionServlet和模型层之间解耦，而命令模式正好解决这个问题。