研磨设计模式之命令模式-3(转)

最新推荐文章于 2023-11-10 07:00:00 发布

seaizon

最新推荐文章于 2023-11-10 07:00:00 发布

阅读量63

点赞数

分类专栏：设计模式文章标签：设计模式 Blog

本文链接：https://blog.csdn.net/seaizon/article/details/83702111

版权

设计模式专栏收录该内容

35 篇文章 0 订阅

订阅专栏

3.3 可撤销的操作

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

Java代码

/**
* 操作运算的接口
*/
public interface OperationApi {
/**
* 获取计算完成后的结果
* @return 计算完成后的结果
*/
public int getResult();
/**
* 设置计算开始的初始值
* @param result 计算开始的初始值
*/
public void setResult( int result);
/**
* 执行加法
* @param num 需要加的数
*/
public void add( int num);
/**
* 执行减法
* @param num 需要减的数
*/
public void substract( int num);
}

/**
 * 操作运算的接口
 */
public interface OperationApi {
	/**
	 * 获取计算完成后的结果
	 * @return 计算完成后的结果
	 */
	public int getResult();
	/**
	 * 设置计算开始的初始值
	 * @param result 计算开始的初始值
	 */
	public void setResult(int result);
	/**
	 * 执行加法
	 * @param num 需要加的数
	 */
	public void add(int num);
	/**
	 * 执行减法
	 * @param num 需要减的数
	 */
	public void substract(int num);
}

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

Java代码

/**
* 运算类，真正实现加减法运算
*/
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;
}
}

/**
 * 运算类，真正实现加减法运算
 */
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）接下来，来抽象命令接口，由于要支持可撤销的功能，所以除了跟前面一样定义一个执行方法外，还需要定义一个撤销操作的方法，示例代码如下：

Java代码

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

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

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

Java代码

/**
* 具体的加法命令实现对象
*/
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;
}
}

/**
 * 具体的加法命令实现对象
 */
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;
	}
}

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

Java代码

/**
* 具体的减法命令实现对象
*/
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);
}
}

/**
 * 具体的减法命令实现对象
 */
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，持有多个命令对象，计算器是实现可撤销操作的地方。
为了大家更好的理解可撤销的功能，先来看看不加可撤销操作的计算器类什么样子，然后再添加上可撤销的功能示例。示例代码如下：

Java代码

/**
* 计算器类，计算器上有加法按钮、减法按钮
*/
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();
}
}

/**
 * 计算器类，计算器上有加法按钮、减法按钮
 */
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();
	}
}

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

Java代码

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

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

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

Java代码

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

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

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

Java代码

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("很抱歉，没有可撤销的命令" );
}
}

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("很抱歉，没有可撤销的命令");
	}
}

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

Java代码

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

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

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

Java代码

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("很抱歉，没有可撤销的命令" );
}
}

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("很抱歉，没有可撤销的命令");
	}
}

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

Java代码

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("很抱歉，没有可恢复的命令" );
}
}

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("很抱歉，没有可恢复的命令");
	}
}

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

Java代码

/**
* 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
*/
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("很抱歉，没有可恢复的命令" );
}
}
}

/**
 * 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
 */
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）终于到可以收获的时候了，写个客户端，组装好命令和接收者，然后操作几次命令，来测试一下撤销和恢复的功能，示例代码如下：

Java代码

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());
}
}

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）运行一下，看看结果，享受一下可以撤销和恢复的操作，结果如下：

Java代码

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

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

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

未完待续......

转载自：http://chjavach.iteye.com/blog/711226

seaizon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
研磨设计模式之命令模式-3(转)

3.3 可撤销的操作可撤销操作的意思就是：放弃该操作，回到未执行该操作前的状态。这个功能是一个非常重要的功能，几乎所有GUI应用里面都有撤消操作的功能。GUI的菜单是命令模式最典型的应用之一，所以你总是能在菜单上找到撤销这样的菜单项。既然这么常用，那该如何实现呢？有两种基本的思路来实现可撤销的操作，一种是补偿式，又称反操作式...
复制链接

扫一扫

专栏目录