Java核心篇，二十三种设计模式（十八），行为型——备忘录模式

一、概念

在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为Token

二、角色组成

Originator（原发器）：需要被数据备份，保存状态的对象；它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器
Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用
Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。备份的数据会有多份，因此需要有一个类来管理这些备份

三、适用场景

必须保存一个对象在某一个时刻的(部分)状态,这样以后需要时它才能恢复到先前的状态。
如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

四、角色关系

五、代码实现

Memento

package com.behaviour.memo.Memento;

import java.io.*;
import java.util.HashMap;

/**
 * Memento（备忘录)
 * 存储原发器的内部状态；是待保存数据模块的原子模型
 */
public class Memento implements Serializable {

    private HashMap<String, Object> states;

    public Memento(HashMap<String, Object> states) {
        this.states = states;
    }

    public HashMap<String, Object> getStates() {
        return this.states;
    }

    // 深度克隆
    public Memento deepClone(){

        Memento memento = null;

        try {

            ByteArrayOutputStream ous = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(ous);
            oos.writeObject(this);

            //把字节流转化为对象
            ByteArrayInputStream ais = new ByteArrayInputStream(ous.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ais);

            memento = (Memento) ois.readObject();

            // 关闭文件流
            oos.close();
            ois.close();

        }catch (Exception e){
            e.printStackTrace();
        }

        return memento;
    }
}

Originator

package com.behaviour.memo.Originator;

import com.behaviour.memo.Memento.Memento;
import java.util.HashMap;

/**
 * originator : 需要保存状态的对象
 * 即原数据对象
 */
public class Originator {

    // 待保存的所有内容
    private HashMap<String, Object> states;

    public HashMap<String, Object> getStates() {
        return this.states;
    }

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

    //保存一个状态对象 Memento
    public Memento createMemento(){
        return new Memento(this.states);
    }

    //通过备忘录对象，恢复状态
    public void restoreMemento(Memento memento){
        this.setStates(memento.getStates());
    }
}

Caretaker

package com.behaviour.memo.Caretaker;

import com.behaviour.memo.Memento.Memento;
import java.util.ArrayList;
import java.util.List;

/**
 * Caretaker: 守护者对象
 * 负责保存多个备忘录对象
 */
public class Caretaker {

    private List<Memento> mementos;

    public Caretaker(){
        this.mementos = new ArrayList<>();
    }

    // 新增备忘录对象
    public void add(Memento memento){
        // 如果不加判断的新增这个对象，由于逻辑失误，可能会导致新增的对象有可能与之前已存在的对象是同一个对象
        // 这种情况的下会导致 Caretaker 存储的所有 Memento 对象均为同一个重复对象
        // 所以这里毫不犹豫的采取了深度复制的方法
        this.mementos.add(memento.deepClone());
    }

    //获取到第 index 个 Originator 的 备忘录对象(即保存状态)
    public Memento get(int index) {
        return mementos.get(index);
    }

}

Test

package com.behaviour.memo;

import com.behaviour.memo.Caretaker.Caretaker;
import com.behaviour.memo.Originator.Originator;
import java.util.HashMap;

public class Test {

    public static void main(String[] args) {

        Originator data = new Originator();
        Caretaker leader = new Caretaker();
        HashMap<String, Object> states = new HashMap<>();

        states.put("name", "夏利");
        states.put("age", 20);
        data.setStates(states);
        leader.add(data.createMemento());
        System.out.println("当前的状态是 " + data.getStates());

        states.put("name", "刘星");
        states.put("age", 18);
        data.setStates(states);
        leader.add(data.createMemento());
        System.out.println("当前的状态是 " + data.getStates());

        states.put("name", "夏雨");
        states.put("age", 12);
        data.setStates(states);
        leader.add(data.createMemento());
        System.out.println("当前的状态是 " + data.getStates());

        data.restoreMemento(leader.get(1));
        System.out.println("当前的状态是 " + data.getStates());
    }
}