《Head First 设计模式》：命令模式

正文

一、定义

命令模式将“请求”封装成对象（命令对象），以便使用不同的“请求”来参数化其他对象。

要点：

• 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦。
• 被解耦的两者之间通过命令对象进行沟通。命令对象封装了接收者和一个或多个动作。
• 命令对象提供一个 execute() 方法，该方法封装了接收者的动作。当此方法被调用时，接收者就会执行这些动作。
• 调用者持有一个或多个命令对象，通过调用命令对象的 execute() 方法发出请求，这会使得接收者的动作被调用。

二、实现步骤

1、创建接收者类

接收者类中包含要执行的动作。

（1）接收者A

/**
 * 接收者A
 */
public class ReceiverA {

    /**
     * 动作1
     */
    public void action1() {
        System.out.println("ReceiverA do action1");
    }

    /**
     * 动作2
     */
    public void action2() {
        System.out.println("ReceiverA do action2");
    }
}

（2）接收者B

/**
 * 接收者B
 */
public class ReceiverB {

    /**
     * 动作1
     */
    public void action1() {
        System.out.println("ReceiverB do action1");
    }

    /**
     * 动作2
     */
    public void action2() {
        System.out.println("ReceiverB do action2");
    }
}

2、创建命令接口

/**
 * 命令接口
 */
public interface Command {

    /**
     * 执行命令
     */
    public void execute();
}

3、创建具体的命令，并实现命令接口

命令对象中，封装了命令接收者和相关动作。

（1）命令A1

/**
 * 命令A1
 */
public class ConcreteCommandA1 implements Command{

    /**
     * 接收者A
     */
    ReceiverA receive;

    public ConcreteCommandA1(ReceiverA receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者A执行动作1
        receive.action1();
    }
}

（2）命令A2

/**
 * 命令A2
 */
public class ConcreteCommandA2 implements Command{

    /**
     * 接收者A
     */
    ReceiverA receive;

    public ConcreteCommandA2(ReceiverA receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者A执行动作2
        receive.action2();
    }
}

（3）命令B1

/**
 * 命令B1
 */
public class ConcreteCommandB1 implements Command{

    /**
     * 接收者B
     */
    ReceiverB receive;

    public ConcreteCommandB1(ReceiverB receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者B执行动作1
        receive.action1();
    }
}

（4）命令B2

/**
 * 命令B2
 */
public class ConcreteCommandB2 implements Command{

    /**
     * 接收者B
     */
    ReceiverB receive;

    public ConcreteCommandB2(ReceiverB receive) {
        this.receive = receive;
    }

    @Override
    public void execute() {
        // 接收者B执行动作2
        receive.action2();
    }
}

4、创建调用者

调用者通过持有的命令对象，来调用接收者的动作。

/**
 * 调用者
 */
public class Invoker {

    /**
     * 命令对象
     */
    Command command;

    /**
     * 设置命令
     */
    public void setCommand(Command command) {
        this.command = command;
    }

    /**
     * 调用动作
     */
    public void invoke() {
        command.execute();
    }
}

5、调用者执行命令

public class Test {

    public static void main(String[] args) {
        // 命令调用者
        Invoker invoker = new Invoker();

        // 命令接收者
        ReceiverA receiverA = new ReceiverA();
        ReceiverB receiverB = new ReceiverB();

        // 创建命令，并指定接收者
        Command commandA1 = new ConcreteCommandA1(receiverA);
        Command commandA2 = new ConcreteCommandA2(receiverA);
        Command commandB1 = new ConcreteCommandB1(receiverB);
        Command commandB2 = new ConcreteCommandB2(receiverB);

        // 调用者执行命令
        invoker.setCommand(commandA1);
        invoker.invoke();
        invoker.setCommand(commandA2);
        invoker.invoke();
        invoker.setCommand(commandB1);
        invoker.invoke();
        invoker.setCommand(commandB2);
        invoker.invoke();
    }
}

三、举个栗子

1、背景

假设你要设计一个家电自动化遥控器的 API。这个遥控器具有七个可编程的插槽（每个都可以指定到一个不同的家电装置），每个插槽都有对应的“开”、“关”按钮。

你希望每个插槽都能够控制一个或一组装置。并且，这个遥控器适用于目前的装置和任何未来可能出现的装置。

2、实现

（1）创建家电类

/**
 * 电灯（接收者）
 */
public class Light {

    /**
     * 电灯位置
     */
    String location;

    public Light(String location) {
        this.location = location;
    }

    /**
     * 开灯
     */
    public void on() {
        System.out.println(location + " light is on");
    }

    /**
     * 关灯
     */
    public void off() {
        System.out.println(location + " light is off");
    }
}

/**
 * 音响（接收者）
 */
public class Stereo {

    /**
     * 打开音响
     */
    public void on() {
        System.out.println("Stereo is on");
    }

    /**
     * 关闭音响
     */
    public void off() {
        System.out.println("Stereo is off");
    }

    /**
     * 设置为播放CD
     */
    public void setCd() {
        System.out.println("Stereo is set for CD input");
    }

    /**
     * 设置为播放DVD
     */
    public void setDvd() {
        System.out.println("Stereo is set for DVD input");
    }

    /**
     * 设置音量
     */
    public void setVolume(int volume) {
        System.out.println("Stereo volume set to " + volume);
    }
}

（2）创建命令接口

/**
 * 命令接口
 */
public interface Command {

    /**
     * 执行命令
     */
    public void execute();
}

（3）创建具体的命令，并继承命令接口

/**
 * 无命令
 */
public class NoCommand implements Command {

    @Override
    public void execute() {}
}

/**
 * 开灯命令
 */
public class LightOnCommand implements Command {

    Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

/**
 * 关灯命令
 */
public class LightOffCommand implements Command {

    Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

/**
 * 打开音响播放CD命令
 */
public class StereoOnWithCDCommand implements Command {

    Stereo stereo;

    public StereoOnWithCDCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.on();
        stereo.setCd();
        stereo.setVolume(11);
    }
}

/**
 * 关闭音响命令
 */
public class StereoOffCommand implements Command {

    Stereo stereo;

    public StereoOffCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.off();
    }
}

（4）创建遥控器类

/**
 * 遥控器（调用者）
 */
public class RemoteControl {

    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;
        }
    }

    /**
     * 设置插槽命令
     */
    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();
    }
}

（5）使用遥控器控制家电

public class Test {

    public static void main(String[] args) {
        // 遥控器
        RemoteControl remoteControl = new RemoteControl();

        // 家电
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        Stereo stereo = new Stereo();

        // 创建命令，并指定家电
        Command livingRoomLightOn = new LightOnCommand(livingRoomLight);
        Command livingRoomLightOff = new LightOffCommand(livingRoomLight);
        Command kitchenLightOn = new LightOnCommand(kitchenLight);
        Command kitchenLightOff = new LightOffCommand(kitchenLight);
        Command stereoOnWithCD = new StereoOnWithCDCommand(stereo);
        Command stereoOff = new StereoOffCommand(stereo);

        // 设置插槽命令
        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
        remoteControl.setCommand(2, stereoOnWithCD, stereoOff);

        // 遥控器执行命令
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);
        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);
        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);
    }
}

四、命令模式的更多用途

1、队列请求

命令可以将运算块打包（一个接收者和一组动作），然后将它传来传去，就像是一般的对象一样。即使在命令对象被创建许久之后，运算依然可以被调用。事实上，它甚至可以在不同的线程中被调用。

因此，命令模式可以用来实现队列请求。具体做法是：在工作队列的一端添加命令，另一端通过线程取出命令，调用它的 execute() 方法，等调用完成后，将此命令对象丢弃，再取出下一个命令……

2、日志请求

某些应用需要我们将所有的动作都记录在日志中，并能在系统死机后，重新调用这些动作恢复到之前的状态。

命令模式能够支持这一点。具体做法是：当我们执行命令时，利用序列化将命令对象存储在磁盘中。一旦系统死机，再利用反序列化将命令对象重新加载，并依次调用这些对象的 execute() 方法。