设计模式（十九）行为型：备忘录模式详解

设计模式（十九）行为型：备忘录模式详解

备忘录模式（Memento Pattern）是 GoF 23 种设计模式中的行为型模式之一，其核心价值在于在不破坏封装性的前提下，捕获并外部化一个对象的内部状态，以便在之后能够将该对象恢复到原先保存的状态。它通过引入“备忘录”对象来存储原发器（Originator）的快照，由管理者（Caretaker）负责保存和管理这些快照，从而实现状态的保存与恢复。备忘录模式是实现撤销（Undo）、重做（Redo）、事务回滚、游戏存档、对象版本控制、配置快照等关键功能的基础，是构建具备“时间旅行”能力、高容错性和用户友好性的系统的必备设计模式。

一、详细介绍

备忘录模式解决的是“需要保存对象在某一时刻的状态，并在需要时恢复该状态，但又不能暴露对象的内部实现细节”的问题。在传统设计中，若要实现撤销功能，可能会让对象提供 getState() 和 setState() 方法，但这会破坏对象的封装性，暴露其内部结构，导致耦合度高、安全性差。

备忘录模式的核心思想是：将状态的保存与恢复过程封装在三个角色中，通过“窄接口”与“宽接口”的设计，既保证了封装性，又实现了状态管理。

该模式包含以下核心角色：

• Originator（原发器）：创建一个备忘录来记录当前内部状态，并可在需要时根据备忘录恢复状态。它负责定义如何保存和恢复自身状态。
• Memento（备忘录）：存储原发器的内部状态。备忘录对象的接口设计是关键：
  • 窄接口（Narrow Interface）：对外（管理者）只暴露最小必要接口，通常无任何方法（或仅用于标识），防止管理者修改状态。
  • 宽接口（Wide Interface）：对原发器暴露完整状态访问权限，允许原发器读取状态以恢复自身。
    在 Java 中，通常通过内部类或包级私有类实现，利用访问控制机制实现接口隔离。
• Caretaker（管理者）：负责保存和管理备忘录对象，但不能对备忘录的内容进行任何操作或检查。它只是“保管”备忘录，并在需要时将其交还给原发器。

备忘录模式的关键优势：

• 保持封装性：原发器的内部状态通过备忘录安全地外部化，管理者无法访问或修改。
• 支持撤销/重做：通过保存多个备忘录（如栈结构），可实现多级撤销与重做。
• 实现事务回滚：在操作失败时，可恢复到操作前的状态。
• 支持版本控制：可保存对象的历史状态快照。
• 解耦状态管理：状态的保存与恢复逻辑由原发器控制，管理者仅负责存储。

与“命令模式”相比，命令封装操作，备忘录封装状态；命令常与备忘录结合实现撤销功能（命令执行前保存状态）。与“观察者模式”相比，观察者关注状态变化的通知，备忘录关注状态的保存与恢复。

备忘录模式适用于：

• 需要实现撤销/重做功能（如文本编辑器、图形编辑器）。
• 需要事务性操作或回滚机制。
• 需要保存游戏进度或配置快照。
• 需要对象状态的历史版本管理。

二、备忘录模式的UML表示

以下是备忘录模式的标准 UML 类图：

图解说明：

• Originator 创建 Memento 保存状态，并可从 Memento 恢复状态。
• Memento 存储 Originator 的状态。
• Caretaker 保存 Memento 对象，但无法访问其内容。
• 实际实现中，Memento 的 getState() 方法通常设为 private 或包私有，仅 Originator 可访问（通过内部类或友元机制）。

三、一个简单的Java程序实例及其UML图

以下是一个文本编辑器的示例，支持保存当前文本状态并撤销到之前的状态。

Java 程序实例

import java.util.ArrayList;
import java.util.List;

// 备忘录类：存储编辑器状态
// 使用包级私有类实现接口隔离
class EditorMemento {
    private final String content;
    private final long timestamp;

    // 包级私有构造函数，仅 Originator 可创建
    EditorMemento(String content) {
        this.content = content;
        this.timestamp = System.currentTimeMillis();
    }

    // 包级私有方法，仅 Originator 可读取状态
    String getContent() {
        return content;
    }

    long getTimestamp() {
        return timestamp;
    }

    @Override
    public String toString() {
        return "Memento@" + timestamp + "[content='" + content + "']";
    }
}

// 原发器：文本编辑器
class TextEditor {
    private String content = "";

    public void type(String text) {
        this.content += text;
        System.out.println("📝 输入: \"" + text + "\"");
        System.out.println("📄 当前内容: \"" + content + "\"");
    }

    public String getContent() {
        return content;
    }

    // 创建备忘录（保存当前状态）
    public EditorMemento save() {
        System.out.println("💾 保存当前状态到备忘录");
        return new EditorMemento(content);
    }

    // 从备忘录恢复状态
    public void restore(EditorMemento memento) {
        this.content = memento.getContent();
        System.out.println("⏪ 恢复到备忘录状态: " + memento);
        System.out.println("📄 恢复后内容: \"" + content + "\"");
    }
}

// 管理者：历史记录
class History {
    private List<EditorMemento> mementos = new ArrayList<>();

    // 保存备忘录
    public void push(EditorMemento memento) {
        mementos.add(memento);
        System.out.println("📦 管理者保存备忘录，历史记录数量: " + mementos.size());
    }

    // 获取备忘录（通常按栈或队列顺序）
    public EditorMemento pop() {
        if (mementos.isEmpty()) {
            System.out.println("⚠️  无可用备忘录");
            return null;
        }
        EditorMemento memento = mementos.remove(mementos.size() - 1);
        System.out.println("📤 管理者提供备忘录，剩余数量: " + mementos.size());
        return memento;
    }

    public boolean isEmpty() {
        return mementos.isEmpty();
    }
}

// 客户端使用示例
public class MementoPatternDemo {
    public static void main(String[] args) {
        System.out.println("📝 文本编辑器 - 备忘录模式示例\n");

        // 创建原发器和管理者
        TextEditor editor = new TextEditor();
        History history = new History();

        // 初始状态
        System.out.println("--- 初始状态 ---");
        editor.type("Hello");

        // 保存状态1
        System.out.println("\n--- 保存状态1 ---");
        history.push(editor.save());

        // 修改状态
        System.out.println("\n--- 修改状态 ---");
        editor.type(" World");

        // 保存状态2
        System.out.println("\n--- 保存状态2 ---");
        history.push(editor.save());

        // 再次修改
        System.out.println("\n--- 再次修改 ---");
        editor.type("! How are you?");

        // 撤销（恢复到状态2）
        System.out.println("\n--- 执行撤销 (Undo) ---");
        EditorMemento memento = history.pop();
        if (memento != null) {
            editor.restore(memento);
        }

        // 再次撤销（恢复到状态1）
        System.out.println("\n--- 再次撤销 (Undo) ---");
        memento = history.pop();
        if (memento != null) {
            editor.restore(memento);
        }

        // 尝试撤销（无更多状态）
        System.out.println("\n--- 再次撤销 ---");
        memento = history.pop(); // 应为空

        // 演示：管理者无法访问备忘录内容
        System.out.println("\n💡 说明：管理者 (History) 无法读取备忘录内容，");
        System.out.println("🔒 保证了封装性。备忘录的 getContent() 方法是包私有。");
    }
}

实例对应的UML图（简化版）

运行说明：

• TextEditor 是原发器，维护文本内容。
• EditorMemento 是备忘录，存储文本快照和时间戳。
• History 是管理者，使用栈结构保存备忘录，实现撤销功能。
• 客户端通过 save() 创建备忘录并交由 History 保存。
• 通过 pop() 获取备忘录并调用 restore() 恢复状态。
• EditorMemento 的 getContent() 为包私有，仅 TextEditor 可访问，History 无法读取内容，保证封装性。

四、总结

备忘录模式使用建议：

• 使用窄接口设计，防止管理者访问内部状态。
• 考虑内存开销，可实现快照压缩、增量保存或限制历史记录长度。
• 可结合命令模式，命令对象在执行前保存备忘录。
• 在 Java 中，可使用内部类实现备忘录，天然支持访问控制。

架构师洞见：
备忘录模式是“状态持久化”与“时间控制”的抽象。在现代架构中，其思想已演变为事件溯源（Event Sourcing）、CQRS（命令查询职责分离）、数据库事务日志 和 分布式快照 的核心。例如，在事件溯源中，对象状态由事件流重建，每个事件相当于一个“操作备忘录”；在分布式系统中，Raft 或 Paxos 算法使用日志（Log）作为状态变更的备忘录；在云原生中，Kubernetes 的 etcd 存储集群状态快照；在 AI 训练中，模型检查点（Checkpoint）是典型的备忘录应用。

未来趋势是：备忘录将与区块链结合，每个区块是系统状态的不可变备忘录；在量子计算中，量子态的测量与保存面临“观测即改变”的挑战，需要新型备忘录机制；在元宇宙中，用户虚拟形象的状态快照是跨世界迁移的基础；在AI Agent 中，Agent 的记忆（Memory）可视为一种高级备忘录，存储其经验与状态。

掌握备忘录模式，有助于设计出具备容错性、可追溯性、用户友好性的系统。作为架构师，应在设计需要“撤销”、“回滚”或“历史状态管理”的功能时，优先考虑备忘录模式。备忘录不仅是模式，更是系统韧性的保障——它提醒我们：真正的健壮性，不仅在于正确执行操作，更在于当错误发生时，系统有能力优雅地“回到过去”，从错误中学习并恢复，而非陷入不可逆的崩溃。