备忘录模式
例子
用月光宝盒追女生。
备忘录
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;
}
}
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 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("\n=====男孩追女孩子后的状态======");
System.out.println(boy.getState());
//追女孩失败,恢复原状
boy.restoreMemento(caretaker.getMemento());
System.out.println("\n=====男孩恢复后的状态======");
System.out.println(boy.getState());
}
}
=====男孩现在的状态======
心情很棒
=====男孩追女孩子后的状态======
心情可能很不好
=====男孩恢复后的状态======
心情很棒
定义
在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
- Originator发起人角色
记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和恢复备忘录数据。 - Memento备忘录角色
负责存储Originator发起人对象的内部状态,在需要的时候提供发起人需要的内部状态。 - Caretaker备忘录管理员角色
对备忘录进行管理、保存和提供备忘录。
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());
}
}
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;
}
}
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键等。
- 需要监控的副本场景中。例如要监控一个对象的属性,但是监控又不应该作为系统的主业务来调用,它只是边缘应用,即使出现监控不准、错误报警也影响不大,因此一般的做法是备份一个主线程中的对象,然后由分析程序来分析。
- 数据库连接的事务管理就是用的备忘录模式,想想看,如果你要实现一个JDBC驱 动,你怎么来实现事务?还不是用备忘录模式嘛!
注意事项
- 备忘录的生命期
备忘录创建出来就要在“最近”的代码中使用,要主动管理它的生命周期,建立就要使 用,不使用就要立刻删除其引用,等待垃圾回收器对它的回收处理。 - 备忘录的性能
不要在频繁建立备份的场景中使用备忘录模式(比如一个for循环中),原因有二:一是控制不了备忘录建立的对象数量;二是大对象的建立是要消耗资源的,系统的性能需要考虑。因此,如果出现这样的代码,设计师就应该好好想想怎么修改架构了。
扩展
clone方式的备忘录
我们可以通过复制的方式产生一个对象的内部 状态,这是一个很好的办法,发起人角色只要实现Cloneable就成。
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 Memento createMemento(){
return new Memento(this.state);
}
public void restoreMemento(){
this.setState(this.backup.getState());
}
@Override
protected Originator clone(){
try {
return (Originator)super.clone();
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
return null;
}
}
public class Caretaker {
private Originator originator;
public Originator getOriginator() {
return originator;
}
public void setOriginator(Originator originator) {
this.originator = originator;
}
}
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());
}
}
注意 :使用Clone方式的备忘录模式,可以使用在比较简单的场景或者比较单一的场景中,尽量不要与其他的对象产生严重的耦合关系。
多状态的备忘录模式
在实际的开发中一个对象不可能只有一个状态,一个JavaBean有多个属性非常常见,这都是它的状态。
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 "state1=" +state1+"\nstat2="+state2+"\nstate3="+state3; }
}
public class Memento {
private HashMap<String,Object> stateMap;
public Memento(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 Caretaker {
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
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();
}
}
}
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);
}
}
注意:如果要设计一个在运行期决定备份状态的框架,则建议采用AOP框架来实现,避免采用动态代理无谓地增加程序逻辑复杂性。(ps:应该是使用aop框架,不要自己在代码里自己实现)
多备份的备忘录
我们先来说一个名词,检查点(Check Point),也就是你在备份的时候做的戳记,系统 级的备份一般是时间戳,那我们程序的检查点该怎么设计呢?一般是一个有意义的字符串。我们只要把通用代码中的Caretaker管理员稍做修改就可以了。
public class Caretaker {
private HashMap<String, Memento> memMap = new HashMap<>();
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的上限,否则系统很容易产生内存溢出情况。
封装得更好一点
在系统管理上,一个备份的数据是完全、绝对不能修改的,它保证数据的洁净,避免数据污染而使备份失去意义。在我们的设计领域中,也存在着同样的问题,备份是不能被篡改的,也就是说需要缩小备份出的备忘录的阅读权限,保证只能是发起人可读就成了,使用内置类。
public interface 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 class Caretaker {
private IMemento memento;
public IMemento getMemento() {
return memento;
}
public void setMemento(IMemento memento) {
this.memento = memento;
}
}
在这里我们使用了一个新的设计方法:双接口设计,我们的一个类可以实现多个接口, 在系统设计时,如果考虑对象的安全问题,则可以提供两个接口,一个是业务的正常接口, 实现必要的业务逻辑,叫做宽接口;另外一个接口是一个空接口,什么方法都没有,其目的 是提供给子系统外的模块访问,比如容器对象,这个叫做窄接口,由于窄接口中没有提供任何操纵数据的方法,因此相对来说比较安全。