备忘录模式

1 备忘录模式定义

备忘录模式(Memento Pattern):在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态.

2 备忘模式结构图

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

3 代码实现

public class Originator {

    private String state;

    public Originator(String state){
        this.state = state;
    }

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

    //根据备忘录对象恢复原发器状态
    public void restoreMemento(Memento memento){
        state = memento.getState();
    }

    public String getState() {
        return state;
    }

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

public class Memento {

    private String state;

    public Memento(Originator o){
        this.state = o.getState();
    }

    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) {
        Caretaker caretaker = new Caretaker();
        Originator originator = new Originator("1");
        System.out.println(originator.getState());
        originator.setState("2");
        System.out.println(originator.getState());
        //保存备忘录
        caretaker.setMemento(originator.createMemento());
        originator.setState("3");
        System.out.println(originator.getState());
        //撤销
        originator.restoreMemento(caretaker.getMemento());
        System.out.println(originator.getState());
    }


}

上述代码中只能存储一个状态,如果想存储多个状态,并且可以撤销重做,则可以做如下修改:

public class CaretakerList {

    private List<Memento> mementoList = new ArrayList<Memento>();


    public Memento getMemento(int i) {
        return mementoList.get(i);
    }

    public void setMemento(Memento memento) {
        mementoList.add(memento);
    }
}

public class ClientList {
    static int index = -1;
    static CaretakerList caretaker = new CaretakerList();
    public static void main(String[] args) {
        Originator originator = new Originator("1");
        System.out.println(originator.getState());
        changeState(originator,"2");
        changeState(originator,"3");
        System.out.println("=====撤销====");
        undo(originator);
        undo(originator);
        System.out.println("=====重做====");
        redo(originator);
        redo(originator);

    }

    public static void changeState(Originator originator,String state){
        originator.setState(state);
        caretaker.setMemento(originator.createMemento());//存到备忘录
        index++;
        System.out.println(originator.getState());
    }

    public static void undo(Originator originator){
        originator.restoreMemento(caretaker.getMemento(index));
        index--;
        System.out.println(originator.getState());
    }
    public static void redo(Originator originator){
        index++;
        originator.restoreMemento(caretaker.getMemento(index));
        System.out.println(originator.getState());
    }
}

4 优缺点及适用场景

主要优点:
1)它提供了一种状态恢复的实现机制,使得用户可以方便的回到一个特定的历史步骤,当新的抓鬼太无效或者存在问题时,可以适用暂时存储起来的备忘录将状态复原
2)备忘录实现了对信息的封装,一个备忘录对象是一种对原发器对象状态的表示,不会被其他代码改动.备忘录保存了原发器的状态,采用列表,堆栈等集合来存储备忘录对象可以实现多次撤销重做操作.

主要缺点:
资源消耗过大,如果需要保存的原发器类的成员变量太多,就不可避免需要占用大量的存储空间,每保存一次对象的状态都需要消耗一定的系统资源.

适用场景:
1)保存一个对象在某一个时刻的全部状态或部分状态，这样以后需要时它能够恢复到先前的状态，实现撤销操作。
2)防止外界对象破坏一个对象历史状态的封装性，避免将对象历史状态的实现细节暴露给外界对象。