设计模式之备忘录模式

设计模式之备忘录模式

1. 什么是备忘录模式

备忘录模式就是说在不破坏封装的前提下，存储关键对象的重要状态，从而可以在将来把对象还原到存储的那个状态。

备忘录模式的结构：

如果一个对象需要保存状态并可通过undo或rollback等操作恢复到以前的状态时，可以使用Memento模式。

• Originator（原生者）需要被保存状态以便恢复的那个对象。

• Memento（备忘录）该对象由Originator创建，主要用来保存Originator的内部状态。

• Caretaker（管理者）负责在适当的时间保存/恢复Originator对象的状态。

具体的就是说：

• 一个类需要保存它的对象的状态（相当于Originator角色）
• 设计一个类，该类只是用来保存上述对象的状态（相当于Memento角色）
• 需要的时候，Caretaker角色要求Originator返回一个Memento并加以保存
• undo或rollback操作时，通过Caretaker保存的Memento恢复Originator对象的状态

优缺点：

优点：

• 状态存储在外面，不和关键对象混在一起，这可以帮助维护内聚

• 提供了容易实现的恢复能力

• 保持了关键对象的数据封装

缺点：

• 资源消耗上面备忘录对象会很昂贵

• 存储和恢复状态的过程比较耗时

2. 具体实例

游戏进度保存：对象状态，场景…然后一个游戏中或者团队中有很多人要保存进度，然后每个人保存的进度必须是独立的，读取的时候也是只能自己读取自己的状态，这个时候我们就使用备忘录模式来设计。设计的类图如下：

就是先设计一个备忘录的接口，然后由具体的发起者去实现和扩展这个接口，当发起者需要保存状态时就创建一个备忘录然后交给Caretaker（管理者）去管理，读取的时候直接从管理者那里读取，并且只能读取到自己的状态。

看一下具体的代码实现：

备忘录的接口:空的，因为这个例子中没有什么要实现的，具体的都要发起者中自己个性化实现了。

public interface 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;
		}
	}
}

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;
		}
	}
}

备忘录的管理者

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);
	}
}

测试类：

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();

		//System.out.println("*****Originator&&Originator 2*****");
		//mOriginator.restoreMemento(mMementoCaretaker
		//.retrieveMemento("Originator2"));
		//mOriginator.showState();
	}
}