* 24种设计模式——备忘录模式

最新推荐文章于 2024-04-24 18:24:21 发布

Testdddddddddddddddd

最新推荐文章于 2024-04-24 18:24:21 发布

阅读量379

点赞数

本文链接：https://blog.csdn.net/yifanSJ/article/details/76473857

版权

核心：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

一、如此追女孩，你还不乐

1. 男孩状态类

public class Boy {
	//男孩的状态
	private String state = "";
	//认识女孩子后状态肯定改变，比如心情，手中的花等
	public void changeState(){
		this.state="心情可能 很不好";
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	//保留一个备份
	public Memento createMemento(){
		return new Memento(state);
	}
	//恢复一个备份
	public void restoreMemento(Memento _memento){
		this.setState(_memento.getState());
	}
}

2. 备忘录类

public class Memento {
	//男孩的状态
	private String state = "";
	//通过构造函数传递状态信息
	public Memento(String state) {
		this.state = state;
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
}

3. 备忘录管理者类

public class Caretaker {
	//备忘录对象
	private Memento memento;
	public Memento getMemento() {
		return memento;
	}
	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

之所以存在备忘录管理者类，是因为单独备忘录对象违反迪米特法则：只和朋友类通信。高层模块只希望创建一个备份点，需要的时候进行备份和恢复，不用关心到底有没有备忘录这个类

4. 场景类

public class Client {
	public static void main(String[] args) {
		//声明出主角
		Boy boy = new Boy();
		//声明出备忘录的管理者
		Caretaker caretaker = new Caretaker();
		//初始化当前状态
		boy.setState("心情很棒");
		System.out.println("===男孩现在的状态===");
		System.out.println(boy.getState());
		//需要记录下当前状态呀
		caretaker.setMemento(boy.createMemento());
		//男孩去追女孩，状态改变
		boy.changeState();
		System.out.println("===男孩追女孩后的状态===");
		System.out.println(boy.getState());
		//追女孩失败，恢复原状
		boy.restoreMemento(caretaker.getMemento());
		System.out.println("===男孩恢复后的状态");
		System.out.println(boy.getState());
	}
}

需要备份的时候就创建一个备份，然后丢给备忘录管理者进行管理，要取的时候再从管理者手中拿到这个备份。这个备份者就类似于一个备份的仓库管理员，创建一个丢进去，需要的时候再拿出来。这就是备忘录模式。

创建备忘录：备忘录由发起人创建后，set进备忘录管理类

恢复备忘录：从备忘录管理者中get到，后恢复到发起人中。

二、备忘录模式的定义

定义，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

Originator发起人角色：记录当前的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。

Memento备忘录角色：负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。

Caretaker备忘录管理员角色：对备忘录进行管理、保存和提供备忘录。

1. 发起人角色

public class Originator {
	//内部状态
	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());
	}
}

2. 备忘录角色

public class Memento {
	//发起人的内部状态
	private String state = "";
	//构造函数传递参数
	public Memento(String state) {
		this.state = state;
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
}

3. 备忘录管理者角色

public class Caretaker {
	//备忘录对象
	private Memento memento;
	public Memento getMemento() {
		return memento;
	}
	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

4. 场景类

public class Client {
	public static void main(String[] args) {
		//定义出发起人
		Originator originator = new Originator();
		//定义出备忘录管理员
		Caretaker caretaker = new Caretaker();
		//创建一个备忘录
		caretaker.setMemento(originator.createMemento());
		//恢复一个备忘录
		originator.restoreMemento(caretaker.getMemento());
	}
}

三、备忘录模式

1.使用场景

1）需要保存和恢复数据的相关状态场景

2）提供一个类似可回滚（rollback）操作

3）需要监控的副本场景中。例如要监控一个对象属性，但是监控又不应该作为系统的主业务来调用，它只是边缘应用，即使出现监控不准、错误报警也影响不大，因此一般的做法是备份一个主线程中的对象，然后由分析程序来分析

数据库连接的事务管理就是用的备忘录模式，如果你要实现一个JDBC驱动，还不是用备忘录模式嘛！

2. 备忘录模式的注意事项

1）备忘录的生命周期：备忘录创建出来就要在“最近”的代码中使用，要主动管理它的生命周期，建立就要使用，不使用就要立刻删除其引用，等待垃圾回收顺对它的回收处理。

2）备忘录的性能：不要在频繁建立备份的场景中使用备忘录模式（比如一个for循环中），控制不了对象的数量，以及消耗资源。

四、备忘录模式的扩展

1. clone方式的备忘录

大家还记得13章中讲的原型模式吗？通过复制方式产生一个对象的内部状态，这是一个很好的办法，发起人角色只要实现Cloneable就成，比较简单，我们来看类图。

发起人角色（融入了备忘录和备忘录管理者功能）

public class Originator implements Cloneable{
	private Originator backup;
	//内部状态
	private String state = "";
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	//创建一个备忘录
	public void createMemento(){
		this.backup = this.clone();
	}
	//恢复一个备忘录
	public void restoreMemento(){
		//在进行恢复前应该进行断言，防止空指针
		this.setState(this.backup.getState());
	}
	//克隆当前对象
	protected Originator clone() {
		try {
			return (Originator) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
}

场景类

public class Client {
	public static void main(String[] args) {
		//定义发起人
		Originator originator = new Originator();
		//建立初始状态
		originator.setState("初始状态");
		System.out.println("初始状态是："+originator.getState());
		//建立备份
		originator.createMemento();
		//修改状态
		originator.setState("修改后的状态");
		System.out.println("修改后的状态是："+originator.getState());
		//恢复原有状态
		originator.restoreMemento();
		System.out.println("恢复后的状态是："+originator.getState());
	}
}

2. 多状态的备忘录模式

发起人角色

public class Originator {
	//内部状态
	private String state1 = "";
	private String state2 = "";
	private String state3 = "";
	get/set()
	//创建一个备忘录
	public Memento createMemento(){
		return new Memento(BeanUtils.backupProp(this));
	}
	//恢复一个备忘录
	public void restoreMemento(Memento _memento){
		BeanUtils.restoreProp(this, _memento.getStateMap());
	}
	public String toString() {
		return "Originator [state1=" + state1 + ", state2=" + state2+ ", state3=" + state3 + "]";
	}
}

备忘录角色

public class Memento {
	//接受HashMap作为状态
	private HashMap<String,Object> stateMap;
	//接受一个对象，建立一个备份
	public Memento(HashMap<String, Object> stateMap) {
		this.stateMap = stateMap;
	}
	public HashMap<String, Object> getStateMap() {
		return stateMap;
	}
	public void setStateMap(HashMap<String, Object> stateMap) {
		this.stateMap = stateMap;
	}
}

备忘录管理者角色

public class Caretaker {
	//备忘录对象
	private Memento memento;
	public Memento getMemento() {
		return memento;
	}
	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

BeanUtils工具类

public class BeanUtils {
	//把bean的所有属性及数值放入到Hashmap中
	public static HashMap<String,Object> backupProp(Object bean){
		HashMap<String,Object> result = new HashMap<String,Object>();
		try {
			//获得Bean描述
			BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
			//获得属性描述
			PropertyDescriptor[] descrptDescriptors = beanInfo.getPropertyDescriptors();
			//遍历所有属性
			for(PropertyDescriptor des:descrptDescriptors){
				//属性名称
				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){
		try {
			//获得Bean描述
			BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
			//获得属性描述
			PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
			//遍历所有属性
			for(PropertyDescriptor des:descriptors){
				//属性名称
				String fieldName = des.getName();
				//如果有这个属性
				if(propMap.containsKey(fieldName)){
					//写属性的方法
					Method setter = des.getWriteMethod();
					setter.invoke(bean, new Object[]{propMap.get(fieldName)});
				}
			}
		} catch (Exception e) {
			//异常处理
			System.out.println("shit");
			e.printStackTrace();
		}
	}
}

场景类

public class Client {
	public static void main(String[] args) {
		//定义出发起人
		Originator originator = new Originator();
		//定义出备忘录管理员
		Caretaker caretaker = new Caretaker();
		//初始化
		originator.setState1("中国");
		originator.setState2("强盛");
		originator.setState3("繁荣");
		System.out.println("===初始化状态==="+originator);
		//创建一个备忘录
		caretaker.setMemento(originator.createMemento());
		//修改状态值
		originator.setState1("软件");
		originator.setState2("架构");
		originator.setState3("优秀");
		System.out.println("===修改后的状态==="+originator);
		//恢复一个备忘录
		originator.restoreMemento(caretaker.getMemento());
		System.out.println("===恢复后的状态==="+originator);
	}
}