设计模式学习笔记——备忘录模式

定义：

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

备忘录模式主要是对某个对象的状态的备份，备份的主要是对象当前的属性值，即成员变量的值，成员变量可以有多个，而且可以备份同一个对象的多种不同状态，即同一个对象可以同时有多个备份，先来看最简单的情况，即一个对象只有一个成员变量：

其通用类图为：

源代码如下：

/* * 单属性的备忘录模式，本类即是需要被备份的类 */public class Originator {private String state;public String getState() {return state;}public void setState(String state) {this.state = state;}public void changeState(){this.state="heart hurt...";}public Memento createMemento(){return new Memento(this.state);}public void restoreMemento(Memento memento){this.setState(memento.getState());}}

/* * 备忘录类 */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;}}

/* * 备忘录管理类 */public class Caretaker {private Memento memento;public Memento getMemento() {return memento;}public void setMemento(Memento memento) {this.memento = memento;}}

public class Client {public static void main(String[] args) {Originator originator=new Originator();Caretaker caretaker=new Caretaker();originator.setState("happy...");System.out.println(originator.getState());//保存当前的状态caretaker.setMemento(originator.createMemento());//状态改变originator.changeState();System.out.println(originator.getState());//恢复状态originator.restoreMemento(caretaker.getMemento());System.out.println(originator.getState());}}

要是遇到多属性怎么办？要是一个对象不仅仅只需要备份一次，而需要备份很多次，又该如何呢？看下面改进源码：

/* * 多属性的备忘录模式 */public class Originator {private String state1;private String state2;private String state3;public String getState1() {return state1;}public void setState1(String state1) {this.state1 = state1;}public String getState2() {return state2;}public void setState2(String state2) {this.state2 = state2;}public String getState3() {return state3;}public void setState3(String state3) {this.state3 = state3;}//将本对象的各个属性以HashMap类型保存到Memento对象中public Memento createMemento(){return new Memento(BeanUtils.beanToHash(this));}//从Memento对象中取出保存的对象的属性状态，并赋值给本对象的各个属性public void restoreMemento(Memento memento){BeanUtils.hashToBean(this, memento.getStateMap());}public String toString(){return this.state1+" "+this.state2+" "+this.state3;}}

//Memento的成员变量为一个HashMap类型的，是为了保存源目标对象的各个属性的名和值public class Memento {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;}}

/** * 多备份备份，即可以备份一个对象的多种状态， * 注意这种多备份，不要用于备份特别频繁的地方，容易出现内存溢出， * 或者增加Map的上限，防止出现内存的泄漏。 */public class Caretaker {private HashMap<String,Memento> mementos=new HashMap<String,Memento>();public Memento getMemento(String key) {return mementos.get(key);}public void setMemento(String key, Memento memento) {this.mementos.put(key, memento);}}

/* * 使用此类是为了操作方便 */public class BeanUtils {/* * 把bean的所有属性及数值放到HashMap中 */public static HashMap<String,Object> beanToHash(Object bean){HashMap<String,Object> result=new HashMap<String,Object>();try{BeanInfo beanInfo=Introspector.getBeanInfo(bean.getClass());//获得bean描述PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();//获得属性描述//遍历所有属性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 hashToBean(Object bean, HashMap<String,Object> result){try{BeanInfo beanInfo=Introspector.getBeanInfo(bean.getClass());//获得bean描述PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();//获得属性描述//遍历所有属性for(PropertyDescriptor des : descriptors){String fieldName=des.getName();//属性名if(result.containsKey(fieldName)){Method setter=des.getWriteMethod();//写属性的方法setter.invoke(bean, new Object[]{result.get(fieldName)});//将值写入到属性中}}}catch(Exception e){}}}

public class Client {public static void main(String[] args) {Originator originator=new Originator();Caretaker caretaker=new Caretaker();originator.setState1("brave");originator.setState2("responsibility");originator.setState3("clever");System.out.println("001: "+originator.toString());caretaker.setMemento("001",originator.createMemento());//创建第一个备份originator.setState1("weak");originator.setState2("lazy");originator.setState3("temper");System.out.println("002: "+originator.toString());caretaker.setMemento("002",originator.createMemento());//创建第二个备份originator.setState1("self-reflection");originator.setState2("get up early");originator.setState3("go to libyary everyday");System.out.println("003: "+originator.toString());caretaker.setMemento("003",originator.createMemento());//创建第三个备份originator.restoreMemento(caretaker.getMemento("001"));//恢复System.out.println("now: "+originator.toString());}}

多个属性，多个备份嘛，那就把备忘录类和备忘录管理类换成集合类型就可以了。但是这种做法要特别注意内存溢出的问题，不要在备份频繁的地方使用这种备忘录模式，可以设置Map的上限，来防止内存泄露。

另外，备份还可以有另外一种实现方式，备份嘛，自然会联想到复制，也就联想到原型模型了，可以使用克隆的方法来实现备忘录，如下源码：

/* * 通过克隆对象的方式实现备忘录 */public class Originator implements Cloneable{private String state;public String getState() {return state;}public void setState(String state) {this.state = state;}public void changeState(){this.state="heart hurt...";}public Originator createMemento(){return this.clone();}public void restoreMemento(Originator originator){this.setState(originator.getState());}@Overrideprotected Originator clone(){try{return (Originator)super.clone();}catch(CloneNotSupportedException e){e.printStackTrace();}return null;}}

public class Caretaker {private Originator originator;public Originator getMemento() {return originator;}public void setMemento(Originator originator) {this.originator = originator;}}

还有，如果需要想要增加安全性，即备份的东西是不可以随便改变的，除了原发起对象之外，其他的对象是都不可访问这个备忘录的，我个人现在浅薄的观点认为，只要在备忘录类中不实现那个setMemento()方法，不就可以避免这个类的对象被修改了吗？反正这个方法没有被用到，不知道这样做对不对，《设计模式之禅》的作者有他的做法，即把备忘录类作为原发起对象的一个内部类，这样就可以实现只有发起对象可以访问这个备忘录类了，再让这个内部类实现一个空的接口，让其可以在外和其他类建立关联关系，其实现代码如下：

public interface IMemento {}

/* * 使用内部类，增强安全性 */public class Originator {private String state;public String getState() {return state;}public void setState(String state) {this.state = state;}public void changeState(){this.state="heart hurt...";}public Memento createMemento(){return new Memento(this.state);}public void restoreMemento(IMemento memento){this.setState(((Memento)memento).getState());}//把备忘录类写成内部类，这样只有发起人才能访问备忘录，其他对象都不可以访问，这就增加了备忘录的安全性//实现了一个空的接口，以便于在外边和其他类产生关联关系。private class Memento implements IMemento {private String state;private Memento(String state) {this.state = state;}private String getState() {return state;}}}

//在原发起类的外部使用备忘录类的空接口建立和其他对象的关联public class Caretaker {private IMemento memento;public IMemento getMemento() {return memento;}public void setMemento(IMemento memento) {this.memento = memento;}}