备忘录模式又叫做快照模式(Snapshot Pattern)或Token模式，是对象的行为模式。
备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代器模式一同使用。
一、备忘录模式的结构
备忘录模式的结构图如下所示
备忘录模式所涉及的角色有三个：备忘录(Memento)角色、发起人(Originator)角色、负责人(Caretaker)角色。
1. 备忘录(Memento)角色
备忘录角色又如下责任：
- 将发起人（Originator）对象的内存状态存储起来。备忘录可以根据发起人对象的判断来决定存储多少发起人（Originator）对象的内部状态。
- 备忘录可以保护其内容不被发起人（Originator）对象之外的任何对象所读取。
备忘录有两个等效的接口：
- 窄接口：负责人（Caretaker）对象（和其他除发起人对象之外的任何对象）看到的是备忘录的窄接口(narrow interface)，这个窄接口只允许它把备忘录对象传给其他的对象。
- 宽接口：与负责人对象看到的窄接口相反的是，发起人对象可以看到一个宽接口(wide interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。
2. 发起人（Originator）角色
发起人角色有如下责任：
- 创建一个含有当前的内部状态的备忘录对象。
- 使用备忘录对象存储其内部状态。
3. 负责人（Caretaker）角色
负责人角色有如下责任：
- 负责保存备忘录对象。
- 不检查备忘录对象的内容。
二、“白箱”备忘录模式的实现
备忘录角色对任何对象都提供一个接口，即宽接口，备忘录角色的内部所存储的状态就对所有对象公开。因此这个实现又叫做“白箱实现”。
“白箱”实现将发起人角色的状态存储在一个大家都看得到的地方，因此是破坏封装性的。但是通过程序员自律，同样可以在一定程度上实现模式的大部分用意。因此白箱实现仍然是有意义的。
下面给出一个示意性的“白箱实现”。
代码实现如下：
/**
* 备忘录角色，备忘录对象将发起人对象传入的状态存储起来。
*/
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 Originator {
private String state;
/**
* 工厂方法，创建一个新的备忘录对象
* @return
*/
public Memento createMemento() {
return new Memento(state);
}
/**
* 通过备忘录对象，将发起人状态恢复到备忘录记载的状态
* @param memento
*/
public void restoreMemento(Memento memento) {
this.state = memento.getState();
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
System.out.println("发起人当前状态：" + this.state);
}
}
/**
* 负责人角色，负责保存备忘录对象，但是从不修改（甚至不查看）备忘录对象的内容。
*/
public class Caretaker {
private Memento memento;
/**
* 备忘录取值方法
* @return
*/
public Memento retrieveMemento() {
return this.memento;
}
/**
* 备忘录的赋值方法
*/
public void saveMemento(Memento memento) {
this.memento = memento;
}
}
/**
* 测试类
*/
public class Client {
public static void main(String[] args) {
// 发起人角色
Originator originator = new Originator();
// 负责人角色
Caretaker caretaker = new Caretaker();
// 设置状态
originator.setState("ON");
// 创建一个备忘录对象，并使用负责人对象保存
caretaker.saveMemento(originator.createMemento());
// 修改发起人状态
originator.setState("OFF");
// 恢复发起人对象的状态
originator.restoreMemento(caretaker.retrieveMemento());
System.out.println("发起人状态恢复到：" + originator.getState());
}
}运行结果：
发起人当前状态：ON 发起人当前状态：OFF 发起人状态恢复到：ON
在上面的这个示意性的客户端角色里面，首先将发起人对象的状态设置成“On”，并创建一个备忘录对象将这个状态存储起来；然后将发起人对象的状态改成“Off”；最后又将发起人对象恢复到备忘录对象所存储起来的状态，即“On”状态。
系统的时序图更能够反映出系统各个角色被调用的时间顺序。如下图是将发起人对象的状态存储到白箱备忘录对象中去的时序图。
可以看出系统运行的时序是这样的：
- 将发起人对象的状态设置成“On”
- 调用发起人角色的
createMemento()方法，创建一个备忘录对象将这个状态存储起来。 - 将备忘录对象存储到负责人对象中去。
将发起人对象恢复到备忘录对象所记录的状态的时序图如下所示：
可以看出，将发起人对象恢复到备忘录对象所记录的状态时，系统的运行时序是这样的：
- 将发起人状态设置成 “Off” 。
- 将备忘录对象从负责人对象中取出。
- 将发起人对象恢复到备忘录对象所存储起来的状态，即“On”状态。
三、“黑箱”备忘录模式的实现
备忘录角色对发起人（Originator）角色对象提供一个宽接口，而为其他对象提供一个窄接口。这样的实现叫做“黑箱实现”。
在JAVA语言中，实现双重接口的办法就是将 备忘录角色类 设计成 发起人角色类 的内部成员类。
将 Memento 设成 Originator 类的内部类，从而将 Memento 对象封装在 Originator 里面；在外部提供一个标识接口 MementoIF 给Caretaker以及其他对象。这样，Originator 类看到的是 Menmento 的所有接口，而 Caretaker 以及其他对象看到的仅仅是标识接口 MementoIF 所暴露出来的接口。
使用内部类实现备忘录模式的类图如下所示。
代码实现如下：
/**
* 窄接口MementoIF，这是一个标识接口，没有定义出任何的方法。
*/
public interface MementoIF {
}
/**
* 发起人角色， 定义了一个内部的Memento类。由于此Memento类的全部接口都是私有的，因此只有它自己和发起人类可以调用。
*/
public class Originator {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
System.out.println("发起人当前状态：" + this.state);
}
/**
* 工厂方法，创建一个新的备忘录对象
* @return
*/
public MementoIF createMemento() {
return new Memento(this.state);
}
/**
* 发起人恢复到备忘录对象记录的状态
*/
public void restoreMemento(MementoIF mementoIF) {
Memento memento = (Memento) mementoIF;
this.setState(memento.getState());
}
/**
* 备忘录角色，实现MementoIF接口，作为内部类发起人类可以全部使用其功能接口，其它类只能获得其接口引用
*/
private class Memento implements MementoIF {
private String state;
private Memento(String state) {
this.state = state;
}
private String getState() {
return state;
}
private void setState(String state) {
this.state = state;
}
}
}
/**
* 负责人对象，得到的备忘录对象是以MementoIF为接口的，由于这个接口仅仅是一个标识接口，因此负责人角色不可能改变这个备忘录对象的内容。
*/
public class Caretaker {
private MementoIF mementoIF;
/**
* 获取备忘录对象
* @return
*/
public MementoIF retrieveMemento() {
return mementoIF;
}
/**
* 备忘录赋值方法
* @param mementoIF
*/
public void saveMemento(MementoIF mementoIF) {
this.mementoIF = mementoIF;
}
}
/**
* 测试类
*/
public class Client {
public static void main(String[] args) {
// 发起人对象
Originator originator = new Originator();
// 负责人对象
Caretaker caretaker = new Caretaker();
// 设置状态
originator.setState("ON");
// 创建备忘录
MementoIF mementoIF = originator.createMemento();
// 负责人对象保存备忘录
caretaker.saveMemento(mementoIF);
// 改变发起人状态
originator.setState("OFF");
// 通过备忘录，恢复发起人对象的状态
originator.restoreMemento(caretaker.retrieveMemento());
}
}运行结果如下：
发起人当前状态：ON 发起人当前状态：OFF 发起人当前状态：ON
客户端首先
- 将发起人对象的状态设置为“On”。
- 调用
createMemento()方法，创建一个备忘录对象将这个状态存储起来（此时createMemento()方法还回的类型是MementoIF接口，真实类型为Originator内部的Memento对象）。 - 将备忘录对象存储到负责人对象中去。由于负责人对象拿到的仅是
MementoIF接口，因此无法读出备忘录对象内部的状态。 - 将发起人对象的状态设置为“Off”。
- 调用负责人对象的
retrieveMemento()方法将备忘录对象取出。注意此时仅能得到MementoIF接口，因此无法读出此对象的内部状态。 - 调用发起人对象的
restoreMemento()方法将发起人对象的状态恢复成备忘录对象所存储的起来的状态，即“On”状态。由于发起人对象的内部类Memento实现了MementoIF接口，这个内部类是传入的备忘录对象的真实类型，因此发起人对象可以利用内部类Memento的私有接口读出此对象的内部状态。
四、多重检查点
前面所给出的白箱和黑箱的示意性实现都是只存储一个状态的简单实现，也可以叫做只有一个检查点。常见的系统往往需要存储不止一个状态，而是需要存储多个状态，或者叫做有多个检查点。
备忘录模式可以将发起人对象的状态存储到备忘录对象里面，备忘录模式可以将发起人对象恢复到备忘录对象所存储的某一个检查点上。下面给出一个示意性的、有多重检查点的备忘录模式的实现。
代码实现如下：
/**
* 备忘录角色，这个实现可以存储任意多的状态，外界可以使用检查点索引index来取出检查点上的状态。
*/
public class Memento {
private List<String> states;
private int index;
public Memento(List<String> states, int index) {
// states是引用，重新创建新的对象
this.states = new ArrayList<>(states);
this.index = index;
}
public List<String> getStates() {
return states;
}
public int getIndex() {
return index;
}
}
/**
* 发起人角色
*/
public class Originator {
private List<String> states;
//检查点指数
private int index;
public Originator() {
this.states = new ArrayList<>();
this.index = 0;
}
/**
* 工厂方法，返还一个新的备忘录对象
*/
public Memento createMemento(){
return new Memento(states , index);
}
/**
* 将发起人恢复到备忘录对象记录的状态上
*/
public void restoreMemento(Memento memento){
states = memento.getStates();
index = memento.getIndex();
}
/**
* 状态赋值，更新states和索引
* @param state
*/
public void setState(String state) {
this.states.add(state);
this.index++;
}
/**
* 打印当前检查点的状态
*/
public void printStates() {
System.out.print("发起人检查点索引：" + this.index + "， 状态：");
for (String state : states) {
System.out.print(state + " ");
}
System.out.println();
}
}
/**
* 负责人角色
*/
public class Caretaker {
private Originator originator;
private List<Memento> mementos;
private int current;
public Caretaker(Originator originator) {
this.originator = originator;
mementos = new ArrayList<>();
current = 0;
}
/**
* 创建一个新的检查点
* @return
*/
public int createMemento() {
Memento memento = originator.createMemento();
mementos.add(memento);
return current++;
}
/**
* 将发起人恢复到某个检查点
* @param index
*/
public void restoreMemento(int index) {
Memento memento = mementos.get(index);
originator.restoreMemento(memento);
}
/**
* 删除某个检查点
* @param index
*/
public void removeMemento(int index) {
mementos.remove(index);
}
}
/**
* 测试类
*/
public class Client {
public static void main(String[] args) {
// 发起人
Originator originator = new Originator();
// 负责人
Caretaker caretaker = new Caretaker(originator);
// 变更状态，并保存检查点
originator.setState("State 0");
caretaker.createMemento();
// 变更状态，并保存检查点
originator.setState("State 1");
caretaker.createMemento();
// 变更状态，并保存检查点
originator.setState("State 2");
caretaker.createMemento();
// 打印当前检查点
originator.printStates();
// 恢复到检查点1
caretaker.restoreMemento(1);
// 打印当前检查点
originator.printStates();
// 恢复到检查点2
caretaker.restoreMemento(2);
// 打印当前检查点
originator.printStates();
}
}运行结果：
发起人检查点索引：3， 状态：State 0 State 1 State 2 发起人检查点索引：2， 状态：State 0 State 1 发起人检查点索引：3， 状态：State 0 State 1 State 2
可以看出，客户端角色通过不断改变发起人角色的状态，并将之存储在备忘录里面。通过指明检查点指数可以将发起人角色恢复到相应的检查点所对应的状态上。
将发起人的状态存储到备忘录对象中的活动序列图如下：
系统运行的时序是这样的：
- 将发起人对象的状态设置成某个有效状态；
- 调用负责人角色的
createMemento()方法，负责人角色会负责调用发起人角色和备忘录角色，将发起人对象的状态存储起来。
将发起人对象恢复到某一个备忘录对象的检查点的活动序列图如下：
由于负责人角色的功能被增强了，因此将发起人对象恢复到备忘录对象所记录的状态时，系统运行的时序被简化了：
- 调用负责人角色的
restoreMemento()方法，将发起人恢复到某个检查点。
五、“自述历史”模式
所谓“自述历史”模式(History-On-Self Pattern)实际上就是备忘录模式的一个变种。在备忘录模式中，发起人(Originator)角色、负责人(Caretaker)角色和备忘录(Memento)角色都是独立的角色。虽然在实现上备忘录类可以成为发起人类的内部成员类，但是备忘录类仍然保持作为一个角色的独立意义。在“自述历史”模式里面，发起人角色自己兼任负责人角色。
“自述历史”模式的类图如下所示：
备忘录角色有如下责任：
- 将发起人（Originator）对象的内部状态存储起来。
- 备忘录可以保护其内容不被发起人（Originator）对象之外的任何对象所读取。
发起人角色有如下责任：
- 创建一个含有它当前的内部状态的备忘录对象。
- 使用备忘录对象存储其内部状态。
客户端角色有负责保存备忘录对象的责任。
代码实现如下：
/**
* 窄接口MementoIF，这是一个标识接口，因此它没有定义出任何的方法。
*/
public interface MementoIF {
}
/**
* 发起人角色同时还兼任负责人角色，也就是说它自己负责保持自己的备忘录对象。
*/
public class Originator {
public String state;
/**
* 改变状态
* @param state
*/
public void changeState(String state) {
this.state = state;
System.out.println("状态改变为：" + state);
}
/**
* 工厂方法，返还一个新的备忘录对象
*/
public MementoIF createMemento() {
return new Memento(this);
}
/**
* 将发起人恢复到备忘录对象所记录的状态上
*/
public void restoreMemento(MementoIF mementoIF) {
Memento memento = (Memento) mementoIF;
changeState(memento.getState());
}
public String getState() {
return state;
}
/**
* 备忘录角色，作为内部类
*/
private class Memento implements MementoIF {
private String state;
/**
* 构造方法
* @param originator
*/
public Memento(Originator originator) {
this.state = originator.getState();
}
public String getState() {
return state;
}
}
}
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
// 发起人
Originator originator = new Originator();
// 改变状态
originator.changeState("ON");
// 存储发起人状态
MementoIF memento = originator.createMemento();
// 改变状态
originator.changeState("OFF");
// 恢复发起人状态
originator.restoreMemento(memento);
}
}运行结果：
状态改变为：ON 状态改变为：OFF 状态改变为：ON
由于“自述历史”作为一个备忘录模式的特殊实现形式非常简单易懂，它可能是备忘录模式最为流行的实现形式。
参考链接：https://www.cnblogs.com/java-my-life/archive/2012/06/06/2534942.html
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 george_95@126.com