设计模式(十九) 备忘录模式

Memento Pattern

1. 什么是备忘录模式

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

2. 备忘录模式类角色解析

备忘录模式结构图：

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

备忘录模式的核心是备忘录以及用于管理备忘录的负责人的设计，由于在备忘录中存储的是原发器的中间状态，因此需要防止原发器以外的其他对象访问备忘录，特别是不允许其他对象来修改备忘录。

原发器类Originator，在真实业务中，原发器类是一个具体的业务类，它包含一些用于存储成员数据的属性。
备忘录中存储的是原发器的中间状态，因此需要防止原发器以外的其他对象访问备忘录，特别是不允许其他对象来修改备忘录，它通常提供了与原发器相对应的属性（可以是全部，也可以是部分）用于存储原发器的状态。

##3. 备忘录模式优缺点
优点：

• 它提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原。
• 备忘录实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码所改动。备忘录保存了原发器的状态，采用列表、堆栈等集合来存储备忘录对象可以实现多次撤销操作。

缺点：

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

适用场景：

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

4. 实操感想

备忘录模式用备忘录类(Memento)来保存Originator的状态，存储的属性可以是全部也可以是部分Originator的属性。这样的好处是意义清晰，Memento是Originator的历史状态，被Caretaker存储的集合中，用于恢复状态。

使用该模式时，调用者可以操作Originator，这个是业务类；也可以操作Caretaker，用于查询历史状态，用于恢复；不可以操作Memento，因为历史状态是唯一的。

5. 代码示例

// Originator，原发器类
class Chessman {
    private String label;
    private int x;
    private int y;

    Chessman(String label, int x, int y) {
        this.label = label;
        this.x = x;
        this.y = y;
    }

    //保存状态
    ChessmanMemento save() {
        return new ChessmanMemento(this.label, this.x, this.y);
    }

    //恢复状态
    void restore(ChessmanMemento memento) {
        this.label = memento.getLabel();
        this.x = memento.getX();
        this.y = memento.getY();
    }
}

// 备忘录类，存储历史状态
class ChessmanMemento {
    private final String label;
    private final int x;
    private final int y;

    ChessmanMemento(String label, int x, int y) {
        this.label = label;
        this.x = x;
        this.y = y;
    }
}

// 负责人，简陋的写法，应该封装
class MementoCaretaker {
    //定义一个集合来存储多个备忘录，可以是栈等
    private ArrayList<ChessmanMemento> mMementoList = new ArrayList<>();

    ChessmanMemento getMemento(int i) {
        return mMementoList.get(i);
    }

    void setMemento(ChessmanMemento memento) {
        mMementoList.add(memento);
    }
}

// test

    private static MementoCaretaker mc = new MementoCaretaker();

    // 针对该例子，这些操作使用门面模式可以封装在同一个类中，不用调方法
    public static void main(String args[]) {
        Chessman chess = new Chessman("车", 1, 1);
        play(chess);
        chess.setY(4);
        play(chess);
        chess.setX(5);
        play(chess);
        undo(chess);
        undo(chess);
        redo(chess);
        redo(chess);
    }

    //下棋
    private static void play(Chessman chess) {
        mc.save(chess.save()); //保存备忘录
        System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");
    }

    //悔棋
    private static void undo(Chessman chess) {
        System.out.println("******悔棋******");
        chess.restore(mc.undo()); //撤销到上一个备忘录
        System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");
    }

    //撤销悔棋
    private static void redo(Chessman chess) {
        System.out.println("******撤销悔棋******");
        chess.restore(mc.redo()); //恢复到下一个备忘录
        System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");
    }