备忘录模式(Memento Pattern)

保存对象状态

1.基本介绍

为了使软件的使用更加人性化，对于误操作，我们需要提供一种类似“后悔药”的机制，让软件系统可以回到误操作前的状态，因此需要保存用户每一次操作时系统的状态，一旦出现误操作，可以把存储的历史状态取出即可回到之前的状态。

在应用软件的开发过程中，很多时候我们都需要记录一个对象的内部状态。

在具体实现过程中，为了允许用户取消不确定的操作或从错误中恢复过来，需要实现备份点和撤销机制，而要实现这些机制，必须事先将状态信息保存在某处，这样才能将对象恢复到它们原先的状态。

备忘录模式是一种给我们的软件提供后悔药的机制，通过它可以使系统恢复到某一特定的历史状态。

模式定义:

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

---

2.具体实现

Memento类

/**
 * @author Jay
 * @date 2019/7/6 18:41
 * @description 备忘录类
 */
public class Memento {
    /**
     * 所持金钱
     */
    private int money;
    /**
     * 获得的水果
     */
    private List<String> fruits;

    /**
     * 获取当前所持金钱
     *
     * @return 所持金钱
     */
    public int getMoney() {
        return money;
    }

    /**
     * 构造方法，初始化所持钱数
     *
     * @param money 初始化钱数
     */
    Memento(int money) {
        this.money = money;
        this.fruits = new ArrayList<>();
    }

    /**
     * 添加水果
     *
     * @param fruit 水果
     */
    void addFruit(String fruit) {
        fruits.add(fruit);
    }

    /**
     * 添加当前所持的所有水果
     *
     * @return 水果列表
     */
    List<String> getFruits() {
        return fruits;
    }
}

Gamer类

/**
 * @author Jay
 * @date 2019/7/6 18:47
 * @description
 */
public class Gamer {
    /**
     * 所持金钱
     */
    private int money;
    /**
     * 获得的水果
     */
    private List<String> fruits = new ArrayList<>();
    /**
     * 随机数生成器
     */
    private Random random = new Random();
    /**
     * 表示水果种类的数组
     */
    private static String[] fruitsname = {"苹果", "葡萄", "香蕉", "橘子"};

    /**
     * 构造方法，初始化金钱数
     *
     * @param money 金钱数
     */
    public Gamer(int money) {
        this.money = money;
    }

    /**
     * 获取当前所持金钱数
     *
     * @return 金钱数
     */
    public int getMoney() {
        return money;
    }

    /**
     * 投掷骰子进行游戏
     */
    public void bet() {
        // 获取骰子数值
        int dice = random.nextInt(6) + 1;
        if (dice == 1) {
            this.money += 100;
            System.out.println("所持金钱增加了。");
        } else if (dice == 2) {
            this.money /= 2;
            System.out.println("所持金钱减半了。");
        } else if (dice == 6) {
            String f = this.getFruit();
            System.out.println("获得了水果(" + f + ")。");
            this.fruits.add(f);
        } else {
            System.out.println("什么都没有发生。");
        }
    }

    /**
     * 创建备忘录
     *
     * @return 备忘录对象
     */
    public Memento createMemento() {
        Memento m = new Memento(money);
        Iterator<String> it = fruits.iterator();
        while (it.hasNext()) {
            String fruit = it.next();
            if (fruit.startsWith("好吃的")) {
                m.addFruit(fruit);
            }
        }
        return m;
    }

    /**
     * 撤销到指定备忘
     *
     * @param memento 备忘录对象
     */
    public void restoreMemento(Memento memento) {
        this.money = memento.getMoney();
        this.fruits = memento.getFruits();
    }

    /**
     * 获得一个水果
     *
     * @return 水果
     */
    private String getFruit() {
        String prefix = "";
        if (random.nextBoolean()) {
            prefix = "好吃的";
        }
        return prefix + fruitsname[random.nextInt(fruitsname.length)];
    }

    @Override
    public String toString() {
        return "Gamer{ money=" + money + ", fruits=" + fruits + '}';
    }
}

测试类

/**
 * @author Jay
 * @date 2019/7/6 18:48
 * @description
 */
public class MementoTest {
    /**
     * 测试备忘录模式
     */
    @Test
    public void testMemento() {
        Gamer gamer = new Gamer(100);
        Memento memento = gamer.createMemento();
        for (int i = 0; i < 5; i++) {
            System.out.println("==== " + i);
            System.out.println("当前状态：" + gamer);
            // 投掷骰子
            gamer.bet();

            System.out.println("所持金钱为" + gamer.getMoney() + "元。");
            // 如何处理memento
            if (gamer.getMoney() > memento.getMoney()) {
                System.out.println("    （所持金钱增加了许多，因此保存游戏当前的状态）");
                memento = gamer.createMemento();
            } else if (gamer.getMoney() < memento.getMoney() / 2) {
                System.out.println("    （所持金钱减少了许多，因此将游戏恢复至以前的状态）");
                gamer.restoreMemento(memento);
            }

            // 等待一段时间
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            System.out.println("");
        }
    }
}

---

3.模式中的角色

Originator(生成者)

Originator角色会在保存自己的最新状态时生成Memento角色。当把以前保存的Memento角色传递给Originator角色时，它会将自己恢复至生成该Memento角色时的状态。在案例中，由Gamer类扮演此角色。

Memento(纪念品)

Memento角色会将Originator角色的内部信息整合在一起。在Memento角色中虽然保存了Originator角色的信息，但它不会向外部公开这些信息。

Memento角色有以下两种接口（API）：

wide interface——宽接口（API）

Memento角色提供的“宽接口（API）”是指所有用于获取恢复对象状态信息的方法的集合。由于宽接口（API）会暴露所有Memento角色的内部信息，因此能够使用宽接口（API）的只有Originator角色。

narrow interface——窄接口（API）：

Memento角色为外部的Caretaker角色提供了“窄接口（API）” 。可以通过窄接口（API）获取的Memento角色的内部信息、非常有限，因此可以有效地防止信息泄露。
通过对外提供以上两种接口（API），可以有效地防止对象的封装性被破坏。

Originator角色和Memento角色之间有着非常紧密的联系。

Caretaker(负责人)

当Caretaker角色想要保存当前的Originator角色的状态时，会通知Originator角色。Originator角色在接收到通知后会生成Memento角色的实例并将其返回给Caretaker角色。由于以后可能会用Memento实例来将Originator 恢复至原来的状态，因此Caretaker角色会一直保存Memento实例。在案例中，由测试类扮演此角色。

不过，Caretaker角色只能使用Memento角色两种接口（API）中的窄接口（API），也就是说它无法访问Memento 角色内部的所有信息。它只是将Originator角色生成的Memento角色当作一个黑盒子保存起来。 (黑盒模式)

虽然Originator角色和Memento角色之间是强关联关系，但Caretaker角色和Memento角色之间是弱关联关系。Memento角色对Caretaker角色隐藏了自身的内部信息。

---

To GitHub