文章目录
案例展示——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循环),原因如下
- 控制不了备忘录建立的对象数量
- 大对象的建立需要耗费很大的资源
参考
《设计模式之禅》