设计模式(18)——备忘录模式

来源：互联网发布：c语言开发实战宝典编辑：程序博客网时间：2024/05/17 03:33

备忘录模式

一、模式定义

在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存前的状态。

备忘录模式又叫做快照模式(Snapshot Pattern)或Token模式，属于行为模式。

二、结构

组成部分：

发起人(Originator):负责创建一个备忘录Memento,用以记录当前时刻自身的内部状态，并可使用备忘录恢复内部状态。发起人可以根据需要觉得备忘录存储自己的哪些内部状态。
备忘录(Memento):负责存储发起人对象的内部状态，并可以防止发起人以外的其他对象访问备忘录。备忘录有两个接口：管理者只能看到备忘录的窄接口，他只能将备忘录传递给其他对象。发起人却可以看到备忘录的宽接口，允许它访问返回到先前状态所需要的所有数据。
管理者(Caretaker):负责备忘录，不能对备忘录的内容进行访问或者操作。

三、例子---游戏进度保存

实例：以保存游戏进度为例，在游戏角色大战Boss前将该角色的状态存储，与Boss作战后角色的各项能力会下降，如果没有通关，则可利用备忘录进行恢复到战前状态。

Memento

[java] view plaincopyprint?
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;  
    }  
}  

发起人可以看到备忘录的宽接口，允许它访问返回到先前状态所需要的所有数据。

[java] view plaincopyprint?
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);  
    }  
}  

管理者 只能看到备忘录的窄接口，他只能将备忘录传递给其他对象

[java] view plaincopyprint?
public class Caretaker {  
    private Memento memento;  
  
    public Memento getMemento() {  
        return memento;  
    }  
  
    public void setMemento( Memento memento) {  
        this.memento = memento;  
    }  
}  

场景类

[java] view plaincopyprint?
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容器才存储所有的备份。下面我们给出一个多状态多备份的例子：

[java] view plaincopyprint?
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);  
    }  
}  