备忘录模式——Memento

案例展示——Memento怎么用？

 在电影中，月光宝盒是一种可以穿越时空的宝物，持有月关宝盒的人可以去到任意的时间，也可以迅速的回到原来的时间。当然，在现实中，起码在现在的科技水平下，人类的科技是无法做到时空穿梭的程度的，但是作为程序员，我们却可以通过编程来体验这种任意穿梭时间的乐趣，下面是设计类图：

类图元素分析如下：

• TimeMachine：这就是前面说的月关宝盒类了，这个类会显示当前月关宝盒所在的年代，同时可以创建一个备份保存这个年代，以便以后可以返回

• Memento：备忘录类，这是一个Javabean，就是单纯的为TimeMachine保存一个年代信息

• Caretaker：备忘录的管理类，通过这个类去管理备忘录类，高层模块不必要直接和备忘录接触，降低耦合

下面是代码实现：

// 时间机器——月关宝盒
public class TimeMachine {
    // 年代
    private String time = "";
    // 改变年代
    public void changeTime() {
        this.time = "公元1970-1-1 00:00:00，我是月光宝盒，今天是我的生日！";
    }
    public void setTime(String time) {
        this.time = time;
    }
    public String getTime() {
        return time;
    }
    // 保留一个备份
    public Memento createMemento() {
        return new Memento(this.time);
    }
    // 恢复一个备份
    public void restoreMemento(Memento memento) {
        this.setTime(memento.getTime());
    }
}

// 备忘录类
public class Memento {
    // 年代
    private String time = "";
    // 通过构造函数来传递年代
    public Memento(String time) {
        this.time = time;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
}

// 备忘录管理员
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(String[] args) {
        // 准备时间机器——“月光宝盒”
        TimeMachine tm = new TimeMachine();
        // 准备一个备忘录管理者
        Caretaker caretaker = new Caretaker();
        // 初始化时间机器
        tm.setTime("公元前221年，秦始皇一统天下！");
        System.out.println("==========月光宝盒当前时间===========");
        System.out.println(tm.getTime());
        // 使用备忘录记录一下
        caretaker.setMemento(tm.createMemento());
        // 改变一下年代
        tm.changeTime();
        System.out.println("==========月光宝盒修改后时间===========");
        System.out.println(tm.getTime());
        // 回到原始的那个年代
        tm.restoreMemento(caretaker.getMemento());
        System.out.println("==========月光宝盒恢复后时间===========");
        System.out.println(tm.getTime());
    }
}

结果如下：
公元前221年，秦始皇一统天下！
==========月光宝盒修改后时间===========
公元1970-1-1 00:00:00，我是月光宝盒，今天是我的生日！
==========月光宝盒恢复后时间===========
公元前221年，秦始皇一统天下！

 看见结果是不是很神奇，我们可以任意的穿梭时空啦，想到哪里就去哪里，但是最重要的就是在去之前要备份一下，以免到时候回不来。在这个设计中我们就用到了备忘录模式。

深入分析——Memento是什么？

Memento的定义

定义： 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将该对象恢复到原先保存的状态。下面其通用类图：

类图元素分析：

• Originator发起人角色：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据

• Memento备忘录角色：负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态

• Caretaker备忘录管理员角色：对备忘录进行管理、保存和提供备忘录

Memento的几种扩展形式

1. clone方式的备忘录

通过复制的方式产生一个内部对象，这是一种简单好用的方法，其类图如下：

代码实现如下：

// 发起人自主备份和恢复
public class Originator implements Cloneable {
    // 当前发起人的备份
    private Originator backup;

    // 内部状态
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    // 创建一个备忘录
    public void createMemento() {
        this.backup = (Originator) this.clone();
    }

    // 恢复一个备忘录
    public void restoreMemento() {
        // 断言备忘录不为空
        Assert.assertNotNull(backup);
        this.setState(this.backup.getState());
    }

    // 克隆当前对象
    @Override
    protected Object clone(){
        try {
            return (Originator) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

// 在一个场景中运行
public class Client {
    public static void main(String[] args) {
        // 定义发起人
        Originator originator = new Originator();
        // 建立初始状态
        originator.setState("初始状态....");
        System.out.println("初始状态是：" + originator.getState());
        // 建立备份
        originator.createMemento();
        // 修改状态
        originator.setState("修改后的状态...");
        System.out.println("修改后的状态是：" + originator.getState());
        // 恢复原有状态
        originator.restoreMemento();
        System.out.println("恢复后的状态是：" + originator.getState());
    }
}

结果如下：
初始状态是：初始状态....
修改后的状态是：修改后的状态...
恢复后的状态是：初始状态....

 我们发现结果没有变化，完美的实现了我们的需求，同时程序更加精简。但是由于深拷贝和浅拷贝存在的问题，在复杂场景下会让程序的逻辑变得很复杂，所以基于克隆的备忘录模式适用于较为简单的场景，不要与其他的对象产生严重的耦合关系。

2. 多状态的备忘录模式

 在前面介绍的案例中，发起人角色Originator只有一个状态，我们只需要备份一个状态就可以，那要是在复杂场景中出现了多个状态值需要备份怎么办呢？这时我们可以使用前面的介绍的通过克隆的备忘录模式，也可以使用下面介绍的方法。类图设计如下：

分析：将多个状态值按照键值对(属性-属性值)的形式存放在HashMap中，通过一个工具类BeanUtils来获取属性值或者设置属性值

下面是代码实现：

// 发起人角色：有多个状态
public 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());
    }

    @Override
    public String toString() {
        return "Originator{" +
                "state1='" + state1 + '\'' +
                ", state2='" + state2 + '\'' +
                ", state3='" + state3 + '\'' +
                '}';
    }
}

// 备忘录类
public class Memento {
    // 状态值存放在一个HashMap中
    private HashMap<String, Object> stateMap;
    // 接收一个对象，建立一个备份
    public Memento(HashMap<String, Object> map) {
        this.stateMap = map;
    }

    public HashMap<String, Object> getStateMap() {
        return stateMap;
    }

    public void setStateMap(HashMap<String, Object> stateMap) {
        this.stateMap = stateMap;
    }
}

// 备忘录管理员类
public class Caretaker {
    // 备忘录对象
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

// 工具类
public class BeanUtils {
    // 把bean的所有属性和数值放到HashMap中：使用反射获取
    public static HashMap<String, Object> backupProp(Object bean) {
        HashMap<String, Object> result = new HashMap<String, Object>(16);
        try {
            // 获得bean的描述
            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;
    }

    // 把HashMap的值返回到bean中
    public static void restoreProp(Object bean, HashMap<String, Object> propMap) {
        try {
            // 获得bean的描述
            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();
        }
    }
}

//在一个场景中测试
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(ori.createMemento());
        // 修改状态值
        ori.setState1("蔬菜");
        ori.setState2("水果");
        ori.setState3("海鲜");
        System.out.println("\n=======修改后状态======\n" + ori);
        // 恢复备忘录中保存的状态
        ori.restoreMemento(caretaker.getMemento());
        System.out.println("\n=======恢复后状态======\n" + ori);
    }
}

结果如下：
=======初始化状态=====
Originator{state1='篮球', state2='足球', state3='乒乓球'}

=======修改后状态======
Originator{state1='蔬菜', state2='水果', state3='海鲜'}

=======恢复后状态======
Originator{state1='篮球', state2='足球', state3='乒乓球'}

3. 多备份的备忘录

 备忘录也可以有多个，我们可以建立多个备份，然后选择回到哪个备份。其实这样的场景会有很多，比如视频监控，我们想回到某某时间段，那这个备份的必须是连续的，每一个时间点就是一个备份点，通过这个备份点我们就能回到那个状态，下面是代码实现(只给出修改部分)：

// 备忘录管理员：通过HashMap来存放多个备忘录——(备份点索引, 备忘录对象)
public class Caretaker {
    // 使用HashMap来存放多个备忘录
    private HashMap<String, Memento> memMap = new HashMap<String, Memento>(16);
    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 originator = new Originator();
        // 定义出备忘录管理员
        Caretaker caretaker = new Caretaker();
        // 创建多个备忘录
        caretaker.setMemento("001", originator.createMemento());
        caretaker.setMemento("002", originator.createMemento());
        // 恢复指定标记的备忘录
        originator.restoreMemento(caretaker.getMemento("001"));
    }
}

4. 更加安全的备忘录

 备忘录的数据一般来说是不允许修改的，这就要求我们将其保护的更好，纵观我们前面的设计，备忘录暴露在外，任何人都可以对其进行修改。这样设计是很不安全的，所以可以将备忘录的阅读权限缩小，比如作为发起人的一个私有内部类，外部的话就声明一个没有任何方法的备忘录接口，其他一切对备忘录的访问都通过这个接口进行，只允许使用，不允许修改，这样就会安全的多(当然无法防止通过反射去修改)，下面是类图设计：

下面是代码实现：

// 备忘录接口
public interface IMemento {

}

// 发起人角色
public class Originator {
    // 状态
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    // 创建一个备忘录
    public Memento createMemento() {
        return new Memento(this.state);
    }

    // 恢复一个备忘录
    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }

    // 内部类
    private class Memento implements IMemento {
        // 发起人的内部状态
        private String state = "";
        // 构造函数进行参数传递
        public Memento(String state) {
            this.state = state;
        }

        public String getState() {
            return state;
        }

        public void setState(String state) {
            this.state = state;
        }
    }
}

// 备忘录管理员
public class Caretaker {
    // 备忘录对象
    private IMemento memento;
    public IMemento getMemento() {
        return memento;
    }
    public void setMemento(IMemento memento) {
        this.memento = memento;
    }
}

 在上面的例子中使用了双接口设计：一个类可以实现多个接口，如果考虑对象安全问题，可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外一个是空接口，没有任何方法，其目的是提供给子系统的外部模块访问，比如容器对象，这个叫做窄接口。由于窄接口中没有提供任何操作数据的方法，因此相对比较安全。

Memento的使用场景

• 需要保存和恢复数据的相关状态场景

• 提供回滚操作：如数据库中事物提交失败后的回滚操作就是使用了备忘录模式

• 需要对一个对象进行监控的场景

Memento的注意事项

• 备忘录的生命周期：备忘录创建出来要在“最近”的代码中使用，要主动管理它的生命周期，建立了就要使用它，不使用了就删除它的引用，等待垃圾回收期对其进行回收

• 备忘录的性能：不要在频繁建立备份的场景中使用备忘录模式(比如for循环)，原因如下

  • 控制不了备忘录建立的对象数量
  • 大对象的建立需要耗费很大的资源

参考

《设计模式之禅》