盈利网站备案/十种营销方式

案例展示——Memento怎么用？

 在电影中，月光宝盒是一种可以穿越时空的宝物，持有月关宝盒的人可以去到任意的时间，也可以迅速的回到原来的时间。当然，在现实中，起码在现在的科技水平下，人类的科技是无法做到时空穿梭的程度的，但是作为程序员，我们却可以通过编程来体验这种任意穿梭时间的乐趣，下面是设计类图：

类图元素分析如下：

• TimeMachine：这就是前面说的月关宝盒类了，这个类会显示当前月关宝盒所在的年代，同时可以创建一个备份保存这个年代，以便以后可以返回

• Memento：备忘录类，这是一个Javabean，就是单纯的为TimeMachine保存一个年代信息

• Caretaker：备忘录的管理类，通过这个类去管理备忘录类，高层模块不必要直接和备忘录接触，降低耦合

下面是代码实现：

// 时间机器——月关宝盒
public class TimeMachine {// 年代private String time = "";// 改变年代public void changeTime() {this.time = "公元1970-1-1 00:00:00，我是月光宝盒，今天是我的生日！";}public void setTime(String time) {this.time = time;}public String getTime() {return time;}// 保留一个备份public Memento createMemento() {return new Memento(this.time);}// 恢复一个备份public void restoreMemento(Memento memento) {this.setTime(memento.getTime());}
}// 备忘录类
public class Memento {// 年代private String time = "";// 通过构造函数来传递年代public Memento(String time) {this.time = time;}public String getTime() {return time;}public void setTime(String time) {this.time = time;}
}// 备忘录管理员
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) {// 准备时间机器——“月光宝盒”TimeMachine tm = new TimeMachine();// 准备一个备忘录管理者Caretaker caretaker = new Caretaker();// 初始化时间机器tm.setTime("公元前221年，秦始皇一统天下！");System.out.println("==========月光宝盒当前时间===========");System.out.println(tm.getTime());// 使用备忘录记录一下caretaker.setMemento(tm.createMemento());// 改变一下年代tm.changeTime();System.out.println("==========月光宝盒修改后时间===========");System.out.println(tm.getTime());// 回到原始的那个年代tm.restoreMemento(caretaker.getMemento());System.out.println("==========月光宝盒恢复后时间===========");System.out.println(tm.getTime());}
}结果如下：
公元前221年，秦始皇一统天下！
==========月光宝盒修改后时间===========
公元1970-1-1 00:00:00，我是月光宝盒，今天是我的生日！
==========月光宝盒恢复后时间===========
公元前221年，秦始皇一统天下！

 看见结果是不是很神奇，我们可以任意的穿梭时空啦，想到哪里就去哪里，但是最重要的就是在去之前要备份一下，以免到时候回不来。在这个设计中我们就用到了备忘录模式。

深入分析——Memento是什么？

Memento的定义

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

类图元素分析：

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

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

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

Memento的几种扩展形式

1. clone方式的备忘录

通过复制的方式产生一个内部对象，这是一种简单好用的方法，其类图如下：

代码实现如下：

// 发起人自主备份和恢复
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 = (Originator) this.clone();}// 恢复一个备忘录public void restoreMemento() {// 断言备忘录不为空Assert.assertNotNull(backup);this.setState(this.backup.getState());}// 克隆当前对象@Overrideprotected Object 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. 多状态的备忘录模式

 在前面介绍的案例中，发起人角色Originator只有一个状态，我们只需要备份一个状态就可以，那要是在复杂场景中出现了多个状态值需要备份怎么办呢？这时我们可以使用前面的介绍的通过克隆的备忘录模式，也可以使用下面介绍的方法。类图设计如下：

分析：将多个状态值按照键值对(属性-属性值)的形式存放在HashMap中，通过一个工具类BeanUtils来获取属性值或者设置属性值

下面是代码实现：

// 发起人角色：有多个状态
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;}// 创建一个备忘录public Memento createMemento() {return new Memento(BeanUtils.backupProp(this));}// 恢复一个备忘录public void restoreMemento(Memento memento) {BeanUtils.restoreProp(this, memento.getStateMap());}@Overridepublic String toString() {return "Originator{" +"state1='" + state1 + '\'' +", state2='" + state2 + '\'' +", state3='" + state3 + '\'' +'}';}
}// 备忘录类
public class Memento {// 状态值存放在一个HashMap中private HashMap<String, Object> stateMap;// 接收一个对象，建立一个备份public Memento(HashMap<String, Object> map) {this.stateMap = map;}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;}
}// 工具类
public class BeanUtils {// 把bean的所有属性和数值放到HashMap中：使用反射获取public static HashMap<String, Object> backupProp(Object bean) {HashMap<String, Object> result = new HashMap<String, Object>(16);try {// 获得bean的描述BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());// 获得属性描述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 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) {e.printStackTrace();}}
}//在一个场景中测试
public class Client {public static void main(String[] args) {// 定义一个发起人Originator ori = new Originator();// 定义出备忘录管理员Caretaker caretaker = new Caretaker();// 初始化ori.setState1("篮球");ori.setState2("足球");ori.setState3("乒乓球");System.out.println("=======初始化状态=====\n" + ori);// 创建一个备忘录caretaker.setMemento(ori.createMemento());// 修改状态值ori.setState1("蔬菜");ori.setState2("水果");ori.setState3("海鲜");System.out.println("\n=======修改后状态======\n" + ori);// 恢复备忘录中保存的状态ori.restoreMemento(caretaker.getMemento());System.out.println("\n=======恢复后状态======\n" + ori);}
}结果如下：
=======初始化状态=====
Originator{state1='篮球', state2='足球', state3='乒乓球'}=======修改后状态======
Originator{state1='蔬菜', state2='水果', state3='海鲜'}=======恢复后状态======
Originator{state1='篮球', state2='足球', state3='乒乓球'}

3. 多备份的备忘录

 备忘录也可以有多个，我们可以建立多个备份，然后选择回到哪个备份。其实这样的场景会有很多，比如视频监控，我们想回到某某时间段，那这个备份的必须是连续的，每一个时间点就是一个备份点，通过这个备份点我们就能回到那个状态，下面是代码实现(只给出修改部分)：

// 备忘录管理员：通过HashMap来存放多个备忘录——(备份点索引, 备忘录对象)
public class Caretaker {// 使用HashMap来存放多个备忘录private HashMap<String, Memento> memMap = new HashMap<String, Memento>(16);public Memento getMemento(String index) {return memMap.get(index);}public void setMemento(String index, Memento memento) {this.memMap.put(index, memento);}
}// 客户端
public class Client {public static void main(String[] args) {// 定义发起人Originator originator = new Originator();// 定义出备忘录管理员Caretaker caretaker = new Caretaker();// 创建多个备忘录caretaker.setMemento("001", originator.createMemento());caretaker.setMemento("002", originator.createMemento());// 恢复指定标记的备忘录originator.restoreMemento(caretaker.getMemento("001"));}
}

4. 更加安全的备忘录

 备忘录的数据一般来说是不允许修改的，这就要求我们将其保护的更好，纵观我们前面的设计，备忘录暴露在外，任何人都可以对其进行修改。这样设计是很不安全的，所以可以将备忘录的阅读权限缩小，比如作为发起人的一个私有内部类，外部的话就声明一个没有任何方法的备忘录接口，其他一切对备忘录的访问都通过这个接口进行，只允许使用，不允许修改，这样就会安全的多(当然无法防止通过反射去修改)，下面是类图设计：

下面是代码实现：

// 备忘录接口
public interface IMemento {}// 发起人角色
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());}// 内部类private class Memento implements IMemento {// 发起人的内部状态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 IMemento memento;public IMemento getMemento() {return memento;}public void setMemento(IMemento memento) {this.memento = memento;}
}

 在上面的例子中使用了双接口设计：一个类可以实现多个接口，如果考虑对象安全问题，可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外一个是空接口，没有任何方法，其目的是提供给子系统的外部模块访问，比如容器对象，这个叫做窄接口。由于窄接口中没有提供任何操作数据的方法，因此相对比较安全。

Memento的使用场景

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

• 提供回滚操作：如数据库中事物提交失败后的回滚操作就是使用了备忘录模式

• 需要对一个对象进行监控的场景

Memento的注意事项

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

• 备忘录的性能：不要在频繁建立备份的场景中使用备忘录模式(比如for循环)，原因如下

  • 控制不了备忘录建立的对象数量
  • 大对象的建立需要耗费很大的资源

参考

《设计模式之禅》