设计模式：第六篇--命令模式

• 命令模式模型
• 案例：家居遥控器
  • 撤销命令
  • 宏命令
• 总结：

命令模式模型

命令模式：将“请求”封装成对象，以便使用不同的请求，队列或日志来参数化其他对象，支持撤销命令的操作。实现“动作的请求者”从“动作的执行者”中解耦。

命令模式

理解：很简单的一个思想，抽象了命令，同时提供了操作这个命令对象的角色Invoker。命令请求于命令执行，两个东西是耦合到一起的。抽象了命令，和提供了Invoker之后。Client可以向Invoker提出具体的命令请求。具体的命令是耦合具体的Receiver(具体的命令执行者)。由Invoker去封装命令并且发出“执行命令的请求”。这个过程，其实是将命令请求从 client-->Receiver 转移到 Client-->Invoker-->Receiver。抽象和封装有时候就是这样，多一个角色去协调，那么便可以拓展和管理被协调的两方面了。

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/26 10:22.
 *
 * 命令模式的Command：抽象命令对象
 */
public interface Command {

    void execute();

}

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/26 10:24.
 *
 * 命令模式的Command：具体命令对象
 */
public class ConcreteCommand implements Command{

    //接收命令对象
    Receiver receiver;

    public ConcreteCommand(Receiver light) {
        this.receiver = light;
    }

    @Override
    public void execute() {
        this.receiver.action();
    }
}

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/26 10:26.
 *
 * 命令模式的Invoker:调用者对象，调用者传递命令
 */
public class Invoker {

    //插槽持有命令
    Command command;

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

    /**
     * 将命令封装进按下按钮动作中
     */
    public void buttonWasPressed() {
        command.execute();
    }

}

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/26 10:23.
 *
 * 命令模式的Receiver:接收者（具体动作执行者）
 */
public class Receiver {

    /**
     * 具体的命令要执行的动作
     */
    void action(){
    }

}

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/26 10:47.
 *
 * client:命令模式的客户，客户通过Invoker设置命令
 */
public class Client {

    public static void main(String[] args) {

        Invoker invoker = new Invoker();
        
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);

        invoker.setCommand(command);
        invoker.buttonWasPressed();

    }

}

案例：家居遥控器

需求：装修了，换一套智能家居。需要遥控器来控制家里的一些，比如灯，音响之类的一些家具。
思考：原来我需要到开关上去控制开关，现在转移到遥控器上了，命令的请求从命令的执行者，转移到协调者（Invoker）去了。这不正符合命令模式吗。用命令模式设计一下。

• 第一步：首先是实际的执行者（Receiver）

public class Light {

    private String description;

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

    public void on() {
        System.out.println(description + " on");
    }

    public void off() {
        System.out.println(description + " off");
    }
    
}

public class Stereo {

    private String description;

    public Stereo(String description) {
        this.description = description;
    }

    public void on() {
        System.out.println(description + "Stereo on");
    }

    public void off() {
        System.out.println(description + "Stereo off");
    }

    public void setCD(){
        System.out.println(description + "Stereo set CD");
    }

    public void setVolume(int volume){
        System.out.println(description + "Stereo set volume is " + volume);
    }

}

• 第二步：抽象命令接口，提供向Receiver请求执行具体命令的具体命令对象。

public interface Command {
    void execute();
}

public class LightOffCommand implements Command {

    private Light light;

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

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

public class LightOnCommand implements Command {

    private Light light;

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

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

public class StereoOnWithCDComand implements Command {

    private Stereo stereo;

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

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

public class StereoOffWithCDComand implements Command {

    private Stereo stereo;

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

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

public class NoCommand implements Command {
    /**
     * 空对象，什么都不做
     */
    @Override
    public void execute() {

    }
}

• 第三步：提供遥控器向Receiver请求命令之间的协调者（Invoker）

public class RemoteControl {

    /**
     * 记录命令
     */
    private Command[] onCommands;
    private Command[] offCommands;


    public RemoteControl() {
        
        //设置7个命令插槽
        onCommands = new Command[7];
        offCommands = new Command[7];

        NoCommand noCommand = new NoCommand();

        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }

    }

    /**
     * 提供设置插槽命令的方法
     * @param slot
     * @param onCommand
     * @param offCommand
     */
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        this.onCommands[slot] = onCommand;
        this.offCommands[slot] = offCommand;
    }

    /**
     * 封装出来的具体命令动作
     * @param slot
     */
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
    }

    /**
     * 封装出来的具体命令动作
     * @param slot
     */
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
    }

    @Override
    public String toString() {

        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < onCommands.length; i++) {
            stringBuffer.append("[")
                    .append("slot ")
                    .append(i)
                    .append("]")
                    .append(onCommands[i].getClass().getName())
                    .append("   ")
                    .append(offCommands[i].getClass().getName())
                    .append("\n");
        }

        return stringBuffer.toString();


    }
}

• 第四步：实现遥控器（client）

public class RemoteLoader {

    public static void main(String[] args) {
        //1、获取Invoker，协调者
        RemoteControl remoteControl = new RemoteControl();

        //2、设置Reveiver，实际命令执行者
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        Stereo livingRoomStereo = new Stereo("Living Room");

        //设置命令，并绑定实际命令执行者
        LightOffCommand livingRoomLightOff= new LightOffCommand(livingRoomLight);
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);

        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);

        StereoOnWithCDComand stereoOnWithCDComand = new StereoOnWithCDComand(livingRoomStereo);
        StereoOffWithCDComand stereoOffWithCDComand = new StereoOffWithCDComand(livingRoomStereo);

        //3、封装命令到Invoker协调者
        remoteControl.setCommand(0,livingRoomLightOn,livingRoomLightOff);
        remoteControl.setCommand(1,kitchenLightOn,kitchenLightOff);
        remoteControl.setCommand(2,stereoOnWithCDComand,stereoOffWithCDComand);

        System.out.println(remoteControl);

        //4、Invoker,协调者发出执行命令的请求
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);

        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);

    }
}

总结：命令模式的核心在于抽象命令，并提供命令请求的协调者。怎加一个角色解耦另外两个角色。实现拓展。

撤销命令

需求：命令支持撤销
思考：本质上撤销就是执行历史命令，或者执行乡放的命令。
做法：命令接口提供与execute()方法相反的undo()方法，具体命令提供实现即可。

public interface Command {

    void execute();

    void undo();
}

public class LightOnCommand implements Command {

    private Light light;

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

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

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

public class LightOffCommand implements Command {

    private Light light;

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

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

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

}

记录撤销的命令

public class RemoteControlWithUndo {

    /**
     * 记录命令
     */
    private Command[] onCommands;
    private Command[] offCommands;
    
    //记录要撤销的命令
    private Command undoCommand;

    public RemoteControlWithUndo() {

        //设置7个命令插槽
        onCommands = new Command[7];
        offCommands = new Command[7];

        NoCommand noCommand = new NoCommand();

        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }

        undoCommand = noCommand;

    }

    /**
     * 提供设置插槽命令的方法
     *
     * @param slot
     * @param onCommand
     * @param offCommand
     */
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        this.onCommands[slot] = onCommand;
        this.offCommands[slot] = offCommand;
    }

    /**
     * 封装出来的具体命令动作
     *
     * @param slot
     */
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
        undoCommand = onCommands[slot];
    }

    /**
     * 封装出来的具体命令动作
     *
     * @param slot
     */
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
        undoCommand = offCommands[slot];
    }

    /**
     * 撤销方法
     */
    public void undoButtonWasPushed() {
        undoCommand.undo();
    }

    @Override
    public String toString() {

        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < onCommands.length; i++) {
            stringBuffer.append("[")
                    .append("slot ")
                    .append(i)
                    .append("]")
                    .append(onCommands[i].getClass().getName())
                    .append("   ")
                    .append(offCommands[i].getClass().getName())
                    .append("\n");
        }

        return stringBuffer.toString();


    }
}

使用并测试

public class RemoteLoader {

    public static void main(String[] args) {
        //1、获取Invoker，协调者
        //RemoteControl remoteControl = new RemoteControl();
        //使用带撤销命令的协调者
        RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();

        //2、设置Reveiver，实际命令执行者
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        Stereo livingRoomStereo = new Stereo("Living Room");

        //设置命令，并绑定实际命令执行者
        LightOffCommand livingRoomLightOff= new LightOffCommand(livingRoomLight);
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);

        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);

        StereoOnWithCDComand stereoOnWithCDComand = new StereoOnWithCDComand(livingRoomStereo);
        StereoOffWithCDComand stereoOffWithCDComand = new StereoOffWithCDComand(livingRoomStereo);

        //3、封装命令到Invoker协调者
        remoteControl.setCommand(0,livingRoomLightOn,livingRoomLightOff);
        remoteControl.setCommand(1,kitchenLightOn,kitchenLightOff);
        remoteControl.setCommand(2,stereoOnWithCDComand,stereoOffWithCDComand);

        System.out.println(remoteControl);

        //4、Invoker,协调者发出执行命令的请求
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);

        //撤销命令
        System.out.println("撤销命令:");
        remoteControl.undoButtonWasPushed();

        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);

    }

}

备注：如果要撤销一组命令，可以将记录命令的对象改为记录命令对象的堆栈，每次按下撤销只要调用栈顶对象的undo方法即可

宏命令

需求：现在遥控器要可以一键打开或关闭厨房、客厅的灯。
思考：拓展一个宏命令对象，组长其他命令即可。

public class MacroCommand implements Command {

    Command[] commands;

    public MacroCommand(Command[] commands) {
        this.commands = commands;
    }

    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }

    @Override
    public void undo() {
        for (Command command : commands) {
            command.undo();
        }
    }
}

public class RemoteLoader {

    public static void main(String[] args) {
        //1、获取Invoker，协调者
        //RemoteControl remoteControl = new RemoteControl();
        //使用带撤销命令的协调者
        RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();

        //2、设置Reveiver，实际命令执行者
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        Stereo livingRoomStereo = new Stereo("Living Room");

        //设置命令，并绑定实际命令执行者
        LightOffCommand livingRoomLightOff= new LightOffCommand(livingRoomLight);
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);

        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);

        StereoOnWithCDComand stereoOnWithCDComand = new StereoOnWithCDComand(livingRoomStereo);
        StereoOffWithCDComand stereoOffWithCDComand = new StereoOffWithCDComand(livingRoomStereo);

        //提供开关宏命令
        MacroCommand partyOn = new MacroCommand(new Command[]{livingRoomLightOn, kitchenLightOn});
        MacroCommand partyOff = new MacroCommand(new Command[]{livingRoomLightOff, kitchenLightOff});

        //3、封装命令到Invoker协调者
        remoteControl.setCommand(0,livingRoomLightOn,livingRoomLightOff);
        remoteControl.setCommand(1,kitchenLightOn,kitchenLightOff);
        remoteControl.setCommand(2,stereoOnWithCDComand,stereoOffWithCDComand);
        remoteControl.setCommand(3,partyOn,partyOff);

        System.out.println(remoteControl);

        //4、Invoker,协调者发出执行命令的请求
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);

        //撤销命令
        System.out.println("撤销命令:");
        remoteControl.undoButtonWasPushed();

        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);
        
        //执行宏命令
        remoteControl.onButtonWasPushed(3);
        remoteControl.offButtonWasPushed(3);
    }

}

总结：

命令模式封装的是请求：其实是将计算打包。可以将动作的执行顺序管理起来。解耦的是请求命令的对象以及执行命令的对象。

应用场景：命令模式封装的是请求，在实际应用中，请求一般都是跟队列相关。那么命令模式应用场景其实还是蛮多的。比如说工作队列，日程安排，线程池这些。日志请求也是一个方面，设置还能记录撤销，根据日志队列取出命令请求，还可以撤销命令达到恢复的目的。