概述:
备忘录模式提供了一种状态恢复的实现机制,使得用户可以方便地回到一个特定的历史步骤,当新的状态无效或者存在问题时,可以使用暂时存储起来的备忘录将状态复原,当前很多软件都提供了撤销(Undo)操作,其中就使用了备忘录模式。
定义:
在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式,其别名为Token。
结构:
- Originator(原发器):它是一个普通类,可以创建一个备忘录,并存储它的当前内部状态,也可以使用备忘录来恢复其内部状态,一般将需要保存内部状态的类设计为原发器。
- Memento(备忘录):存储原发器的内部状态,根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计,根据实际需要确定备忘录类中的属性。需要注意的是,除了原发器本身与负责人类之外,备忘录对象不能直接供其他类使用,原发器的设计在不同的编程语言中实现机制会有所不同。
- Caretaker(负责人):负责人又称为管理者,它负责保存备忘录,但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象,它只负责存储对象,而不能修改对象,也无须知道对象的实现细节。
UML图:
场景:如果大家玩过中国象棋的话,肯定会知道有一个悔棋的功能,当然,其他的军棋、五子棋、围棋等,都有这个功能,那么当需要悔棋时,系统会马上回到上一个状态,备忘录模式能很好的实现这个功能。
代码分析:
/**
* Created by **
* 原发器:定义棋子类
*/
public 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;
}
/**
* 保存当前状态
* @return
*/
public ChessmanMemento save(){
return new ChessmanMemento(this.label,this.x,this.y);
}
/**
* 恢复状态
* @param memento
*/
public void restore(ChessmanMemento memento){
this.label = memento.getLabel();
this.x = memento.getX();
this.y = memento.getY();
}
}
/**
* Created by **
* 备忘录
*/
public 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 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;
}
}
/**
* Created by **
* 负责人:备忘录管理类
*/
public class MementoManager {
private ChessmanMemento memento;
public void setMemento(ChessmanMemento memento) {
this.memento = memento;
}
public ChessmanMemento getMemento() {
return memento;
}
}
客户端:
MementoManager manager = new MementoManager();
Chessman chessman = new Chessman("炮", 2, 5);
displayChessmanLocal(chessman);
// 保存该棋子的状态
ChessmanMemento save = chessman.save();
manager.setMemento(save);
chessman.setX(5);
displayChessmanLocal(chessman);
// 取出备忘录对象
ChessmanMemento memento = manager.getMemento();
// 悔棋
LogFactory.log("------悔棋---------");
chessman.restore(memento);
displayChessmanLocal(chessman);
}
private void displayChessmanLocal(Chessman chessman){
LogFactory.log("棋子:"+chessman.getLabel()+",x:"+chessman.getX()+",y:"+chessman.getY());
}
log输出:
08-17 10:50:04.728 14147-14147/? D/test: 棋子:炮,x:2,y:5
08-17 10:50:04.728 14147-14147/? D/test: 棋子:炮,x:5,y:5
08-17 10:50:04.728 14147-14147/? D/test: ------悔棋---------
08-17 10:50:04.728 14147-14147/? D/test: 棋子:炮,x:2,y:5
上述的代码只能悔一步棋,如果用一个集合来存储棋子的状态,那么就可以实现一直悔棋的功能了,现在只需修改部分代码:
/**
* Created by **
* 负责人:备忘录管理类
*/
public class MementoManager {
// 用一个list集合来存储棋子状态
private List<ChessmanMemento> mementoList = new ArrayList<ChessmanMemento>();
public void setMemento(ChessmanMemento memento) {
this.mementoList.add(memento);
}
public ChessmanMemento getMemento(int i) {
return this.mementoList.get(i);
}
}
客户端:
private int index = -1;
private MementoManager manager;
manager = new MementoManager();
Chessman chessman = new Chessman("炮", 2, 5);
play(chessman);
chessman.setX(3);
play(chessman);
chessman.setY(6);
play(chessman);
LogFactory.log("index = " + index);
undo(chessman);
LogFactory.log("index = " + index);
undo(chessman);
}
private void play(Chessman chessman){
ChessmanMemento saveMemento = chessman.save();
manager.setMemento(saveMemento);
index +=1;
displayChessmanLocal(chessman);
}
private void undo(Chessman chessman){
index -=1;
ChessmanMemento chessmanMemento = manager.getMemento(index);
chessman.restore(chessmanMemento);
displayChessmanLocal(chessman);
}
private void displayChessmanLocal(Chessman chessman){
LogFactory.log("棋子:"+chessman.getLabel()+",x:"+chessman.getX()+",y:"+chessman.getY());
}
log输出:
08-17 11:13:03.227 19288-19288/? D/test: 棋子:炮,x:2,y:5
08-17 11:13:03.227 19288-19288/? D/test: 棋子:炮,x:3,y:5
08-17 11:13:03.227 19288-19288/? D/test: 棋子:炮,x:3,y:6
08-17 11:13:03.227 19288-19288/? D/test: index = 2
08-17 11:13:03.227 19288-19288/? D/test: 棋子:炮,x:3,y:5
08-17 11:13:03.227 19288-19288/? D/test: index = 1
08-17 11:13:03.227 19288-19288/? D/test: 棋子:炮,x:2,y:5
优点:
- 它提供了一种状态恢复的实现机制,使得用户可以方便地回到一个特定的历史步骤,当新的状态无效或者存在问题时,可以使用暂时存储起来的备忘录将状态复原。
- 备忘录实现了对信息的封装,一个备忘录对象是一种原发器对象状态的表示,不会被其他代码所改动。备忘录保存了原发器的状态,采用列表、堆栈等集合来存储备忘录对象可以实现多次撤销操作。
缺点:
- 资源消耗过大,如果需要保存的原发器类的成员变量太多,就不可避免需要占用大量的存储空间,每保存一次对象的状态都需要消耗一定的系统资源。
适用场景:
- 保存一个对象在某一个时刻的全部状态或部分状态,这样以后需要时它能够恢复到先前的状态,实现撤销操作。
- 防止外界对象破坏一个对象历史状态的封装性,避免将对象历史状态的实现细节暴露给外界对象。
扩展:
之前我们说过原型模式,这个模式能够克隆对象,并且跟被克隆的对象相互独立,那么在备忘录模式中我们可以跟原型模式结合使用,而且只需要修改其中部分代码:
在备忘录模式中,我们保存的是备忘录类的对象,只是这个对象跟原发器对象的属性是一致的而已。
/**
* Created by **
* 备忘录
*/
public class ChessmanMemento implements Cloneable{
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 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;
}
/**
* clone 备忘录对象
* @return
* @throws CloneNotSupportedException
*/
@Override
protected ChessmanMemento clone() throws CloneNotSupportedException {
ChessmanMemento memento = null;
memento = (ChessmanMemento) super.clone();
return memento;
}
}
客户端:
在客户端只需要将play方法修改一下就行了。
private void play(Chessman chessman){
LogFactory.log("play is start");
ChessmanMemento saveMementoClone = null;
if (saveMemento == null) {
LogFactory.log("play first start");
saveMemento = chessman.save();
manager.setMemento(saveMemento);
}else{
try {
LogFactory.log("clone is start");
saveMementoClone = saveMemento.clone();
saveMementoClone.setX(chessman.getX());
saveMementoClone.setY(chessman.getY());
manager.setMemento(saveMementoClone);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
index +=1;
displayChessmanLocal(chessman);
}
log输出:
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: play first start
08-18 16:09:52.640 12943-12943/? D/test: 棋子:炮,x:2,y:5
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: clone is start
08-18 16:09:52.640 12943-12943/? D/test: 棋子:炮,x:3,y:5
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: clone is start
08-18 16:09:52.640 12943-12943/? D/test: 棋子:炮,x:3,y:6
08-18 16:09:52.640 12943-12943/? D/test: index = 2
08-18 16:09:52.640 12943-12943/? D/test: 棋子:炮,x:3,y:5
08-18 16:09:52.640 12943-12943/? D/test: index = 1
08-18 16:09:52.640 12943-12943/? D/test: 棋子:炮,x:2,y:5
log分析:
play方法第一次执行的时候会保存备忘录对象,但是第二次之后不再去创建备忘录对象了,而是直接clone之前的备忘录对象,并且将这个对象保存在list中。这里的log跟之前的log输出都是一样的,都能恢复到前一个状态。
要了解原型模式的戳这里:原型模式