备忘录模式(Memento Pattern)：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为Token。
备忘录模式经常可以遇到，譬如下面这些场景：
- 典型的例子就是游戏存档和读档的这个行为。
- 浏览器回退：浏览器一般有浏览记录，当我们在一个网页上点击几次链接之后，可在左上角点击左箭头回退到上一次的页面，然后也可以点击右箭头重新回到当前页面
- 数据库备份与还原：一般的数据库都支持备份与还原操作，备份即将当前已有的数据或者记录保留，还原即将已经保留的数据恢复到对应的表中
- 编辑器撤销与重做：在编辑器上编辑文字，写错时可以按快捷键 Ctrl + z 撤销，撤销后可以按 Ctrl + y 重做
- 虚拟机生成快照与恢复：虚拟机可以生成一个快照，当虚拟机发生错误时可以恢复到快照的样子
- Git版本管理：Git是最常见的版本管理软件，每提交一个新版本，实际上Git就会把它们自动串成一条时间线，每个版本都有一个版本号，使用 git reset --hard 版本号 即可回到指定的版本，让代码时空穿梭回到过去某个历史时刻
- 棋牌游戏悔棋：在棋牌游戏中，有时下快了可以悔棋，回退到上一步重新下
角色
Originator（原发器）：它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。
Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。
Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。
备忘录模式的核心是备忘录类以及用于管理备忘录的负责人类的设计。
第一步、创建原发器也就是一个带有状态的角色
/**
* 原发器
*/
public class Originator {
private String state;
/**
* 设置当前状态
* @param state
*/
public void setState(String state){
this.state = state;
}
/**
* 得到当前状态
* @return
*/
public String getState() {
return state;
}
/** 创建一个新的备忘录对象，存储当前状态 */
public Memento saveStateToMemento(){
return new Memento(state);
}
/** 将发起者的状态恢复到备忘录的状态 */
public void restore(Memento memento){
this.state = memento.getState();
}
}第二步、创建备忘录，用来保存原发器状态
/**
* 备忘录
*/
public class Memento {
private String state;
public Memento(String state){
this.state = state;
}
public String getState() {
return state;
}
}第三步、创建备忘录管理者
/**
* 备忘录管理者
*/
public class CareTaker {
private List<Memento> mementoList = new ArrayList<Memento>(); //备忘录集合
/**
* 保存备忘录
* @param state
*/
public void add(Memento state){
mementoList.add(state);
}
/**
* 获得备忘录
* @param index
* @return
*/
public Memento get(int index){
return mementoList.get(index);
}
}测试
/**
* 测试类
*/
public class Client {
public static void main(String[] args) {
//创建一个角色
Originator originator = new Originator();
//创建备忘录管理者
CareTaker careTaker = new CareTaker();
originator.setState("State #1");
originator.setState("State #2");
//保存当前角色状态到备忘录，同时将备忘录保存到备忘录管理者
careTaker.add(originator.saveStateToMemento());
originator.setState("State #3");
careTaker.add(originator.saveStateToMemento());
//恢复角色状态
originator.restore(careTaker.get(0));
System.out.println("First saved State: " + originator.getState());
originator.restore(careTaker.get(1));
System.out.println("Second saved State: " + originator.getState());
}
}First saved State: State #2
Second saved State: State #3示例2：下棋例子，可以下棋，悔棋，撤销悔棋等
棋子类 Chessman，原发器角色
/**
* 棋子类 Chessman，原发器角色
*/
class Chessman {
private String label;
private int x;
private int y;
public Chessman(String label, int x, int y) {
this.label = label;
this.x = x;
this.y = y;
}
public void setLabel(String label) {
this.label = label;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public String getLabel() {
return label;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
//保存状态
public ChessmanMemento save() {
return new ChessmanMemento(this.label, this.x, this.y);
}
//恢复状态
public void restore(ChessmanMemento memento) {
this.label = memento.getLabel();
this.x = memento.getX();
this.y = memento.getY();
}
public void show() {
System.out.println(String.format("棋子<%s>：当前位置为：<%d, %d>", this.getLabel(), this.getX(), this.getY()));
}
}备忘录角色 ChessmanMemento
/**
* 备忘录角色
*/
class ChessmanMemento {
private String label;
private int x;
private int y;
public ChessmanMemento(String label, int x, int y) {
this.label = label;
this.x = x;
this.y = y;
}
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}负责人角色 MementoCaretaker
/**
* 负责人角色
*/
class MementoCaretaker {
//定义一个集合来存储备忘录
private ArrayList<ChessmanMemento> mementolist = new ArrayList<>();
public ChessmanMemento getMemento(int i) {
return mementolist.get(i);
}
public void addMemento(ChessmanMemento memento) {
mementolist.add(memento);
}
}棋子客户端，维护了一个 MementoCaretaker 对象
/**
* 棋子客户端，维护了一个 MementoCaretaker 对象
*/
class Client {
private static int index = -1;
private static MementoCaretaker mc = new MementoCaretaker();
public static void main(String args[]) {
Chessman chess = new Chessman("车", 1, 1);
play(chess);
chess.setY(4);
play(chess);
chess.setX(5);
play(chess);
undo(chess, index);
undo(chess, index);
redo(chess, index);
redo(chess, index);
}
//下棋，同时保存备忘录
public static void play(Chessman chess) {
mc.addMemento(chess.save());
index++;
chess.show();
}
//悔棋，撤销到上一个备忘录
public static void undo(Chessman chess, int i) {
System.out.println("******悔棋******");
index--;
chess.restore(mc.getMemento(i - 1));
chess.show();
}
//撤销悔棋，恢复到下一个备忘录
public static void redo(Chessman chess, int i) {
System.out.println("******撤销悔棋******");
index++;
chess.restore(mc.getMemento(i + 1));
chess.show();
}
}输出如下，悔棋成功，撤销悔棋成功
棋子<车>：当前位置为：<1, 1>
棋子<车>：当前位置为：<1, 4>
棋子<车>：当前位置为：<5, 4>
******悔棋******
棋子<车>：当前位置为：<1, 4>
******悔棋******
棋子<车>：当前位置为：<1, 1>
******撤销悔棋******
棋子<车>：当前位置为：<1, 4>
******撤销悔棋******
棋子<车>：当前位置为：<5, 4>
基本这就是备忘录模式的结构了，可以看出其模式的封闭性，对于状态得存储只有Originator知道
在Android开发中，备忘录模式的典型就是Activity中的状态保存，也就是onSaveInstanceState和onRestoreInstanceState。当Activity不是正常退出，且Activity在随后的时间内被系统杀死之前回调用这两个方法让开发人员可以有机会存储Activity相关的信息，并且在下次返回Activity的时候，恢复这些数据。通过这两个函数，开发人员能够在某些特殊场景下存储与界面相关的信息，提升用户体验。
3. 总结
备忘录模式是在不破坏封装的条件下，通过备忘录对象（Memento）存储另外一个对象内部状态的快照，在将来合适的时候把这个对象还原到存储起来的状态。
优点
- 给用户提供了一种可以恢复状态的机制，可以是用户能够方便的回到某个历史的状态
- 实现了信息的封装，使用户不需要关心状态的保存细节
- 被存储的状态放在外面。不用和关键对象混合在一起，可以帮助维护内聚
缺点
消耗资源，如果累的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
