备忘录模式

定义

备忘录（Memento）模式的定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。

角色

结构图：

备忘录模式的主要角色如下。

• 发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。
• 备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
• 管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

实现

发起人
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());
    }
}
备忘录
public class Memento {
    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 Memento memento;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
测试
public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        originator.setState("老的状态");
        caretaker.setMemento(originator.createMemento());//保存状态
        originator.setState("新的状态");//新的状态
        System.out.println(originator.getState());
        originator.restoreMemento(caretaker.getMemento());//恢复状态
        System.out.println(originator.getState());
    }
}

输出：

如果要保存或恢复前面好几次的操作，可以将管理类使用栈来存储。

public class Caretaker {
    private Stack<Memento> s = new Stack<>();
    public Memento getMemento() {
        return s.pop();
    }
    public void setMemento(Memento memento) {
        s.push(memento);
    }
}

优缺点

优点

• 提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史状态。
• 实现了内部状态的封装，除了创建它的发起人之外，其他对象都不能够访问这些状态信息。
• 发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。

缺点：
资源消耗过大，如果类的成员变量太多，就不可避免占用大量的内存，而且每保存一次对象的状态都需要消耗内存资源。

模式扩展

备忘录模式可以和原型模式配合使用。在备忘录模式中，通过定义“备忘录”来备份“发起人”的信息，而原型模式的 clone() 方法具有自备份功能，所以，如果让发起人实现 Cloneable 接口就有备份自己的功能，这时可以删除备忘录类，其结构图如图 4 所示。

//发起人原型
public class OriginatorPrototype implements Cloneable {
    private String state;
    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
    }
    public OriginatorPrototype createMemento() {
        return this.clone();
    }
    public void restoreMemento(OriginatorPrototype ori) {
        this.setState(ori.getState());
    }
    public OriginatorPrototype clone() {
        try {
            return (OriginatorPrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}
//管理者
public class PrototypeCaretaker {
    private Stack<OriginatorPrototype> s = new Stack<>();
    public OriginatorPrototype getMemento() {
        return s.pop();
    }
    public void setMemento(OriginatorPrototype ori) {
        s.push(ori);
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        OriginatorPrototype ori = new OriginatorPrototype();
        PrototypeCaretaker care = new PrototypeCaretaker();
        ori.setState("a");
        care.setMemento(ori.createMemento());//存储状态
        System.out.println("初始状态：" + ori.getState());
        ori.setState("b");
        care.setMemento(ori.createMemento());
        System.out.println("更新一次状态：" + ori.getState());
        ori.setState("c");
        System.out.println("更新两次状态：" + ori.getState());
        ori.restoreMemento(care.getMemento());
        System.out.println("恢复一次状态：" + ori.getState());
        ori.restoreMemento(care.getMemento());
        System.out.println("恢复两次状态：" + ori.getState());
    }
}

输出：