一、备忘录模式
在不破坏封装的前提下，存储关键对象的重要状态，从而可以在将来把对象还原到存储的那个状态
备忘录模式
二、示例
游戏进度保存：游戏开发过程中需要对人物的属性进行缓存，例如血量、经验值等等，但是一个大的项目中时多人协同开发，每个开发人员完成不同的功能时需要保存不同的属性，并且保存的数据格式不同
为了解决多人协同开发，且每个开发者保存的数据属性，格式都不相同的缓存数据的问题，引入备忘录模式
备忘录模式通过定义一个统一的备忘录对象，用来存储和读取缓存信息，并定义一个统一的接口，开发人员将保存的对象都实现该接口即可实现统一的读取操作
1.定义备忘录对象
/**
* 备忘录模式，开发人员使用的存储方法，用来保存和返回外部开发人员需要缓存的数据
*/
public class MementoCaretaker {
private HashMap<String, MementoIF> mementomap;
public MementoCaretaker() {
mementomap = new HashMap<String, MementoIF>();
}
public MementoIF retrieveMemento(String name) {
return mementomap.get(name);
}
/**
* 备忘录赋值方法
*/
public void saveMemento(String name, MementoIF memento) {
this.mementomap.put(name, memento);
}
}
2.定义开发者缓存对象需实现的接口
/**
* 备忘录模式，定义接口，不需要写方法，起到安全保护和统一存储的作用
*/
public interface MementoIF {
}
3.不同的开发者内部实现自己不同的缓存方法和对象
/**
* 备忘录模式，第一个开发者，使用HashMap缓存数据，通过Memento类实现接口MementoIF统一封装
*/
public class Originator {
private HashMap<String, String> state;
public Originator() {
state = new HashMap();
}
public MementoIF createMemento() {
return new Memento(state);
}
public void restoreMemento(MementoIF memento) {
state = ((Memento) memento).getState();
}
public void showState() {
System.out.println("now state:" + state.toString());
}
public void testState1() {
state.put("blood", "500");
state.put("progress", "gate1 end");
state.put("enemy", "5");
}
public void testState2() {
state.put("blood", "450");
state.put("progress", "gate3 start");
state.put("enemy", "3");
}
private class Memento implements MementoIF {
private HashMap<String, String> state;
private Memento(HashMap state) {
this.state = new HashMap(state);
}
private HashMap getState() {
return state;
}
private void setState(HashMap state) {
this.state = state;
}
}
}
/**
* 备忘录模式，第一个开发者，使用ArrayList缓存数据，通过Memento类实现接口MementoIF统一封装
*/
public class Originator2 {
private ArrayList<String> state;
public Originator2() {
state = new ArrayList<String>();
}
public MementoIF createMemento() {
return new Memento(state);
}
public void restoreMemento(MementoIF memento) {
state = ((Memento) memento).getState();
}
public void testState1() {
state = new ArrayList<String>();
state.add("blood:320");
state.add("progress:gate2 mid");
state.add("enemy:15");
}
public void testState2() {
state = new ArrayList<String>();
state.add("blood:230");
state.add("progress:gate8 last");
state.add("enemy:12");
}
public void showState() {
System.out.println("now state:" + state.toString());
}
private class Memento implements MementoIF {
private ArrayList<String> state;
private Memento(ArrayList<String> state) {
this.state = new ArrayList(state);
}
private ArrayList<String> getState() {
return state;
}
private void setState(ArrayList<String> state) {
this.state = state;
}
}
}
4.外部直接使用备忘录对象进行存储，开发者之间互不干扰
/**
* 备忘录模式：在不破坏封装的前提下，存储关键对象的重要状态，从而可以在将来把对象还原到存储的那个状态
*/
public class MainTest {
public static void main(String[] args) {
MementoCaretaker mMementoCaretaker = new MementoCaretaker();
Originator mOriginator = new Originator();
Originator2 mOriginator2 = new Originator2();
System.out.println("*****Originator*****");
mOriginator.testState1();
// 保存第一个人的数据
mMementoCaretaker.saveMemento("Originator", mOriginator.createMemento());
mOriginator.showState();
mOriginator.testState2();
mOriginator.showState();
// 重置数据
mOriginator.restoreMemento(mMementoCaretaker.retrieveMemento("Originator"));
mOriginator.showState();
System.out.println("*****Originator 2*****");
mOriginator2.testState1();
mOriginator2.showState();
// 保存第二个人的进度
mMementoCaretaker.saveMemento("Originator2", mOriginator2.createMemento());
mOriginator2.testState2();
mOriginator2.showState();
// 重置数据
mOriginator2.restoreMemento(mMementoCaretaker.retrieveMemento("Originator2"));
mOriginator2.showState();
}
三、总结
-
优点：
- 状态存储在外面，不和关键对象混在一起，这可以帮助维护内聚
- 提供了容易实现的恢复能力
- 保持了关键对象的数据封装
-
缺点：
- 资源消耗上面备忘录对象会很昂贵
- 存储和恢复状态的过程比较耗时
-
适用场合：
- 必须保存一个对象在某一个时刻的(整体或部分)状态，在对象以外的地方, 以后需要时恢复到先前的状态时
Java设计模式所有示例代码，持续更新中
网友评论