当前位置:首页 > 开发 > 编程语言 > 设计模式 > 正文

读《研磨设计模式》-代码笔记-备忘录模式-Memento

发表于: 2012-09-23   作者:bylijinnan   来源:转载   浏览:
摘要: 声明: 本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; /* * 备忘录模式的功能是,在不破坏封装性的前提下,捕获一个对象的内部状态,并在对象之外保存这个状态,为以后的状态恢复作“备忘”
声明:
本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/


import java.util.ArrayList;
import java.util.List;



/*
 * 备忘录模式的功能是,在不破坏封装性的前提下,捕获一个对象的内部状态,并在对象之外保存这个状态,为以后的状态恢复作“备忘”
 * 书上给了一个场景,仿真系统:
 * 这个系统有两步操作,第一步操作后,产生一个临时数据(中间数据);
 * 接下来的第二步操作有两种方案,这两种方案都要基于第一步产生的数据作进一步处理
 * 不用备忘录模式的处理方法是:
 * “客户端”调用时,自行创建一个变量来存储该对象第一步操作产生的临时数据,
 * 在第二步操作进行之前,把临时数据再set回到该对象
 * 这就把实现细节暴露到“客户端”去了
 * 看书看到这里时,我想,既然是两步操作共存临时数据又不想暴露给外部,可以用内部类来保存这些数据。接着看下去,果然是这样
 * 另外,为达到“在对象之外保存这个状态”,书上的例子是把“备忘录”作为“备忘录管理者”的类成员来达到这个目的
 * 在“仿真系统”这个例子,似乎不需要“在对象之外保存这个状态”
 */

//不用模式的实现
class WorkflowA {
	
	private String workflowName;		//工作流名字
	private int tempResult;		//临时计算结果
	private String tempState;		//临时状态
	
	public WorkflowA(String workflowName) {
		this.workflowName = workflowName;
	}
	
	public void stepOne() {
		this.tempResult = 1;
		this.tempState = "State of stepOne.";
	}
	
	public void stepTwoSchema1() {
		this.tempResult += 21;
		this.tempState += "--> State of stepTwo by schema1.";
		System.out.println(this.workflowName + " Schema1. result = " + this.tempResult + " state = " + this.tempState);
	}
	
	public void stepTwoSchema2() {
		this.tempResult += 22;
		this.tempState += "--> State of stepTwo by schema2.";
		System.out.println(this.workflowName + " Schema2. result = " + this.tempResult + " state = " + this.tempState);
	}
	
	public int getTempResult() {
		return tempResult;
	}
	public void setTempResult(int tempResult) {
		this.tempResult = tempResult;
	}
	public String getTempState() {
		return tempState;
	}
	public void setTempState(String tempState) {
		this.tempState = tempState;
	}

	public String getWorkflowName() {
		return workflowName;
	}
}


//使用备忘录模式

//备忘录。是一个“窄接口”,空接口
interface IMemento {}

/*
 * WorkflowB在业务逻辑上是和WorkflowA一样的,但增加了备忘录
 * 这里为了偷懒,直接extends WorkflowA了,实际应用中不应该这样
 */
class WorkflowB extends WorkflowA implements Cloneable{
	
	public WorkflowB(String workflowName) {
		super(workflowName);
	}
	
	public IMemento createMemento() {
		return new MementoImpl(this.getTempResult(), this.getTempState());
	}
	
	//备忘录
	private static class MementoImpl implements IMemento {
		
		private int tempResult;
		private String tempState;
		
		MementoImpl(int tempResult, String tempState) {
			this.tempResult = tempResult;
			this.tempState = tempState;
		}

		//提供get方法就好了
		public int getTempResult() {
			return tempResult;
		}

		public String getTempState() {
			return tempState;
		}
	}
	
	//恢复数据到“临时状态”-执行了第一步操作之后
	public void setMemento(IMemento memento) {
		MementoImpl mementoo = (MementoImpl)memento;
		this.setTempResult(mementoo.getTempResult());
		this.setTempState(mementoo.getTempState());
	}
}


//结合原型模式(Prototype)
class WorkflowC extends WorkflowA implements Cloneable{
	
	public WorkflowC(String workflowName) {
		super(workflowName);
	}
	
	public IMemento createMemento() {
		try {
			return new MementoImpl((WorkflowC) this.clone());	//实际应用中要注意浅克隆的问题
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public void setMemento(IMemento memento) {
		MementoImpl mementoo = (MementoImpl)memento;
		this.setTempResult(mementoo.getWorkflow().getTempResult());
		this.setTempState(mementoo.getWorkflow().getTempState());
	}
	
	private static class MementoImpl implements IMemento {
		
		private WorkflowC workflow;

		public MementoImpl(WorkflowC workflow) {
			this.workflow = workflow;
		}
		
		public WorkflowC getWorkflow() {
			return workflow;
		}
		
	}

}
//备忘录管理者 持有了备忘录对象,可把备忘录对象保存到想保存的地方,例如后面提到的保存到xml文件中
class CareTaker {
	
	private IMemento memento;
	
	public void saveMemento(IMemento memento) {
		this.memento = memento;		//这里可以保存到其他地方去,例如写到文件中
	}
	
	public IMemento retriveMemento() {
		return this.memento;		//如果是保存到文件中了,这里就是读文件
	}
}


//扩展:使用备忘录模式来实现可撤销的操作。可与命令模式的实现作对比
interface ICommand {
	
	public void execute();
	
	public void undo(IMemento memento);
	
	public void redo(IMemento memento);
	
	public IMemento createMemento();
	
}


interface IOperation {
	
	public int getResult();
	
	public void add(int num);		//加上num
	
	public void substract(int num);		//减去num
	
	public IMemento createMemento();
	
	public void setMemento(IMemento memento);
	
}


//将Command的一些公共操作提取到抽象的父类中去
abstract class AbstractCommand implements ICommand {
	
	protected IOperation operation;
	
	public void setOperation(IOperation operation) {
		this.operation = operation;
	}
	
	public IMemento createMemento() {
		return this.operation.createMemento();
	}
	
	//不管是撤销操作还是恢复操作,实际都是从备忘录中恢复到指定的状态
	public void redo(IMemento memento) {
		this.operation.setMemento(memento);
	}
	
	public void undo(IMemento memento) {
		this.operation.setMemento(memento);
	}
	
	//具体是什么操作,交由子类来实现
	public abstract void execute();		
}


class AddCommand extends AbstractCommand {

	private int num;		//加数,增量
	
	public void execute() {
		this.operation.add(num);
	}
	
	public AddCommand(int num) {
		this.num = num;
	}
}


class SubstractCommand extends AbstractCommand {

	private int num;		//减数
	
	public void execute() {
		this.operation.substract(num);
	}
	
	public SubstractCommand(int num) {
		this.num = num;
	}
}


class Operation implements IOperation {

	private int result;		//被加数 or 被减数
	
	public void add(int num) {
		this.result += num;
	}

	public void substract(int num) {
		this.result -= num;
	}

	public IMemento createMemento() {
		return new Memento(this.result);
	}

	public int getResult() {
		return result;
	}

	public void setMemento(IMemento memento) {
		Memento mementoo = (Memento)memento;
		this.result = mementoo.getResult();
	}

	private static class Memento implements IMemento {
		
		public Memento(int result) {
			this.result = result;
		}
		
		private int result;

		public int getResult() {
			return result;
		}

		public void setResult(int result) {
			this.result = result;
		}
		
	}
}


class Caculator {
	
	private List<ICommand> undoCmds = new ArrayList<ICommand>();
	
	private List<ICommand> redoCmds = new ArrayList<ICommand>();
	
	//IMemento[2]:两个Memento,一个是操作前,一个是操作后	
	private List<IMemento[]> undoMementos = new ArrayList<IMemento[]>();
	
	private List<IMemento[]> redoMementos = new ArrayList<IMemento[]>();
	
	private ICommand addCommand;
	
	private ICommand substractCommand;

	public void addPressed() {
		IMemento mementoBefore = addCommand.createMemento();
		addCommand.execute();
		undoCmds.add(addCommand);
		IMemento mementoAfter = addCommand.createMemento();
		undoMementos.add(new IMemento[]{mementoBefore, mementoAfter});
	}
	
	public void substractPressed() {
		IMemento mementoBefore = addCommand.createMemento();
		substractCommand.execute();
		undoCmds.add(substractCommand);
		IMemento mementoAfter = substractCommand.createMemento();
		undoMementos.add(new IMemento[]{mementoBefore, mementoAfter});
	}
	
	public void undoPress() {
		if (undoCmds.size() > 0) {
			ICommand cmd = undoCmds.get(undoCmds.size() - 1);
			IMemento[] mementos = undoMementos.get(undoMementos.size() - 1);
			cmd.undo(mementos[0]);
			
			redoCmds.add(cmd);
			redoMementos.add(mementos);
			
			undoCmds.remove(cmd);
			undoMementos.remove(mementos);
		} else {
			System.out.println("没有可撤销的命令");
		}
	}
	
	public void redoPressed() {
		if (redoCmds.size() > 0) {
			ICommand cmd = redoCmds.get(redoCmds.size() - 1);
			IMemento[] mementos = redoMementos.get(redoMementos.size() - 1);
			cmd.redo(mementos[1]);
			
			undoCmds.add(cmd);
			undoMementos.add(mementos);
			
			redoCmds.remove(cmd);
			redoMementos.remove(mementos);
		} else {
			System.out.println("没有可恢复的命令");
		}
	}
	
	public void setAddCommand(ICommand addCommand) {
		this.addCommand = addCommand;
	}
	
	public void setSubstractCommand(ICommand substractCommand) {
		this.substractCommand = substractCommand;
	}
	
	
}


//这个类是用来测试的
public class MementoPattern {

	public static void main(String[] args) {
		//测试不使用模式
		WorkflowA flow = new WorkflowA("WorkflowA");
		flow.stepOne();
		//下面两句是客户端在调用时作备份,将WorkflowA的实现细节暴露给客户端了
		int tempResult = flow.getTempResult();
		String tempState = flow.getTempState();
		flow.stepTwoSchema1();
		flow.setTempResult(tempResult);
		flow.setTempState(tempState);
		flow.stepTwoSchema2();
		
		//测试使用备忘录模式
		WorkflowB flowB = new WorkflowB("WorkflowB");
		flowB.stepOne();
		//保存“临时状态”
		IMemento memento = flowB.createMemento();
		CareTaker taker = new CareTaker();
		taker.saveMemento(memento);
		flowB.stepTwoSchema1();
		//恢复到“临时状态”
		flowB.setMemento(taker.retriveMemento());
		flowB.stepTwoSchema2();
	
		//测试使用备忘录模式与原型模式结合
		WorkflowC flowC = new WorkflowC("WorkflowC");
		flowC.stepOne();
		//保存“临时状态”
		memento = flowC.createMemento();
		taker = new CareTaker();
		taker.saveMemento(memento);
		flowC.stepTwoSchema1();
		//恢复到“临时状态”
		flowC.setMemento(taker.retriveMemento());
		flowC.stepTwoSchema2();
		
		//测试备忘录模式结合命令模式实现可撤销的操作
		IOperation operation = new Operation();
		AddCommand addCommand = new AddCommand(5);
		SubstractCommand substractCommand = new SubstractCommand(3);
		addCommand.setOperation(operation);
		substractCommand.setOperation(operation);
		
		Caculator caculator = new Caculator();
		caculator.setAddCommand(addCommand);
		caculator.setSubstractCommand(substractCommand);
		
		caculator.addPressed();
		System.out.println("一次加法(加5)操作后的结果是:" + operation.getResult());
		
		caculator.substractPressed();
		System.out.println("一次减法(减3)操作后的结果是:" + operation.getResult());
		
		caculator.undoPress();
		System.out.println("撤销一次操作后的结果是:" + operation.getResult());
		
		caculator.undoPress();
		System.out.println("再撤销一次操作后的结果是:" + operation.getResult());
		
		caculator.redoPressed();
		System.out.println("恢复一次操作的结果是:" + operation.getResult());
		
		caculator.redoPressed();
		System.out.println("再恢复一次操作的结果是:" + operation.getResult());
		
		
	}

}

读《研磨设计模式》-代码笔记-备忘录模式-Memento

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
备忘录模式(Memento) 属于对象的行为模式。 备忘录模式是我觉得最容易理解的一种模式,它的名字取得
设计模式学习笔记--备忘录模式(Memento) 备忘录模式(Memento) 属于对象的 行为模式。 备忘录模式是
问题 没有人想犯错误,但是没有人能够不犯错误。犯了错误一般只能改过,却很难改正(恢复)。世界上
  前言:【模式总览】——————————by xingoo   模式意图   这个模式主要是想通过一个
备忘录模式,可以将当前状态保存,并随时恢复。 Originator存在状态state,当需要保存此状态时,通
备忘录(Memento)对象:一个用来存储另外一个对象内部状态(信息)的快照的对象 用意:在不破坏 封
有时候,我们需要创建对象曾在系统中出现过。在这个时候如果我们需要一个撤销功能以使状态回复到以
Memento模式也叫备忘录模式,是由GoF提出的23种软件设计模式的一种。Memento模式是行为模式之一,它
生活中大家可能都幻想过如果当初我没怎么样怎么样就好了,当产生这样的想法的时候一定是发生什么不
备忘录模式:在不破坏封装性的前提下,捕获对象的内部状态并保存,这样以后就可以恢复该对象恢复到
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号