文档章节

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

We911
 We911
发布于 2017/02/08 10:13
字数 3120
阅读 0
收藏 0

研磨设计模式之 命令模式-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。看起来也很容易,对不。

本文转载自:http://blog.csdn.net/liduanw/article/details/8192922

We911
粉丝 1
博文 63
码字总数 0
作品 0
深圳
程序员
私信 提问
设计模式 2014-12-19

book: 阎宏《JAVA与模式》 架构设计栏目 http://blog.csdn.net/enterprise/column.html 概要: http://bbs.csdn.net/forums/Embeddeddriver 23种设计模式分别是: 1.单例模式 2.工厂方法模式...

jayronwang
2014/12/19
296
0
【设计模式笔记】(十六)- 代理模式

一、简述 代理模式(Proxy Pattern),为其他对象提供一个代理,并由代理对象控制原有对象的引用;也称为委托模式。 其实代理模式无论是在日常开发还是设计模式中,基本随处可见,中介者模式中...

MrTrying
2018/06/24
0
0
《PHP设计模式大全》系列分享专栏

《PHP设计模式大全》已整理成PDF文档,点击可直接下载至本地查阅 https://www.webfalse.com/read/201739.html 文章 php设计模式介绍之编程惯用法第1/3页 php设计模式介绍之值对象模式第1/5页...

kaixin_code
2018/11/06
185
0
PHP设计模式(一):简介及创建型模式

我们分三篇文章来总结一下设计模式在PHP中的应用,这是第一篇创建型模式。 一、设计模式简介 首先我们来认识一下什么是设计模式: 设计模式是一套被反复使用、容易被他人理解的、可靠的代码设...

juhenj
2014/05/15
286
2
《JavaScript设计模式与开发实践》原则篇(2)—— 最少知识原则

最少知识原则(LKP)说的是一个软件实体应当尽可能少地与其他实体发生相互作用。这 里的软件实体是一个广义的概念,不仅包括对象,还包括系统、类、模块、函数、变量等。 单一职责原则指导我们...

嗨呀豆豆呢
2018/12/30
0
0

没有更多内容

加载失败,请刷新页面

加载更多

一起来学Java8(四)——复合Lambda

在一起来学Java8(二)——Lambda表达式中我们学习了Lambda表达式的基本用法,现在来了解下复合Lambda。 Lambda表达式的的书写离不开函数式接口,复合Lambda的意思是在使用Lambda表达式实现函...

猿敲月下码
30分钟前
9
0
debian10使用putty配置交换机console口

前言:Linux的推广普及,需要配合解决实际应用方能有成效! 最近强迫自己用linux进行实际工作,过程很痛苦,还好通过网络一一解决,感谢各位无私网友博客的帮助! 系统:debian10 桌面:xfc...

W_Lu
今天
10
0
aelf Enterprise 0.8.0 beta有奖公测,“Bug奖金计划”重磅开启

2019年9月30日,aelf Enterprise 0.8.0 beta版正式发布。aelf Enterprise 0.8.0 beta是一个完备的区块链系统, 包含完备的区块链系统、开发套件、开发文档、以及配套的基础应用和基础服务。 ...

AELF开发者社区
今天
10
0
oracle 初始化数据库脚本

create user lpf identified by 123456; create tablespace lpf_ts_cms datafile '/opt/app/oracle/product/11.2.0/lpf.dbf' size 200M; alter user lpf default tablespace lpf_ts_cms; sel......

internetafei
今天
8
0
深入了解Redis底层数据结构

说明 说到Redis的数据结构,我们大概会很快想到Redis的5种常见数据结构:字符串(String)、列表(List)、散列(Hash)、集合(Set)、有序集合(Sorted Set),以及他们的特点和运用场景。不过它们是...

TurboSanil
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部