设计模式系列 - 备忘录模式

介绍&定义

备忘录模式，也叫快照（Snapshot）模式，英文翻译是 Memento Design Pattern。在 GoF 的《设计模式》一书中，备忘录模式是这么定义的：

Captures and externalizes an object’s internal state so that it can be restored later, all without violating encapsulation.

翻译成中文就是：在不违背封装原则的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便之后恢复对象为先前的状态。

这个模式的定义主要表达了两部分内容。

1. 一部分是，存储副本以便后期恢复。这一部分很好理解。
2. 另一部分是，要在不违背封装原则的前提下，进行对象的备份和恢复。这部分不太好理解。

结构

**Originator（原发器）：**它是一个需要保存状态的类，可以创建一个备忘录/备份，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态。

**Memento（备忘录)：**存储原发器的内部状态。除了原发器类，备忘录类不能被其他类创建和修改。一般通过将Memento类与Originator类定义在同一个包中来实现封装（也可以作为内部类），使用默认访问标识符来定义Memento类，即保证其包内可见。

**Caretaker（负责人）：**负责人又称为管理者，它负责保存备忘录。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象（负责任类只提供备忘录对象的读写接口，不提供备忘录属性的读写接口），也无须知道对象的实现细节。负责人对象可以保存一个备忘录数组，从而实现原发器的多次撤销。

实际案例

实现一个 文本编辑器

:ls 查看文本内容

:undo 回退一步

package com.beauty.designpatterns.behavior;

import java.util.Scanner;
import java.util.Stack;

/**
 * description 备忘录模式
 *
 * @author yufengwen
 * @date 2023/2/20 19:18
 */
public class MemoPattern {

    public static void main(String[] args) {

        Text text = new Text();

        BackupHolder snapshotsHolder = new BackupHolder();

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {

            String input = scanner.next();

            if (input.equals(":ls")) {

                System.out.println(text.toString());

            } else if (input.equals(":undo")) {

                Backup backup = snapshotsHolder.popBackup();

                text.undo(backup);

            } else {

                snapshotsHolder.pushBackup(text.backup());

                text.append(input);

            }

        }

    }
}

class Text {

    private final StringBuilder text = new StringBuilder();

    public String getText() {

        return text.toString();

    }

    public void append(String input) {

        text.append(input).append("|");

    }

    public Backup backup() {

        return new Backup(text.toString());

    }

    public void undo(Backup backup) {

        this.text.replace(0, this.text.length(), backup.getText());

    }

    @Override
    public String toString() {
        return text.toString();
    }
}

class Backup {

    private final String text;

    public Backup(String text) {

        this.text = text;

    }

    public String getText() {

        return this.text;

    }

}

class BackupHolder {

    private final Stack<Backup> backups = new Stack<>();

    public Backup popBackup() {

        return backups.pop();

    }

    public void pushBackup(Backup backup) {

        backups.push(backup);

    }

}

jfaj
slkfja
:ls
jfaj|slkfja|
:undo
ls
sif
:ls
jfaj|ls|sif|
:undo
:ls
jfaj|ls|

如何优化内存和时间消耗？

前面我们只是简单介绍了备忘录模式的原理和经典实现，现在我们再继续深挖一下。如果要备份的对象数据比较大，备份频率又比较高，那快照占用的内存会比较大，备份和恢复的耗时会比较长。这个问题该如何解决呢？

不同的应用场景下有不同的解决方法。比如，我们前面举的那个例子，应用场景是利用备忘录来实现撤销操作，而且仅仅支持顺序撤销，也就是说，每次操作只能撤销上一次的输入，不能跳过上次输入撤销之前的输入。在具有这样特点的应用场景下，为了节省内存，我们不需要在快照中存储完整的文本，只需要记录少许信息，比如在获取快照当下的文本长度，用这个值结合对象存储的文本来做撤销操作。

我们再举一个例子。假设每当有数据改动，我们都需要生成一个备份，以备之后恢复。如果需要备份的数据很大，这样高频率的备份，不管是对存储（内存或者硬盘）的消耗，还是对时间的消耗，都可能是无法接受的。想要解决这个问题，我们一般会采用“低频率全量备份”和“高频率增量备份”相结合的方法。

全量备份就不用讲了，它跟我们上面的例子类似，就是把所有的数据“拍个快照”保存下来。所谓“增量备份”，指的是记录每次操作或数据变动。

当我们需要恢复到某一时间点的备份的时候，如果这一时间点有做全量备份，我们直接拿来恢复就可以了。如果这一时间点没有对应的全量备份，我们就先找到最近的一次全量备份，然后用它来恢复，之后执行此次全量备份跟这一时间点之间的所有增量备份，也就是对应的操作或者数据变动。这样就能减少全量备份的数量和频率，减少对时间、内存的消耗。