设计模式之命令模式

爱被打了一巴掌 2022-12-18 04:53 115阅读 0赞

需求:  对于不同的智能家电设备，这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个App，分别控制，我们希望只要一个App就可以控制全部智能家电. 要实现一个app控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给app调用，这时就可以考虑使用命令模式。命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来。在这里,动作的请求者是手机app，动作的执行者是每个厂商的一个家电产品.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70][]

命令模式的基本**UML**类图:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 1][]

*  **Command** 一个具体命令的抽象接口。
 *  **ConcreteCommand** 就是其具体的一个实现，你可以有多个`Command`接口的具体实现。具体命令本身并不实现具体的业务命令， 而是会将调用委派给一个业务逻辑对象去执行。
 *  **Receiver** 作为具体命令的最终接收者。几乎任何对象都可以作为接收者，命令的细节由**Receiver**来实现。
 *  **Invoker** 携带命令执行 `action`请求。它不负责创建命令对象，它通常会通过构造函数从客户端处获得预先生成的命令。
 *  **Client** 发起具体的命令交给**Invoker**去执行。

命令模式在开发中适用的情况:  
      1.系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。  
      2.系统需要在不同的时间指定请求、将请求排队和执行请求。  
      3.系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。  
      4.系统需要将一组操作组合在一起，即支持宏命令。

命令模式应用非常普遍，我们常见的断路器组件**Hystrix**，还有**Java**多线程中的线程池`ThreadPoolExecutor`都用到了命令模式,后面我将逐一分析他们的实现代码.

下面我们进行一个模拟的实现,类图如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 2][]

1. 先创建命令接口:

package com.yc.commandpattern;
    
    public interface Command {
        /**
         * 执行动作（操作）
         */
        public void execute();
    
        /**
         * 撤销动作（操作）
         */
        public void undo();
    
    }

2. 再创建一个接收器的接口

package com.yc.commandpattern;
    
    //命令接收器接口
    public interface Device {
        //开机
        public void turnOn();
        //关机
        public void turnOff();
    
    }

3. 对命令的接口，我们做两种设备对这些命令的实现，一是TV 智能电视， 另一个是 智勇日光灯的实现.

a. TV智能电视的功能的实现.,包括开机和关机.

package com.yc.commandpattern.tv;
    
    import com.yc.commandpattern.Device;
    
    //智能电视的实现
    public class TvReceiver implements Device {
    
        @Override
        public void turnOn() {
            System.out.println("智能电视开机");
        }
    
        @Override
        public void turnOff() {
            System.out.println("智能电视关机");
        }
    
    
    }

TV智能电视的命令的功能实现.

1. 开机命令

package com.yc.commandpattern.tv;
    
    import com.yc.commandpattern.Command;
    import com.yc.commandpattern.Device;
    
    public class TvOnCommand implements Command {
        //智能电视的真实设备
        private Device device;
    
        public TvOnCommand(  Device device){
            this.device=device;
        }
    
    
        @Override
        public void execute() {
            this.device.turnOn();
        }
    
        @Override
        public void undo() {
            this.device.turnOff();
        }
    }

2. 关机命令

package com.yc.commandpattern.tv;
    
    import com.yc.commandpattern.Command;
    import com.yc.commandpattern.Device;
    
    public class TvOffCommand implements Command {
        /**
         * 聚合TVReceiver
         */
        private Device tvReceiver;
    
        public TvOffCommand(Device tvReceiver) {
            this.tvReceiver = tvReceiver;
        }
    
        @Override
        public void execute() {
            tvReceiver.turnOff();
        }
    
        @Override
        public void undo() {
            tvReceiver.turnOn();
        }
    }

a. 智能灯的功能的实现.,包括开机和关机.

package com.yc.commandpattern.light;
    
    import com.yc.commandpattern.Device;
    
    public class LightReceiver implements Device {
    
        @Override
        public void turnOn() {
            System.out.println(" 电灯打开了。。。 ");
        }
    
        @Override
        public void turnOff() {
            System.out.println(" 电灯关闭了。。。 ");
        }
    
    }

智能灯命令的实现:

1)开灯

package com.yc.commandpattern.light;
    
    import com.yc.commandpattern.Command;
    import com.yc.commandpattern.Device;
    
    public class LightOnCommand implements Command {
        //灯的真实设备
        private Device device;
    
        public LightOnCommand(  Device device){
            this.device=device;
        }
    
        @Override
        public void execute() {
            this.device.turnOn();
        }
    
        @Override
        public void undo() {
            this.device.turnOff();
        }
    }

2). 关灯

package com.yc.commandpattern.light;
    
    import com.yc.commandpattern.Command;
    import com.yc.commandpattern.Device;
    
    //关灯的命令
    public class LightOffCommand implements Command {
        //灯的真实设备
        private Device device;
    
        public LightOffCommand(  Device device){
            this.device=device;
        }
    
        @Override
        public void execute() {
            this.device.turnOff();
        }
    
        @Override
        public void undo() {
            this.device.turnOn();
        }
    }

另外再实现一个命令的空实现:

package com.yc.commandpattern;
    
    public class NoCommand implements Command{
        @Override
        public void execute() {
    
        }
        @Override
        public void undo() {
    
        }
    }

最后来实现Invoker, 我们可以将它理解成一个遥控器(或是一个用于发出命令，并记录命令队列顺序的容器) .

package com.yc.commandpattern.controller;
    
    import com.yc.commandpattern.Command;
    import com.yc.commandpattern.NoCommand;
    
    //可以理解为遥控器
    public class RemoteControllerInvoker {
        // 打开 按钮的命令数组
        private Command[] onCommands;
        //关闭 的命令数组
        private Command[] offCommands;
    
        // 执行撤销的命令
        private Command undoCommand;
    
        /**
         * 构造器，完成对按钮初始化
         */
        public RemoteControllerInvoker() {
            onCommands = new Command[5];
            offCommands = new Command[5];
    
            for (int i = 0;i < 5; i++) {
                onCommands[i] = new NoCommand();
                offCommands[i] = new NoCommand();  //初始化时，对按钮初始化了空命令,这样从数组中取命令时，就不用判断是否为空了
            }
        }
    
        /**
         * 给我们的按钮设置你需要的命令
         * @param no
         * @param onCommand
         * @param offCommand
         */
        public void setCommand(int no, Command onCommand, Command offCommand) {
            onCommands[no] = onCommand;
            offCommands[no] = offCommand;
        }
    
        /**
         * 按下开按钮
         * @param no
         */
        public void onButtonWasPushed(int no) {
            // 找到你按下的开的按钮，并调用对应的方法
            onCommands[no].execute();
            // 记录这次的操作，用于撤销
            undoCommand = onCommands[no];
        }
    
        /**
         * 按下关的按钮
         * @param no
         */
        public void offButtonWasPushed(int no) {
            // 找到你按下的关的按钮，并调用对应方法
            offCommands[no].execute();
            // 记录这次的操作，用于撤销
            undoCommand = offCommands[no];
        }
    
        /**
         * 按下撤销按钮
         */
        public void undoButtonWasPushed() {
            undoCommand.undo();
        }
    
    }

解析:

1) NoCommand 空命令也是一种设计模式，它为我们省去判空的操作。在上面的实例中，如果没有空命令，每按下一个按键都要判空，这会给编码带来一定麻烦。

2) 可以设计了一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令。

3) 将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要命令对象的execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说 ：“请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。

4) 实现了对请求的撤销和重做

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70]: /images/20221122/6d181f720bed4837bb164298cc7e64d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 1]: /images/20221122/9673074b2ebc4587b11f90a7eabded3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 2]: /images/20221122/0cd37bb4f53e49e8b44e6e4d1593fd83.png