**定义**:在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将 该对象恢复到原先保存的状态。 ## 一般模式:  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; } } ~~~