设计模式之备忘录模式

基本介绍

在我们平时玩游戏，下棋的时候都有一个存档的功能。我们可以利用存档，恢复到之前的某个状态。
备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。

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

案例

我们可以使用下棋这个场景，来模拟备忘录模式。
在下棋的过程中，我们可以进行悔棋，也可撤销悔棋。
在这里发起人就是棋子本身，备忘录角色就是用来记录棋子的位置信息，管理者用来管理下棋产生的备忘录。

棋子类(发起人)、棋子备忘录

/**
 * 棋子类，发起人
 */
class Chessman {

    private String label;
    private int x;
    private int y;

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

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

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

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    //棋子备忘录，用于记录棋子状态
    class ChessmanMemento {

        private String label;
        private int x;
        private int y;

        public String getLabel() {
            return label;
        }

        public void setLabel(String label) {
            this.label = label;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }

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

管理端

import java.util.Stack;

/**
 * 管理端
 */
public class MementoCaretaker {

    private Stack<Chessman.ChessmanMemento> mementos;
    private int index;

    public MementoCaretaker() {
        index = -1;
        mementos = new Stack<>();
    }

    public Chessman.ChessmanMemento undo() {
        if (index >= 0) {
            index--;
        } else {
            index = 0;
        }
        return mementos.get(index);
    }

    public void save(Chessman.ChessmanMemento memento) {
        while (mementos.size() > index + 1) {
            mementos.pop();
        }
        mementos.push(memento);
        index++;
    }

    public Chessman.ChessmanMemento redo() {
        if (index + 1 < mementos.size()) {
            index++;
        } else {
            index = mementos.size() - 1;
        }
        return mementos.get(index);
    }
}

客户端

public class Client {

    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);
        redo(chess);
        undo(chess);
        chess.setX(10);
        chess.setY(10);
        play(chess);

        undo(chess);
    }

    private static void play(Chessman chess) {
        System.out.println("******下棋******");
        mc.save(chess.save()); //保存状态
        display(chess);
    }

    private static void undo(Chessman chess) {
        System.out.println("******悔棋******");
        chess.restore(mc.undo()); //恢复状态
        display(chess);
    }

    private static void redo(Chessman chess) {
        System.out.println("******撤销悔棋******");
        chess.restore(mc.redo()); //恢复状态
        display(chess);
    }

    private static void display(Chessman chess) {
        System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");
    }
}

运行结果

******下棋******
棋子车当前位置为：第1行第1列。
******下棋******
棋子车当前位置为：第1行第4列。
******下棋******
棋子车当前位置为：第5行第4列。
******悔棋******
棋子车当前位置为：第1行第4列。
******撤销悔棋******
棋子车当前位置为：第5行第4列。
******悔棋******
棋子车当前位置为：第1行第4列。
******下棋******
棋子车当前位置为：第10行第10列。
******悔棋******
棋子车当前位置为：第1行第4列。

优缺点

优点：

• 提供状态恢复。对象恢复到特定的历史步骤。 封装信息。
• 备忘录保存了原发器的状态，并且只有原发器可以改动。

缺点：

• 资源消耗大。特别是保存的原发器类的对象较多时，需要占据内存，保存操作也需要开销。

适用范围：

• 需要实现撤销操作。
• 需要封装对象的历史状态，并且避免暴露给其他对象。