备忘录模式
一、模式定义
在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存前的状态。
备忘录模式又叫做快照模式(Snapshot Pattern)或Token模式,属于行为模式。
二、 结构
组成部分:
- 发起人(Originator):负责创建一个备忘录Memento,用以记录当前时刻自身的内部状态,并可使用备忘录恢复内部状态。发起人可以根据需要觉得备忘录存储自己的哪些内部状态。
- 备忘录(Memento):负责存储发起人对象的内部状态,并可以防止发起人以外的其他对象访问备忘录。备忘录有两个接口:管理者只能看到备忘录的窄接口,他只能将备忘录传递给其他对象。发起人却可以看到备忘录的宽接口,允许它访问返回到先前状态所需要的所有数据。
- 管理者(Caretaker):负责备忘录,不能对备忘录的内容进行访问或者操作。
三、例子---游戏进度保存
实例:以保存游戏进度为例,在游戏角色大战Boss前将该角色的状态存储,与Boss作战后角色的各项能力会下降,如果没有通关,则可利用备忘录进行恢复到战前状态。
Memento
- public class Memento {
- private int vitality; //生命力
- private int aggressivity; //攻击力
- private int defencivity; //防御力
- public int getVitality() {
- return vitality;
- }
- public void setVitality(int vitality) {
- this.vitality = vitality;
- }
- public int getAggressivity() {
- return aggressivity;
- }
- public void setAggressivity(int aggressivity) {
- this.aggressivity = aggressivity;
- }
- public int getDefencivity() {
- return defencivity;
- }
- public void setDefencivity(int defencivity) {
- this.defencivity = defencivity;
- }
- }
发起人可以看到备忘录的宽接口,允许它访问返回到先前状态所需要的所有数据。
- public class PlayerOriginator {
- private int vitality; //生命力
- private int aggressivity; //攻击力
- private int defencivity; //防御力
- public PlayerOriginator(int vitality, int aggressivity, int defencivity) {
- this.vitality = vitality;
- this.aggressivity = aggressivity;
- this.defencivity = defencivity;
- }
- public int getVitality() {
- return vitality;
- }
- public void setVitality(int vitality) {
- this.vitality = vitality;
- }
- public int getAggressivity() {
- return aggressivity;
- }
- public void setAggressivity(int aggressivity) {
- this.aggressivity = aggressivity;
- }
- public int getDefencivity() {
- return defencivity;
- }
- public void setDefencivity(int defencivity) {
- this.defencivity = defencivity;
- }
- public Memento createMemento() {
- Memento memento = new Memento();
- memento.setVitality(this.vitality);
- memento.setAggressivity(this.aggressivity);
- memento.setDefencivity(this.defencivity);
- return memento;
- }
- public void setMemento(Memento memento) {
- this.vitality = memento.getVitality();
- this.aggressivity = memento.getAggressivity();
- this.defencivity = memento.getDefencivity();
- }
- public void showState() {
- System.out.print("vitality:" + this.vitality);
- System.out.print("; aggressivity:" + this.aggressivity);
- System.out.println("; defencivity:" + this.defencivity);
- }
- }
管理者 只能看到备忘录的窄接口,他只能将备忘录传递给其他对象
- public class Caretaker {
- private Memento memento;
- public Memento getMemento() {
- return memento;
- }
- public void setMemento( Memento memento) {
- this.memento = memento;
- }
- }
场景类
- public class Client {
- public static void main(final String[] args) {
- PlayerOriginator player = new PlayerOriginator(100, 100, 100);
- System.out.print("player's original attributes are ");
- player.showState();
- Caretaker taker = new Caretaker();
- taker.setMemento(player.createMemento());
- player.setVitality(70);
- player.setAggressivity(60);
- player.setDefencivity(20);
- System.out.print("after player fight with Boss, player's attributes are ");
- player.showState();
- //reset player's attribute
- player.setMemento(taker.getMemento());
- System.out.print("after resetting, player's attributes are ");
- player.showState();
- }
- }
运行结果
player's original attributes are vitality:100; aggressivity:100; defencivity:100 after player fight with Boss, player's attributes are vitality:70; aggressivity:60; defencivity:20 after resetting, player's attributes are vitality:100; aggressivity:100; defencivity:100 |
四、 适用场景
- 在程序运行过程中,某些对象的状态处在转换过程中,可能由于某种原因需要保存此时对象的状态,以便程序运行到某个特定阶段,需要恢复到对象之前处于某个点时的状态。
- 如果使用一些公有接口让其它对象来得到对象的状态,便会暴露对象的实现细节。
-
如果有需要提供回滚操作的需求,使用备忘录模式非常适合,比如jdbc的事务操作,文本编辑器的Ctrl+Z恢复等。
五、备忘录模式的优点:
·当发起人角色中的状态改变时,有可能这是个错误的改变,我们使用备忘录模式就可以把这个错误的改变还原。
·备份的状态是保存在发起人角色之外的,这样,发起人角色就不需要对各个备份的状态进行管理。
六、备忘录模式的缺点:
在实际应用中,备忘录模式都是多状态和多备份的,发起人角色的状态需要存储到备忘录对象中,对资源的消耗是比较严重的。
七、多状态多备份备忘录
通用代码演示的例子中,Originator类只有一个state变量需要备份,而通常情况下,发起人角色通常是一个javaBean,对象中需要备份的变量不止一个,需要备份的状态也不止一个,这就是多状态多备份备忘录。实现备忘录的方法很多,备忘录模式有很多变形和处理方式,像通用代码那样的方式一般不会用到,多数情况下的备忘录模式,是多状态多备份的。其实实现多状态多备份也很简单,最常用的方法是,我们在Memento中增加一个Map容器来存储所有的状态,在Caretaker类中同样使用一个Map容器才存储所有的备份。下面我们给出一个多状态多备份的例子:
- import java.beans.BeanInfo;
- import java.beans.Introspector;
- import java.beans.PropertyDescriptor;
- import java.lang.reflect.Method;
- import java.util.HashMap;
- import java.util.Map;
- class Originator {
- private String state1 = "";
- private String state2 = "";
- private String state3 = "";
- public String getState1() {
- return state1;
- }
- public void setState1(String state1) {
- this.state1 = state1;
- }
- public String getState2() {
- return state2;
- }
- public void setState2(String state2) {
- this.state2 = state2;
- }
- public String getState3() {
- return state3;
- }
- public void setState3(String state3) {
- this.state3 = state3;
- }
- public Memento createMemento() {
- return new Memento(BeanUtils.backupProp(this));
- }
- public void restoreMemento(Memento memento) {
- BeanUtils.restoreProp(this, memento.getStateMap());
- }
- public String toString() {
- return "state1=" + state1 + "state2=" + state2 + "state3=" + state3;
- }
- }
- class Memento {
- private Map<String, Object> stateMap;
- public Memento(Map<String, Object> map) {
- this.stateMap = map;
- }
- public Map<String, Object> getStateMap() {
- return stateMap;
- }
- public void setStateMap(Map<String, Object> stateMap) {
- this.stateMap = stateMap;
- }
- }
- class BeanUtils {
- public static Map<String, Object> backupProp(Object bean) {
- Map<String, Object> result = new HashMap<String, Object>();
- try {
- BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
- PropertyDescriptor[] descriptors = beanInfo
- .getPropertyDescriptors();
- for (PropertyDescriptor des : descriptors) {
- String fieldName = des.getName();
- Method getter = des.getReadMethod();
- Object fieldValue = getter.invoke(bean, new Object[] {});
- if (!fieldName.equalsIgnoreCase("class")) {
- result.put(fieldName, fieldValue);
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- return result;
- }
- public static void restoreProp(Object bean, Map<String, Object> propMap) {
- try {
- BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
- PropertyDescriptor[] descriptors = beanInfo
- .getPropertyDescriptors();
- for (PropertyDescriptor des : descriptors) {
- String fieldName = des.getName();
- if (propMap.containsKey(fieldName)) {
- Method setter = des.getWriteMethod();
- setter
- .invoke(bean,
- new Object[] { propMap.get(fieldName) });
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }
- class Caretaker {
- private Map<String, Memento> memMap = new HashMap<String, Memento>();
- public Memento getMemento(String index) {
- return memMap.get(index);
- }
- public void setMemento(String index, Memento memento) {
- this.memMap.put(index, memento);
- }
- }
- public class Client {
- public static void main(String[] args) {
- Originator ori = new Originator();
- Caretaker caretaker = new Caretaker();
- ori.setState1("中国");
- ori.setState2("强盛");
- ori.setState3("繁荣");
- System.out.println("===初始化状态===\n" + ori);
- caretaker.setMemento("001", ori.createMemento());
- ori.setState1("软件");
- ori.setState2("架构");
- ori.setState3("优秀");
- System.out.println("===修改后状态===\n" + ori);
- ori.restoreMemento(caretaker.getMemento("001"));
- System.out.println("===恢复后状态===\n" + ori);
- }
- }
运行结果
===初始化状态=== state1=中国state2=强盛state3=繁荣 ===修改后状态=== state1=软件state2=架构state3=优秀 ===恢复后状态=== state1=中国state2=强盛state3=繁荣 |
参考:
http://www.cnblogs.com/itTeacher/archive/2012/12/12/2814814.html
http://www.blogjava.net/flustar/archive/2007/12/08/memento.html