设计模式之禅【命令模式】

绝地灬酷狼 2022-06-02 09:46 152阅读 0赞

# 真刀实枪之命令模式 #

*  项目经理也难当--难做的事千千万，想办法去解决~.~
    
     *  带过项目的经理有这样的感受：很多项目，行政命令一压下来，那就一条道--做完做好!
 *  从项目合作进入
    
    1.  需求组（Requirement Group，RG）
    2.  美工组（Page Group，PG）
    3.  代码组（来个好听的名字：逻辑实现组）（Code Group，CG）
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70][]
    
     *  Group
        
            package com.peng.ml;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public abstract class Group {
                // 找到相应的组
                public abstract void find();
            
                // 被要求增加功能
                public abstract void add();
            
                // 被要求删除功能
                public abstract void delete();
            
                // 被要求修改功能
                public abstract void change();
            
                // 被要求给出所有的变更计划
                public abstract void plan();
            }
     *  RequirementGroup
        
            package com.peng.ml;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class RequirementGroup extends Group {
            
                @Override
                public void find() {
                    System.out.println("找到需求组！");
                }
            
                @Override
                public void add() {
                    System.out.println("要求需求组增加一个功能！");
                }
            
                @Override
                public void delete() {
                    System.out.println("要求需求组删除一个功能！");
                }
            
                @Override
                public void change() {
                    System.out.println("要求需求组修改一个功能！");
                }
            
                @Override
                public void plan() {
                    System.out.println("要求需求组修改计划！");
                }
            
            }
     *  PageGroup
        
            package com.peng.ml;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class PageGroup extends Group {
            
                @Override
                public void find() {
                    System.out.println("找到美工组！");
                }
            
                @Override
                public void add() {
                    System.out.println("要求美工组增加一个功能！");
                }
            
                @Override
                public void delete() {
                    System.out.println("要求美工组删除一个功能！");
                }
            
                @Override
                public void change() {
                    System.out.println("要求美工组修改一个功能！");
                }
            
                @Override
                public void plan() {
                    System.out.println("要求美工组修改计划！");
                }
            
            }
     *  CodeGroup
        
            package com.peng.ml;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class CodeGroup extends Group {
            
                @Override
                public void find() {
                    System.out.println("找到逻辑实现组！");
                }
            
                @Override
                public void add() {
                    System.out.println("要求逻辑实现组增加一个功能！");
                }
            
                @Override
                public void delete() {
                    System.out.println("要求逻辑实现组删除一个功能！");
                }
            
                @Override
                public void change() {
                    System.out.println("要求逻辑实现组修改一个功能！");
                }
            
                @Override
                public void plan() {
                    System.out.println("要求逻辑实现组修改计划！");
                }
            
            }
     *  Client
        
            package com.peng.ml;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class Client {
                public static void main(String[] args) {
                    // 需求变动
                    Group gp1 = new RequirementGroup();
                    gp1.find();
                    gp1.add();
                    // 界面变动
                    Group gp2 = new PageGroup();
                    gp2.find();
                    gp2.delete();
                    // 逻辑变动
                    Group gp3 = new CodeGroup();
                    gp3.find();
                    gp3.change();
                }
            }
     *  运行结果
        
            找到需求组！
            要求需求组增加一个功能！
            找到美工组！
            要求美工组删除一个功能！
            找到逻辑实现组！
            要求逻辑实现组修改一个功能！
 *  类图展示过程
    
     *  上面的过程中，遇到个问题来通知各个组类进行相应的工作，这种方式不仅浪费时间，而且容易出错
        
         *  美工说：“需求这么写的！”
         *  逻辑实现人员说：“界面是这么画的，需求的要求是这么规定的”
         *  感觉需求老躺枪啊，为你感到不平，但你的不确定性确实该规范规范啦！
     *  来吧，代码逻辑工作者们，受不了就解决呗!
        
         *  类图先上
            
             *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1][]
             *  在原有的类图上增加了一个Invoker类，其作用是根据客户的命令安排不同的组员进行工作--只是String给命令不是一个很好的方案。
                
                 *  解决方案--对客户的命令进行封装，每个命令是一个对象，避免客户、负责人、组员之间的交流出差错
                 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2][]
                 *  类图说明
                    
                     *  Command抽象类：客户发来的命令，定义三个工作组中的成员变量，供子类使用，execute来执行命令
                     *  Invoker实现类：项目接头负责人
                 *  代码
                    
                     *  Command
                        
                            package com.peng.ml;
                            
                            /**
                             * @author kungfu~peng
                             * @data 2017年11月21日
                             * @description
                             */
                            public abstract class Command {
                                // 定义三组成员
                                protected RequirementGroup rg = new RequirementGroup();
                                protected PageGroup pg = new PageGroup();
                                protected CodeGroup cg = new CodeGroup();
                            
                                // 命令执行的方法
                                public abstract void execute();
                            }
                     *  DeletePageCommand
                        
                            package com.peng.ml;
                            
                            /**
                             * @author kungfu~peng
                             * @data 2017年11月21日
                             * @description
                             */
                            public class DeletePageCommand extends Command {
                                // 执行增加一项需求的命令
                                @Override
                                public void execute() {
                                    // 找到美工组
                                    super.pg.find();
                                    // 删除界面
                                    super.pg.delete();
                                    // 给出计划
                                    super.pg.plan();
                                }
                            
                            }
                     *  AddRequirementCommand
                        
                            package com.peng.ml;
                            
                            /**
                             * @author kungfu~peng
                             * @data 2017年11月21日
                             * @description
                             */
                            public class AddRequirementCommand extends Command {
                                // 执行增加一项需求的命令
                                @Override
                                public void execute() {
                                    // 找到需求组
                                    super.rg.find();
                                    // 增加需求
                                    super.rg.add();
                                    // 给出计划
                                    super.rg.plan();
                                }
                            
                            }
                     *  Invoker
                        
                            package com.peng.ml;
                            
                            /**
                             * @author kungfu~peng
                             * @data 2017年11月21日
                             * @description 负责人
                             */
                            public class Invoker {
                                private Command command;
                            
                                // 客户发出命令
                                public void setCommand(Command command) {
                                    this.command = command;
                                }
                            
                                // 执行命令
                                public void action() {
                                    this.command.execute();
                                }
                            }
                     *  Client
                        
                            package com.peng.ml;
                            
                            /**
                             * @author kungfu~peng
                             * @data 2017年11月21日
                             * @description
                             */
                            public class Client {
                                public static void main(String[] args) {
                                    // 定义接头人
                                    Invoker invoker = new Invoker();
                                    // 客户要求增加一个需求
                                    Command command = new AddRequirementCommand();
                                    // 接头人接收命令
                                    invoker.setCommand(command);
                                    // 执行命令
                                    invoker.action();
                            
                                    // 客户要求删除一个界面
                                    Command command2 = new DeletePageCommand();
                                    // 接头人接收命令
                                    invoker.setCommand(command2);
                                    // 执行命令
                                    invoker.action();
                                }
                            }
                     *  Group，CodeGroup，PageGroup，RequirementGroup同上

### 命令模式的定义 ###

*  Encapsulate a request as an object,thereby letting you parameterize clients with different requests,queue or log requests,and support undoable operations.(将一个请求封装成一个对象，从而让你使用不同的请求将客户端参数化，对请求排队或者记录请求日志。可以提供命令的撤销和恢复功能)
 *  命令模式的通用类图
    
     *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3][]
     *  在类图中，有三个角色
        
        1.  Receiver接受者角色--干活滴
        2.  Command命令角色
        3.  Invoker调用者角色--项目经理就是他
 *  命令模式的通用代码
    
     *  Receiver
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public abstract class Receiver {
                // 抽象接收者，定义每个接收者都必须完成的业务
                public abstract void doSomething();
            }
     *  ConcreteReceiver1
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class ConcreteReceiver1 extends Receiver {
                @Override
                public void doSomething() {
                    // 业务逻辑
                    System.out.println("业务逻辑1~~~");
                }
            
            }
     *  ConcreteReceiver2
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class ConcreteReceiver2 extends Receiver {
                @Override
                public void doSomething() {
                    // 业务逻辑
                    System.out.println("业务逻辑2~~~");
                }
            
            }
     *  Command
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public abstract class Command {
                // 执行命令的方法
                public abstract void execute();
            }
     *  ConcreteCommand1
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class ConcreteCommand1 extends Command {
                // 对哪个Receiver类进行命令处理
                private Receiver receiver;
            
                // 构造函数传递接受者
                public ConcreteCommand1(Receiver receiver) {
                    super();
                    this.receiver = receiver;
                }
            
                @Override
                public void execute() {
                    // 业务处理
                    this.receiver.doSomething();
                }
            
            }
     *  ConcreteCommand2
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class ConcreteCommand2 extends Command {
                // 对哪个Receiver类进行命令处理
                private Receiver receiver;
            
                // 构造函数传递接受者
                public ConcreteCommand2(Receiver receiver) {
                    super();
                    this.receiver = receiver;
                }
            
                @Override
                public void execute() {
                    // 业务处理
                    this.receiver.doSomething();
                }
            
            }
     *  Invoker
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class Invoker {
                private Command command;
            
                // 受气包，接收命令
                public void setCommand(Command command) {
                    this.command = command;
                }
            
                // 执行命令
                public void action() {
                    this.command.execute();
                }
            }
     *  Client
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class Client {
                public static void main(String[] args) {
                    // 声明调用者
                    Invoker invoker = new Invoker();
                    // 定义接收者
                    Receiver r1 = new ConcreteReceiver1();
                    // 定义一个命令
                    Command c1 = new ConcreteCommand1(r1);
                    // 把命令交给调用者
                    invoker.setCommand(c1);
                    // 执行命令
                    invoker.action();
            
                    // 定义接收者
                    Receiver r2 = new ConcreteReceiver2();
                    // 定义一个命令
                    Command c2 = new ConcreteCommand1(r2);
                    // 把命令交给调用者
                    invoker.setCommand(c2);
                    // 执行命令
                    invoker.action();
                }
            }
     *  执行结果
        
            业务逻辑1~~~
            业务逻辑2~~~

### 命令模式的应用 ###

*  命令模式的优点
    
    1.  类间解耦：调用者与接受者直接没有任何依赖关系，调用者实现功能时只需要调用、Command抽象类的execute方法就可以，不需要了解到底是哪个接受者执行
    2.  可扩展性：Command的子类可以非常容易的扩展，而调用者和高层次的模块Client不产生严重的代码耦合
    3.  命令模式结合其他模式会更优秀：命令模式可以结合责任链模式，实现命令解析任务；结合模板方法模式，则可以减少Command的子类膨胀问题
 *  命令模式的缺点
    
    1.  Command类的子类可能膨胀的会很大

### 命令模式的使用场景 ###

*  只要是命令的地方就可以采用命令模式
    
     *  GUI开发中：一个按钮的点击事件
     *  模拟DOS命令的时候
     *  触发-反馈机制的处理

### 命令模式的扩展 ###

*  接着咱们的故事
    
    1.  用户增加一项要求，不用命令模式的话需要一个一个挨着找，然后通知他们要完成的工作，而用命令模式的话，直接在execute的方法中调用就可以了
        
            @Override
            public void execute() {
                // 找到需求组
                super.rg.find();
                // 增加需求
                super.rg.add();
                // 给出计划
                super.rg.plan();
            
                // 找到美工组
                super.pg.find();
                // 删除页面
                super.pg.delete();
                // 给出计划
                super.pg.plan();
            
                // 找到逻辑实现组
                super.cg.find();
                // 添加功能
                super.cg.add();
                // 给出计划
                super.cg.plan();
            }
    2.  反悔问题：发出的命令要撤销
        
            1. 方法1：备忘录模式还原最后的状态，该方法适合接收者为状态的变更，不适合事件的处理。
            2. 方法2：实现事件的回滚--反命令（撤销之前的命令--日志的回滚机制）
                //Group组中加入一个回滚方法
                public void rollBack(){
                    //根据日志进行回滚
                }
            
                //命令--撤销命名
                public class CancelDeletePageCommand extends Command{
                    //撤销删除一个页面的命令
                    super.pg.rollBack();
                }

### 最佳实践 ###

*  在仔细回想上面的通用类图，Receiver并没有暴露给Client，而在通用的类图和源码中却出现了Client对Receiver的角色依赖，这是为什么？
    
     *  一个模式在实际应用中，都有一些变形，Receiver在一般的使用中都会封装，（除非非常必要，如撤销处理），那是因为在项目中：约定的优先级最高，每一个命令是对一个或多个Receiver的封装，我们可以在项目中通过有意义的类名或命令名，来处理命令角色和接受者角色的耦合关系（这就是约定），减少高层模块（Client类）对低层模块的依赖关系，提高系统的整体的稳定性，因此，建议在实际的项目开发中采用封闭Receiver的方式【适合的才是最好的！】。
     *  Command
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public abstract class Command {
                //定义一个子类共享的全局共享变量
                protected final Receiver receiver;
                //实现类必须定义一个接受者
            
                public Command(Receiver receiver){
                    this.receiver=receiver;
                } 
            
                // 执行命令的方法
                public abstract void execute();
            }
     *  ConcreteCommand1
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class ConcreteCommand1 extends Command {
            
                // 构造函数传递接受者
                public ConcreteCommand1(Receiver receiver) {
                    super(receiver);
                }
            
                public ConcreteCommand1() {
                    super(new ConcreteReceiver1());
                }
            
                @Override
                public void execute() {
                    // 业务处理
                    super.receiver.doSomething();
                }
            
            }
     *  高层不需要知道接收者--Client
        
            package ml2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月21日
             * @description
             */
            public class Client {
                public static void main(String[] args) {
                    // 声明调用者
                    Invoker invoker = new Invoker();
                    // 定义一个命令
                    Command c1 = new ConcreteCommand1();
                    // 把命令交给调用者
                    invoker.setCommand(c1);
                    // 执行命令
                    invoker.action();
                }
            }
     *  执行结果
        
            业务逻辑1~~~

### 声明 ###

*  摘自秦小波《设计模式之禅》第2版；
 *  仅供学习，严禁商业用途；
 *  代码手写，没有经编译器编译，有个别错误，自行根据上下文改正。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70]: /images/20220602/542bd474ff51454ebe6beefb48b6b01f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1]: /images/20220602/916c942459bd460898fb1966c242b489.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2]: /images/20220602/e9403556c8a5488999a95b7ea1155266.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3]: /images/20220602/a5b7f5cea4f94e669975d7e29dac3af3.png