设计模式(十八)---备忘录模式

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了设计模式(十八)---备忘录模式，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。
定义:在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将

该对象恢复到原先保存的状态。

一般模式:


Originator发起人角色
---|记录当前时刻的内部状态，负责定义那些属于备份范围的状态，负责创建和恢复备忘录数据
Memento备忘录角色
---|负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态
Caretaker备忘录管理员角色

---|对备忘录进行管理、保存和提供备忘录。

public class MementoTest {
	public static void main(String[] args) {
		//定义一个备忘录的发起者
		Originator origin = new Originator();
		origin.setState("你好！");
		//定义一个备忘录的管理者
		Caretaker care = new Caretaker();
		//创建一个备忘录
		care.setMemento(origin.createMemento());
		origin.setState("去死吧！");
		//恢复原有的数据
		origin.restoreMemento(care.getMemento());
		System.out.println(origin.getState());
	}
}
/**
 * 备忘录发起人的角色，
 * 备忘录中保存的就是该类的内容。
 * @author admin
 *
 */
class Originator{
	//一个String类型表示当前状态
	private String state = "";
	
	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}
	//创建一个备忘录角色，用于时刻存储数据。
	public Memento createMemento(){
		return new Memento(this.state);
	}
	//回复原来的数据
	public void restoreMemento(Memento memento){
		this.setState(memento.getState());
	}
}
/**
 * 备忘录角色，
 * 该类用于备份、存储原有数据。
 * @author admin
 *
 */
class Memento{
	//一个String类型表示当前状态
	private String state = "";
	
	public Memento(String state) {
		this.state = state;
	}

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}
}
/**
 * 备忘录的管理类
 * 对备忘录进行管理、保存和存储
 * @author admin
 */
class Caretaker{
	private Memento memento;

	public Memento getMemento() {
		return memento;
	}

	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

一个例子:

模拟月光宝盒中，至尊宝阻止白晶晶自杀的桥段。当白晶晶在洞内自杀，至尊宝没有来得及救，于是就使用月光宝盒--菠萝菠萝蜜
任何就回到上一个状态，继续去救白晶晶，知道能够成功救到为止。
这个例子可以说明，救白晶晶之前，首先保存一个状态命名为1，从这一状态出发，如果没有成功，就回到1状态。

public class MementoT {
	public static void main(String[] args) {
		//创建一个发起者，（看见白晶晶在自杀）
		SaveLifeAction action = new SaveLifeAction();
		action.setState("白晶晶被至尊宝伤透了心...准备拿剑抹脖子自杀");
		//月关宝盒时刻记录每一瞬间
		BoxManager BoxManager = new BoxManager();
		BoxManager.setBoxMemento(action.createMemento());
		action.setState("白晶晶自杀死了...");
		System.out.println(action.getState());
		System.out.println("---至尊宝拿着月关宝盒，回去救她----");
		//至尊宝拿着月关宝盒，回去救她
		action.restoreMemento(BoxManager.getBoxMemento());
		//回到上一状态
		System.out.println(action.getState());
		action.setSuccess(true);
		if(action.isSuccess()){
			System.out.println("----白晶晶成功获救！");
		}
	}
}
/**
 * 该类是发起者类，
 * 设置负责创建和恢复备忘录
 * @author admin
 *
 */
class SaveLifeAction{
	//定义一个状态，用于描述当前正在做什么..
	private String  state="";
	//设置是否救成功
	private boolean isSuccess;
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	public boolean isSuccess() {
		return isSuccess;
	}
	public void setSuccess(boolean isSuccess) {
		this.isSuccess = isSuccess;
	}
	//创建一个备份的状态
	public BoxMemento createMemento(){
		return new BoxMemento(this.state);
	}
	//恢复到原来的状态
	public void restoreMemento(BoxMemento BoxMemento){
		this.setState(BoxMemento.getState());
	}
}
/**
 * 该类是备忘录类
 * 相当于故事中的月光宝盒，他带你回到上一个状态。
 * 内部实现的原理就是，保存上一状态而已。
 * @author admin
 *
 */
class BoxMemento{
	private String state="";

	public BoxMemento(String state) {
		this.state = state;
	}
	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}
}
/**
 * 备忘录的管理者，
 * 谁拿到月光宝盒，谁就可以操纵月光宝盒，
 * 就可以回到过去。
 * @author admin
 *
 */
class BoxManager{
	
	private BoxMemento BoxMemento;

	public BoxMemento getBoxMemento() {
		return BoxMemento;
	}

	public void setBoxMemento(BoxMemento BoxMemento) {
		this.BoxMemento = BoxMemento;
	}
}
备忘录模式的使用场景
---|需要保存和恢复数据的相关状态场景。
---|提供一个可回滚(rollback)的操作，比如word中Ctrl+Z的组合键。
---|需要监控的副本场景中。
---|数据库连接的事务管理就是用的备忘录模式。

备忘录的扩展

---|1、实现java类中的Cloneable实现备忘录模式
使用clone方式的备忘录模式，可以使用在比较简单的场景或者比较单一的场景中，
尽量不要与其他的对象产生严重的耦合关系。

public class MementoExpand {
	public static void main(String[] args) {
		//定义一个发起人
		OriginClass origin = new OriginClass();
		origin.setState("我的原始状态");
		//创建备份
		origin.createOrigin();
		origin.setState("我的现在状态..");
		System.out.println(origin.getState());
		System.out.println("------我不喜欢现在的状态-------");
		//恢复原来的状态
		origin.restoreOrigin();
		System.out.println(origin.getState());
	}
}
/**
 * 发起者实现Cloneable接口，完成自身的备忘录设置。
 * 无需接触其他类来保存自身的当前状态。
 * @author admin
 *
 */
class OriginClass implements Cloneable{
	private String state;
	//自身的备忘录角色
	private OriginClass backUp;
	
	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}
	//创建备份
	public void createOrigin(){
		this.backUp = (OriginClass) this.clone();
	}
	//恢复原来的信息
	public void restoreOrigin(){
		this.setState(backUp.getState());
	}
	
	@Override
	protected Object clone() {
		try {
			return (OriginClass) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
}

---|2多状态的备忘录模式

/**
 * 通过java.beans.Introspector类获取其他类中的属性和方法
 * @author admin
 *
 */
public class BeanUtil {
	public static void main(String[] args) {
		//创建一个发起者
		MyOringin origin = new MyOringin("lzl",10000,"程序员");
		System.out.println("在百度公司里："+origin.toString());
		//在百度公司创建备份
		MyMementor mementor = origin.createMemento();
		System.out.println("感觉太累了，跳槽的阿里巴巴...");
		origin.setName("lzl");
		origin.setPosition("程序员");
		origin.setSalary(12000);
		System.out.println("跳槽到阿里："+origin.toString());
		System.out.println("----------------在这里更累，跟着老大,10天没合眼...想回到百度了.");
		origin.restoreMemento(mementor);
		System.out.println("回到百度，还是很轻松的。。"+origin.toString());
		
	}
	//获取发起者类中的属性参数，并保存在hashMap中
	public static HashMap<String,Object> backUpProp(Object bean){
		HashMap<String,Object> result = new HashMap<String,Object>();
		//获得Bean描述
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
			//返回PropertyDescriptor类型的javaBean描述
			PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
			//遍历返回的javaBean
			for(PropertyDescriptor des : descriptors){
				String fieldName = des.getName();
				//读取属性的方法
				Method getter = des.getReadMethod();
				//读取属性值
				Object fieldValue = getter.invoke(bean,new Object[]{});
				if(!fieldName.equalsIgnoreCase("class")){
					result.put(fieldName,fieldValue);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	//把HashMap中的值设置到bean中。
	public static void restoreProp(Object bean,HashMap<String,Object> propMap){
		//获取BeanInfo
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
			//获取PropertyDescriptor的对象数组
			PropertyDescriptor[] descripors = beanInfo.getPropertyDescriptors();
			//增强for循环，遍历所有的属性，设置到bean中
			for(PropertyDescriptor des : descripors){
				//获取key值对象
				String fieldName = des.getName();
				//如果包含这个属性
				if(propMap.containsKey(fieldName)){
					//获取属性set的方法
					Method setter = des.getWriteMethod();
					setter.invoke(bean,new Object[]{propMap.get(fieldName)});
				}
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
/**
 * 类的发起者，模拟拥有多个属性。
 * @author admin
 *
 */
class MyOringin{
	//姓名
	private String name;
	//薪水
	private double salary;
	//职位
	private String position;
	
	public MyOringin(String name,double salary,String position) {
		this.name = name;
		this.salary = salary;
		this.position = position;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	//创建一个备份
	public MyMementor createMemento(){
		//将方法属性存储到BeanUtil.backUpProp()中的hashMap中
		return new MyMementor(BeanUtil.backUpProp(this));
	}
	public void restoreMemento(MyMementor memento){
		BeanUtil.restoreProp(this,memento.getBeanMap());
	}
	@Override
	public String toString() {
		return "姓名："+this.name+"\t职位："+this.position
				+"\t薪水："+this.salary+"\t";
	}
}
/**
 * 备忘录类，用于保存原有的状态。
 * @author admin
 */
class MyMementor{
	//定义一个hashMap来接收发起者的所有属性状态备份
	private HashMap<String,Object> beanMap = new HashMap<String,Object>();
	
	public MyMementor(HashMap<String,Object> beanMap) {
		this.beanMap = beanMap;
	}

	public HashMap<String,Object> getBeanMap() {
		return this.beanMap;
	}

	public void setBeanMap(HashMap<String,Object> beanMap) {
		this.beanMap = beanMap;
	}
}

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript