设计模式之命令模式

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】 

命令模式

定义

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

一个命令对象通过在特定接收者上绑定一组动作来封装一个请求。要达到这一点，命令对象将动作和接收者包进对象。这个对象只暴露出一个execute()方法，当此方法被调用的时候，接收者就会进行这些动作。从外面看，其他对象不知道空间哪个接收者进行了哪些动作，只知道如果调用了execute()方法，请求的目的就能达到。

类图

实现

1. 定义Command接口

    /**
     * 命令定义
     */
    public interface Command {
        /**
         * 执行命令
         */
        void execute();
    
        /**
         * 回退命令
         */
        void undo();
    }

2. 定义命令接口实现类

    /**
     * 包装开灯、关灯指令
     * ConcreteCommand
     */
    public class LightOffCommand implements Command {
        Light light;
        public LightOffCommand(Light light) {
            this.light = light;
        }
    
        @Override
        public void execute() {
            light.off();
        }
    
        @Override
        public void undo() {
            light.on();
        }
    }
    /**
     * 包装开灯、关灯指令
     * ConcreteCommand
     */
    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();
        }
    }

3.定义命令接收者

    /**
     * Receiver
     * 具体指令执行者
     */
    public class Light {
    
        public void on() {
            System.out.println("Light ON.");
        }
        public void off() {
            System.out.println("Light OFF.");
        }
    }

4. 定义调用者

    /**
     * 使用命令对象
     * 假设只有一个遥控器，它只有一个按钮和对应的插槽，可以控制一个装置。
     * Invoker
     */
    public class RemoteControl {
        // 有一个插槽持有命令，而这个命令控制着一个着墨
        private Command[] onCommands;
        private Command[] offCommands;
        private 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;
            }
            undoCommand = noCommand;
        }
    
        /**
         * 设置插槽控制的命令。
         */
        public void setCommand(int slot, Command onComand, Command offCommand) {
            onCommands[slot] = onComand;
            offCommands[slot] = offCommand;
        }
    
        /**
         * 当按下按钮时，这个方法就会被调用。使得当前命令衔接插槽，并调用它的`execute()`方法
         */
        public void onButtonWasPushed(int slot) {
            onCommands[slot].execute();
            undoCommand = onCommands[slot];
        }
    
        public void offButtonWasPushed(int slot) {
            offCommands[slot].execute();
            undoCommand = offCommands[slot];
        }
    
        public void undoButtonWasPushed() {
            undoCommand.undo();
            System.out.println("UNDO");
        }
    
        @Override
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append("\n-------- Remote Control ---------\n");
            for (int i = 0; i < onCommands.length; i++) {
                if (onCommands[i] == null) {
                    continue;
                }
                sb.append("[slot " + i + "] " + onCommands[i].getClass().getName() + "    " + offCommands[i].getClass().getName() + "\n");
            }
            return sb.toString();
        }
    }

5. 定义Client

    public class M {
        /**
         * M 为命令模式的客户。Client
         */
        public static void main(String[] args) {
            // 遥控器就是调用者，会传入一个命令对象，可以用来发出请求
            RemoteControl remoteControl = new RemoteControl();
            // 现在创建了一个电灯对象，此对象也是请求的接收者
            Light light = new Light();
            // 创建一个命令，并将接收者传递给命令
            LightOnCommand lightOnCommand = new LightOnCommand(light);
            LightOffCommand lightOffCommand = new LightOffCommand(light);
    
            // 模拟按下按钮
            // 在简单的遥控器中，我们先用一个 `打开电灯`命令加载按钮插槽，后来替换为`打开车库电灯`命令。
            // 遥控器插槽并根本不在乎所拥有的是什么命令对象。只要该命令对象实现了`command`接口就可以。
            GarageDoor garageDoor = new GarageDoor();
            GarageDoorOnCommand garageDoorOnCommand = new GarageDoorOnCommand(garageDoor);
            GarageDoorOffCommand garageDoorOffCommand = new GarageDoorOffCommand(garageDoor);
    
            remoteControl.setCommand(0, lightOnCommand, lightOffCommand);
            remoteControl.setCommand(1, garageDoorOnCommand, garageDoorOffCommand);
    
            remoteControl.onButtonWasPushed(0);
            remoteControl.onButtonWasPushed(1);
            remoteControl.offButtonWasPushed(0);
            remoteControl.undoButtonWasPushed();
            remoteControl.offButtonWasPushed(1);
    
        }
    }

带状态回滚

    public class CeilingFanOffCommand implements Command {
        CeilingFan ceilingFan;
        // 增加局部状态变量，以便追踪吊扇之前的速度
        int prevSpeed;
        public CeilingFanOffCommand(CeilingFan ceilingFan) {
            this.ceilingFan = ceilingFan;
        }
    
        @Override
        public void execute() {
            // 先将它的状态记录下来，以便需要撤销的时候用到
            prevSpeed = ceilingFan.getSpeed();
            ceilingFan.off();
        }
    
        @Override
        public void undo() {
            if (prevSpeed == 3) {
                ceilingFan.high();
            } else if (prevSpeed == 2) {
                ceilingFan.medium();
            } else if (prevSpeed == 1) {
                ceilingFan.low();
            } else {
                ceilingFan.off();
            }
        }
    }

总结

1. 命令模式可以将动作的请求者从动作的执行者对象中解耦。

• 遥控器应该知道如何解读按钮被按下的动作，然后发出正确的请求。但是不知道这些家电自动化的细节。
• 使用状态实现撤销。
• 命令模式更多用途: 队列请求。命令可以将运算块打包(一个接收者和一组动作)，然后将它传来传去。就像是一般的对象一样。利用这样的特性衍生出: 日程安排(Scheduler)、线程池、工作队列。
• 在某一端添加命令，然后另一端则是线程。线程进行如下操作: 从队列中取出一个命令，调用它的execute()方法，等待这个调用完成，然后将此命令对象丢弃，再取出下一个命令。

1. 每个设计模式都应该由两部分组成: 一是应用场景、二是解决方案。如果只关注代码实现，会产生大部分设计模式看起来很相似的感觉。实际上，设计模式之间的主要区别在于设计意图，即应用场景。

2. 命令模式VS策略模式

   1. 策略模式包含策略的定义、创建和使用三部分。从代码角度看，非常类似于工厂模式。区别在于，策略模式侧重“策略”或“算法”这个特定的应用场景，用来解决根据运行时状态从一组策略中选择不同策略的问题，而工厂模式侧重封装对象的创建过程，这里的对象没有任何业务场景的限定，可以是策略，但也可以是其他东西。从设计意图上来，这两个模式完全是两回事儿。
   2. 命令模式的主要作用和应用场景，是用来控制命令的执行，比如，异步、延迟、排队执行命令、撤销重做命令、存储命令、给命令记录日志等等，这才是命令模式能发挥独一无二作用的地方。