研磨设计模式之 命令模式-3

研磨设计模式之 命令模式-3

3.3  可撤销的操作

        可撤销操作的意思就是：放弃该操作，回到未执行该操作前的状态。这个功能是一个非常重要的功能，几乎所有GUI应用里面都有撤消操作的功能。GUI的菜单是命令模式最典型的应用之一，所以你总是能在菜单上找到撤销这样的菜单项。
        既然这么常用，那该如何实现呢？
        有两种基本的思路来实现可撤销的操作，一种是补偿式，又称反操作式：比如被撤销的操作是加的功能，那撤消的实现就变成减的功能；同理被撤销的操作是打开的功能，那么撤销的实现就变成关闭的功能。
        另外一种方式是存储恢复式，意思就是把操作前的状态记录下来，然后要撤销操作的时候就直接恢复回去就可以了。
        这里先讲第一种方式，就是补偿式或者反操作式，第二种方式放到备忘录模式中去讲解。为了让大家更好的理解可撤销操作的功能，还是用一个例子来说明会比较清楚。
1：范例需求
        考虑一个计算器的功能，最简单的那种，只能实现加减法运算，现在要让这个计算器支持可撤销的操作。
2：补偿式或者反操作式的解决方案
（1）在实现命令接口之前，先来定义真正实现计算的接口，没有它命令什么都做不了，操作运算的接口的示例代码如下：

代码

 1 /**
 2  * 操作运算的接口
 3  */
 4 public interface OperationApi {
 5     /**
 6      * 获取计算完成后的结果
 7      * @return 计算完成后的结果
 8      */
 9     public int getResult();
10     /**
11      * 设置计算开始的初始值
12      * @param result 计算开始的初始值
13      */
14     public void setResult(int result);
15     /**
16      * 执行加法
17      * @param num 需要加的数
18      */
19     public void add(int num);
20     /**
21      * 执行减法
22      * @param num 需要减的数
23      */
24     public void substract(int num);
25 }
26 

定义了接口，来看看真正执行加减法的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/**   * 运算类，真正实现加减法运算   */ public  class  Operation implements  OperationApi{      /**       * 记录运算的结果       */      private  int  result;      public  int  getResult() {          return  result;      }      public  void  setResult( int  result) {          this .result = result;      }        public  void  add( int  num){          //实现加法功能          result += num;      }      public  void  substract( int  num){          //实现减法功能          result -= num;      } }

 

（2）接下来，来抽象命令接口，由于要支持可撤销的功能，所以除了跟前面一样定义一个执行方法外，还需要定义一个撤销操作的方法，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

/**   * 命令接口，声明执行的操作，支持可撤销操作   */ public  interface  Command {      /**       * 执行命令对应的操作       */      public  void  execute();      /**       * 执行撤销命令对应的操作       */      public  void  undo(); }

（3）应该来实现命令了，具体的命令分成了加法命令和减法命令，先来看看加法命令的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

/**   * 具体的加法命令实现对象   */ public  class  AddCommand implements  Command{      /**       * 持有具体执行计算的对象       */      private  OperationApi operation = null ;      /**       * 操作的数据，也就是要加上的数据       */      private  int  opeNum;            public  void  execute() {          //转调接收者去真正执行功能，这个命令是做加法          this .operation.add(opeNum);      }      public  void  undo() {          //转调接收者去真正执行功能          //命令本身是做加法，那么撤销的时候就是做减法了          this .operation.substract(opeNum);      }                /**       * 构造方法，传入具体执行计算的对象       * @param operation 具体执行计算的对象       * @param opeNum 要加上的数据       */      public  AddCommand(OperationApi operation, int  opeNum){          this .operation = operation;          this .opeNum = opeNum;      } }

减法命令和加法类似，只是在实现的时候和加法反过来了，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

/**   * 具体的减法命令实现对象   */ public  class  SubstractCommand implements  Command{      /**       * 持有具体执行计算的对象       */      private  OperationApi operation = null ;      /**       * 操作的数据，也就是要减去的数据       */      private  int  opeNum;      /**       * 构造方法，传入具体执行计算的对象       * @param operation 具体执行计算的对象       * @param opeNum 要减去的数据       */      public  SubstractCommand(OperationApi operation, int  opeNum){          this .operation = operation;          this .opeNum = opeNum;      }              public  void  execute() {          //转调接收者去真正执行功能，这个命令是做减法          this .operation.substract(opeNum);      }        public  void  undo() {          //转调接收者去真正执行功能          //命令本身是做减法，那么撤销的时候就是做加法了          this .operation.add(opeNum);      } }

（4）接下来应该看看计算器了，计算器就相当于Invoker，持有多个命令对象，计算器是实现可撤销操作的地方。
为了大家更好的理解可撤销的功能，先来看看不加可撤销操作的计算器类什么样子，然后再添加上可撤销的功能示例。示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

/**   * 计算器类，计算器上有加法按钮、减法按钮   */ public  class  Calculator {      /**       * 持有执行加法的命令对象       */      private  Command addCmd = null ;      /**       * 持有执行减法的命令对象       */      private  Command substractCmd = null ;      /**       * 设置执行加法的命令对象       * @param addCmd 执行加法的命令对象       */      public  void  setAddCmd(Command addCmd) {          this .addCmd = addCmd;      }      /**       * 设置执行减法的命令对象       * @param substractCmd 执行减法的命令对象       */      public  void  setSubstractCmd(Command substractCmd) {          this .substractCmd = substractCmd;      }        /**       * 提供给客户使用，执行加法功能       */      public  void  addPressed(){          this .addCmd.execute();      }      /**       * 提供给客户使用，执行减法功能       */      public  void  substractPressed(){          this .substractCmd.execute();      } }

 目前看起来跟前面的例子实现得差不多，现在就在这个基本的实现上来添加可撤销操作的功能。
要想实现可撤销操作，首先就需要把操作过的命令记录下来，形成命令的历史列表，撤销的时候就从最后一个开始执行撤销。因此我们先在计算器类里面加上命令历史列表，示例代码如下：

?

1 2 3 4

/** * 命令的操作的历史记录，在撤销时候用 */ private  List<Command> undoCmds = new  ArrayList<Command>();

什么时候向命令的历史记录里面加值呢？
        很简单，答案是在每个操作按钮被按下的时候，也就是你操作加法按钮或者减法按钮的时候，示例代码如下

?

1 2 3 4 5 6 7 8 9 10

public  void  addPressed(){          this .addCmd.execute();          //把操作记录到历史记录里面          undoCmds.add( this .addCmd);      }      public  void  substractPressed(){          this .substractCmd.execute();          //把操作记录到历史记录里面          undoCmds.add( this .substractCmd);      }

 然后在计算器类里面添加上一个撤销的按钮，如果它被按下，那么就从命令历史记录里取出最后一个命令来撤销，撤消完成后要把已经撤销的命令从历史记录里面删除掉，相当于没有执行过该命令了，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11

public  void  undoPressed(){      if ( this .undoCmds.size()> 0 ){          //取出最后一个命令来撤销          Command cmd = this .undoCmds.get( this .undoCmds.size()- 1 );          cmd.undo();          //然后把最后一个命令删除掉，          this .undoCmds.remove(cmd);      } else {          System.out.println( "很抱歉，没有可撤销的命令" );      } }

同样的方式，还可以实现恢复的功能，也为恢复设置一个可恢复的列表，需要恢复的时候从列表里面取最后一个命令进行重新执行就好了，示例代码如下：

?

1 2 3 4

/** * 命令被撤销的历史记录，在恢复时候用 */ private  List<Command> redoCmds = new  ArrayList<Command>();

       那么什么时候向这个集合里面赋值呢？大家要注意，恢复的命令数据是来源于撤销的命令，也就是说有撤销才会有恢复，所以在撤销的时候向这个集合里面赋值，注意要在撤销的命令被删除前赋值。示例代码如下: 

?

1 2 3 4 5 6 7 8 9 10 11 12 13

public  void  undoPressed(){      if ( this .undoCmds.size()> 0 ){          //取出最后一个命令来撤销          Command cmd = this .undoCmds.get( this .undoCmds.size()- 1 );          cmd.undo();          //如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面          this .redoCmds.add(cmd);          //然后把最后一个命令删除掉，          this .undoCmds.remove(cmd);      } else {          System.out.println( "很抱歉，没有可撤销的命令" );      } }

那么如何实现恢复呢？请看示例代码： 

?

1 2 3 4 5 6 7 8 9 10 11 12 13

public  void  redoPressed(){      if ( this .redoCmds.size()> 0 ){          //取出最后一个命令来重做          Command cmd = this .redoCmds.get( this .redoCmds.size()- 1 );          cmd.execute();               //把这个命令记录到可撤销的历史记录里面                        this .undoCmds.add(cmd);          //然后把最后一个命令删除掉          this .redoCmds.remove(cmd);      } else {          System.out.println( "很抱歉，没有可恢复的命令" );      } }

 

 好了，分步讲解了计算器类，一起来看看完整的计算器类的代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

/**   * 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮   */ public  class  Calculator {      /**       * 命令的操作的历史记录，在撤销时候用       */      private  List<Command> undoCmds = new  ArrayList<Command>();      /**       * 命令被撤销的历史记录，在恢复时候用       */      private  List<Command> redoCmds = new  ArrayList<Command>();            private  Command addCmd = null ;      private  Command substractCmd = null ;      public  void  setAddCmd(Command addCmd) {          this .addCmd = addCmd;      }      public  void  setSubstractCmd(Command substractCmd) {          this .substractCmd = substractCmd;      }        public  void  addPressed(){          this .addCmd.execute();          //把操作记录到历史记录里面          undoCmds.add( this .addCmd);      }      public  void  substractPressed(){          this .substractCmd.execute();          //把操作记录到历史记录里面          undoCmds.add( this .substractCmd);      }      public  void  undoPressed(){          if ( this .undoCmds.size()> 0 ){              //取出最后一个命令来撤销              Command cmd = this .undoCmds.get(undoCmds.size()- 1 );              cmd.undo();              //如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面              this .redoCmds.add(cmd );              //然后把最后一个命令删除掉，              this .undoCmds.remove(cmd);          } else {              System.out.println( "很抱歉，没有可撤销的命令" );          }      }      public  void  redoPressed(){          if ( this .redoCmds.size()> 0 ){              //取出最后一个命令来重做              Command cmd = this .redoCmds.get(redoCmds.size()- 1 );              cmd.execute();                   //把这个命令记录到可撤销的历史记录里面              this .undoCmds.add(cmd);              //然后把最后一个命令删除掉              this .redoCmds.remove(cmd);          } else {              System.out.println( "很抱歉，没有可恢复的命令" );          }      } }

（5）终于到可以收获的时候了，写个客户端，组装好命令和接收者，然后操作几次命令，来测试一下撤销和恢复的功能，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

public  class  Client {      public  static  void  main(String[] args) {          //1：组装命令和接收者          //创建接收者          OperationApi operation = new  Operation();          //创建命令对象，并组装命令和接收者          AddCommand addCmd = new  AddCommand   (operation, 5 );          SubstractCommand substractCmd =                                      new  SubstractCommand(operation, 3 );                    //2：把命令设置到持有者，就是计算器里面          Calculator calculator = new  Calculator();          calculator.setAddCmd(addCmd);          calculator.setSubstractCmd(substractCmd);                    //3:模拟按下按钮，测试一下          calculator.addPressed();          System.out.println( "一次加法运算后的结果为："                                       +operation.getResult());          calculator.substractPressed();          System.out.println( "一次减法运算后的结果为："                                       +operation.getResult());                    //测试撤消          calculator.undoPressed();          System.out.println( "撤销一次后的结果为："                                       +operation.getResult());          calculator.undoPressed();          System.out.println( "再撤销一次后的结果为："                                       +operation.getResult());                    //测试恢复          calculator.redoPressed();          System.out.println( "恢复操作一次后的结果为："                                       +operation.getResult());          calculator.redoPressed();          System.out.println( "再恢复操作一次后的结果为："                                       +operation.getResult());      } }

（6）运行一下，看看结果，享受一下可以撤销和恢复的操作，结果如下：

?

1 2 3 4 5 6

一次加法运算后的结果为： 5 一次减法运算后的结果为： 2 撤销一次后的结果为： 5 再撤销一次后的结果为： 0 恢复操作一次后的结果为： 5 再恢复操作一次后的结果为： 2

也就是初始值为0，执行的两次命令操作为先加上5，然后再减去3。看起来也很容易，对不。