备忘录模式(Memento Pattern):在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式,其别名为Token。
备忘录模式经常可以遇到,譬如下面这些场景:
角色
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 mementoList = new ArrayList(); //备忘录集合
/**
* 保存备忘录
* @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
棋子类 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 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
的时候,恢复这些数据。通过这两个函数,开发人员能够在某些特殊场景下存储与界面相关的信息,提升用户体验。
备忘录模式是在不破坏封装的条件下,通过备忘录对象(Memento)存储另外一个对象内部状态的快照,在将来合适的时候把这个对象还原到存储起来的状态。
优点
缺点
消耗资源,如果累的成员变量过多,势必会占用比较大的资源,而且每一次保存都会消耗一定的内存。