备忘录模式——Memento
文章目录
- 案例展示——Memento怎么用？
- 深入分析——Memento是什么？
- Memento的定义
- Memento的几种扩展形式
- 1. clone方式的备忘录
- 2. 多状态的备忘录模式
- 3. 多备份的备忘录
- 4. 更加安全的备忘录
- Memento的使用场景
- Memento的注意事项
- 参考
案例展示——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());
}
// 克隆当前对象
@Override
protected 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());
}
@Override
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> 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循环)，原因如下
- 控制不了备忘录建立的对象数量
- 大对象的建立需要耗费很大的资源
参考
《设计模式之禅》