备忘录模式
备忘录模式(Memento Pattern):在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
类图中的角色:
- Originator发起人角色:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和恢复备忘录数据。
- Memento备忘录角色:负责存储Originator发起人对象的内部状态,在需要的时候提供发起人需要的内部状态。
- Caretaker备忘录管理员角色:对备忘录进行管理、保存和提供备忘录。
发起人角色Originator:
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());
}
}
备忘录角色Memento:
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;
}
}
备忘录管理员角色Caretaker:
public class Caretaker {
//备忘录对象
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
场景类Client:
public class Client {
public static void main(String[] args) {
//定义出发起人
Originator originator = new Originator();
//定义出备忘录管理员
Caretaker caretaker = new Caretaker();
//创建一个备忘录
caretaker.setMemento(originator.createMemento());
//恢复一个备忘录
originator.restoreMemento(caretaker.getMemento());
}
}
备忘录模式的使用场景:
- 需要保存和恢复数据的相关状态场景。
- 提供一个可回滚(rollback)的操作;比如Word中的CTRL+Z组合键,IE浏览器中的后退按钮,文件管理器上的backspace键等。
- 需要监控的副本场景中。例如要监控一个对象的属性,但是监控又不应该作为系统的主业务来调用,它只是边缘应用,即使出现监控不准、错误报警也影响不大,因此一般的做法是备份一个主线程中的对象,然后由分析程序来分析。
- 数据库连接的事务管理就是用的备忘录模式。
备忘录模式的注意事项
- 备忘录的生命期:备忘录创建出来就要在“最近”的代码中使用,要主动管理它的生命周期,建立就要使用,不使用就要立刻删除其引用,等待垃圾回收器对它的回收处理。
- 备忘录的性能:不要在频繁建立备份的场景中使用备忘录模式(比如一个for循环中),原因有二:一是控制不了备忘录建立的对象数量;二是大量对象的建立是要消耗资源的,系统的性能需要考虑。
备忘录模式的扩展
- clone方式的备忘录
- 多状态的备忘录模式
- 多备份的备忘录
- 封装得更好一点
备忘录模式的实例
小伙子追小姑凉,第一次追求失败,恢复原先状态然后进行第二次追求,直到最后成功。
(1)备忘录模式
public class Boy {
private String state = "";
public void changeState() {
this.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());
}
}
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;
}
}
import com.sfq.action.Boy;
import com.sfq.action.Caretaker;
public class Client {
public static void main(String[] args) {
Boy boy = new Boy();
Caretaker caretaker = new Caretaker();
boy.setState("心情很棒!");
System.out.println("=====现在状态=====");
System.out.println(boy.getState());
caretaker.setMemento(boy.createMemento());
boy.changeState();
System.out.println("=====追女孩后状态=====");
System.out.println(boy.getState());
//追女孩失败后恢复原状
boy.restoreMemento(caretaker.getMemento());
System.out.println("=====恢复后的状态=====");
System.out.println(boy.getState());
}
}
结果
=====现在状态=====
心情很棒!
=====追女孩后状态=====
心情可能很不好
=====恢复后的状态=====
心情很棒!
这个备份者就类似于一个备份的仓库管理员,创建一个丢进去,需要的时候再拿出来。这就是备忘录模式。
(2)clone方式的备忘录
发起人角色融合了发起人角色和备忘录角色,具有双重功效。
public class Originator implements Cloneable {
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public Originator createMemento() {
return this.clone();
}
//恢复一个备忘录
public void restoreMemento(Originator originator) {
this.setState(originator.getState());
}
//克隆当前对象
@Override
protected Originator clone() {
try {
return (Originator)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
public class CaretakerOriginator {
private Originator originator;
public Originator getOriginator() {
return originator;
}
public void setOriginator(Originator originator) {
this.originator = originator;
}
}
由于管理员角色是为了管理备忘录角色,而现在备忘录角色被合并了,因此我们可以将其删除,并进行精简。
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 = this.clone();
}
//恢复一个备忘录
public void restoreMemento() {
//在进行恢复前应该进行断言,防止空指针
this.setState(this.backup.getState());
}
//克隆当前对象
@Override
protected Originator clone() {
try {
return (Originator)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
当然,这与备忘录模式的定义不相符,它定义是“在该对象之外保存这个状态”,而我们却把这个状态保存在了发起人内部。是的,设计模式定义的诞生比Java的出世略早,它没有想到Java程序是这么有活力,有远见,而且在面向对象的设计中,即使把一个类封装在另一个类中也是可以做到的,何况一个小小的对象复制,这是它的设计模式完全没有预见到的,我们把它弥补回来。
public class Client1 {
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());
}
}
结果
初始状态是:初始状态...
修改后的状态是:修改后的状态...
恢复后的状态是:初始状态...
注意:使用Clone方式的备忘录模式,可以使用在比较简单的场景或者比较单一的场景中,尽量不要与其他的对象产生严重的耦合关系。
(3)多状态的备忘录模式
以上讲解都是单状态的情况,在实际的开发中一个对象不可能只有一个状态。一个对象全状态备份方案,有多种处理方式,比如使用Clone的方式,使用数据技术(DTO回写到临时表中)等,我们使用对备忘录模式继续扩展的方式,实现一个JavaBean对象的所有状态的备份和还原。
public class Originator1 {
//内部状态
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 Memento1 createMemento() {
return new Memento1(BeanUtils.backupProp(this));
}
//恢复一个备忘录
public void restoreMemento(Memento1 memento) {
BeanUtils.restoreProp(this,memento.getStateMap());
}
//增加一个toString方法
@Override
public String toString() {
return "state1=" + state1 + "\nstate2=" + state2 + "\nstate3=" + state3;
}
}
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
public class BeanUtils {
public static HashMap<String, Object> backupProp(Object bean) {
HashMap<String, Object> result = new HashMap<String, Object>();
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) {
// 异常处理
}
return result;
}
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) {
System.out.println("shit");
e.printStackTrace();
}
}
}
import java.util.HashMap;
public class Memento1 {
//接受HashMap作为状态
private HashMap<String, Object> stateMap;
//接受一个对象,建立一个备份
public Memento1(HashMap<String, Object> stateMap) {
this.stateMap = stateMap;
}
public HashMap<String, Object> getStateMap() {
return stateMap;
}
public void setStateMap(HashMap<String, Object> stateMap) {
this.stateMap = stateMap;
}
}
public class Caretaker1 {
private Memento1 memento1;
public Memento1 getMemento1() {
return memento1;
}
public void setMemento1(Memento1 memento1) {
this.memento1 = memento1;
}
}
import com.sfq.action.Caretaker1;
import com.sfq.action.Originator1;
public class Client2 {
public static void main(String[] args) {
Originator1 originator1 = new Originator1();
Caretaker1 caretaker1 = new Caretaker1();
originator1.setState1("中国");
originator1.setState2("强盛");
originator1.setState3("繁荣");
System.out.println("=====初始化状态=====\n" + originator1);
//创建一个备忘录
caretaker1.setMemento1(originator1.createMemento());
//修改状态
originator1.setState1("软件");
originator1.setState2("架构");
originator1.setState3("优秀");
System.out.println("\n=====修改后状态=====\n" + originator1);
//恢复一个备忘录
originator1.restoreMemento(caretaker1.getMemento1());
System.out.println("\n=====恢复后状态=====\n" + originator1);
}
}
结果
=====初始化状态=====
state1=中国
state2=强盛
state3=繁荣
=====修改后状态=====
state1=软件
state2=架构
state3=优秀
=====恢复后状态=====
state1=中国
state2=强盛
state3=繁荣
注意:如果要设计一个在运行期决定备份状态的框架,则建议采用AOP框架来实现,避免采用动态代理无谓地增加程序逻辑复杂性。
(4)多备份的备忘录
这里涉及到一个名词——检查点(Check Point),也就是你在备份的时候做的戳记,系统级的备份一般是时间戳。
我们只要把通用代码中的Caretaker管理员添加一个容器就可以了:
public class Caretaker {
//容纳备忘录的容器
private HashMap<String,Memento> memMap = new HashMap<String,Memento>();
public Memento getMemento(String idx) {
return memMap.get(idx);
}
public void setMemento(String idx,Memento memento) {
this.memMap.put(idx, 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"));
}
}
注意:内存溢出问题,该备份一旦产生就装入内存,没有任何销毁的意向,这是非常危险的。因此,在系统设计时,要严格限定备忘录的创建,建议增加Map的上限,否则系统很容易产生内存溢出情况。
(5)封装得更好一点
在系统管理上,一个备份的数据是完全、绝对不能修改的,它保证数据的洁净,避免数据污染而使备份失去意义。
建立一个空接口IMemento——什么方法属性都没有的接口,然后在发起人Originator类中建立一个内置类(也叫做类中类)Memento实现IMemento接口,同时也实现自己的业务逻辑。
public class Originator {
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public IMemento 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;
}
private void setState(String state) {
this.state = state;
}
}
}
public interface IMemento {
}
public class Caretaker {
//备忘录对象
private IMemento memento;
public IMemento getMemento() {
return memento;
}
public void setMemento(IMemento memento) {
this.memento = memento;
}
}
全部通过接口访问,这当然没有问题,如果你想访问它的属性那是肯定不行的。但是安全是相对的,没有绝对的安全,可以使用refelect反射修改Memento的数据。
在这里我们使用了一个新的设计方法:双接口设计,我们的一个类可以实现多个接口,在系统设计时,如果考虑对象的安全问题,则可以提供两个接口,一个是业务的正常接口,实现必要的业务逻辑,叫做宽接口;另外一个接口是一个空接口,什么方法都没有,其目的是提供给子系统外的模块访问,比如容器对象,这个叫做窄接口,由于窄接口中没有提供任何操纵数据的方法,因此相对来说比较安全。