备忘录模式
1. 什么是备忘录模式？
想象一下你在玩一个有存档功能的游戏。当你觉得当前进度不错，或者要进行一个有风险的操作前，你会选择“存档”。这个“存档”就保存了你当前游戏的所有状态（比如角色位置、等级、物品栏等）。如果后续操作失败或者你想回到之前的状态，你就可以“读档”，恢复到存档时的状态。
备忘录模式 就是这样一种行为型设计模式，它的核心思想是：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
简单来说，它提供了一种状态保存和恢复的机制，允许你“撤销”操作或回到历史某个时间点的状态。
2. 备忘录模式的结构 (主要角色)：
Originator (发起人/源对象):
这是我们想要保存其状态的对象。
它知道如何创建备忘录 (Memento) 来保存其当前状态。
它也知道如何从备忘录中恢复其之前的状态。
重要： Originator 内部的状态通常是私有的，不直接暴露给外部。
Memento (备忘录):
这是一个简单的对象，用于存储 Originator 的内部状态。
核心特点：
它对 Originator 是“宽接口”：Originator 可以访问 Memento 内部的所有数据，以便保存和恢复状态。
它对其他对象（特别是 Caretaker）是“窄接口”：Caretaker 只能持有 Memento 对象，但不能访问或修改 Memento 的内部状态。这是为了保护封装性。
Memento 自身不应该包含任何业务逻辑，它只是一个状态的快照容器。
Caretaker (负责人/管理者):
负责保存 Memento 对象。
它不知道 Memento 内部的具体内容，也不关心。它只是像保管箱一样持有 Memento。
当需要恢复状态时，它会将之前保存的 Memento 交还给 Originator。
Caretaker 可以保存多个 Memento，从而实现多步撤销或历史记录功能。
结构图示：
+-----------------+ creates +-----------------+ | Originator |<------------------| Memento | | - state | | - state | | + setState() | | + getState() | <-- (Usually package-private or accessible only to Originator) | + createMemento()| | | | + restore(m) | +-----------------+ +-----------------+ ^ | | (holds) | uses | V | +-----------------+ | | Caretaker |-------------------------+ | - mementoList | | + saveMemento(m)| | + getMemento(idx)| +-----------------+
实现窄接口和宽接口的技巧：
在 Java 中，为了实现 Memento 对 Originator 的宽接口和对 Caretaker 的窄接口，有几种常见做法：
内部类 (Inner Class):
将 Memento 定义为 Originator 的一个内部类（甚至是私有静态内部类）。
这样，Originator 可以访问 Memento 的所有成员（即使是私有的），而 Caretaker 只能通过 Memento 暴露的公共接口（如果有的话，但通常 Memento 对 Caretaker 没有任何有意义的公共方法）或者仅仅是持有 Memento 的引用。
包级私有 (Package-Private) 接口：
定义一个接口 MementoInterface，只包含 Caretaker 需要的方法（通常是空的，或者只有标记作用）。
让 Memento 类实现这个接口，并且 Memento 类的 getState() 等方法设置为包级私有或 protected。
Originator 和 Memento 放在同一个包下，这样 Originator 可以访问 Memento 的包级私有成员。Caretaker 只能通过 MementoInterface 来引用 Memento。
标记接口 (Marker Interface) + 封装：
Memento 实现一个空的标记接口。
Memento 的状态获取方法对 Originator 可见（例如，通过构造函数传入，或者 Originator 具有特殊权限访问）。
内部类是最常见且简洁的实现方式。
3. 备忘录模式的优缺点：
优点：
封装性： 保持了 Originator 内部状态的封装。Caretaker 和其他客户端代码不需要知道 Originator 的内部结构。
简化 Originator： Originator 不需要自己管理其历史状态，将状态的保存和恢复逻辑与自身核心业务逻辑解耦。
状态恢复： 提供了方便的状态恢复机制，可以实现撤销/重做、回滚等功能。
高内聚，低耦合： Originator 和 Memento 紧密相关，但它们与 Caretaker 之间的耦合度较低。
缺点：
资源消耗： 如果 Originator 的状态非常复杂，或者需要保存大量的历史状态，那么创建和存储 Memento 对象可能会消耗大量的内存。需要谨慎管理 Memento 的生命周期。
实现细节： 如果 Originator 的内部状态非常多，创建 Memento 的时候需要复制所有相关状态，可能会比较繁琐。
可能破坏封装（如果 Memento 接口设计不当）： 如果 Memento 暴露了过多的内部状态给非 Originator 对象，可能会破坏 Originator 的封装性。所以 Memento 的接口设计很重要。
4. 备忘录模式的应用场景：
需要保存和恢复对象历史状态的场景。
实现撤销/重做 (Undo/Redo) 功能： 文本编辑器、绘图软件、IDE 中的操作撤销。
数据库事务的回滚 (Rollback) 机制的简化模型。
游戏存档和读档功能。
配置信息的快照和恢复： 当用户修改配置后，可以恢复到之前的某个配置版本。
状态机中，需要回溯到某个先前状态时。
代码示例 (使用内部类实现 Memento):
假设我们有一个文本编辑器 Editor，它可以输入文本，并支持撤销操作。
import java.util.Stack;
// Memento (备忘录) - 作为 Editor 的静态内部类
class Editor {
private String content; // Originator 的状态
public Editor() {
this.content = "";
}
public void type(String words) {
this.content += words;
}
public String getContent() {
return content;
}
// 创建备忘录，保存当前状态
public EditorMemento save() {
return new EditorMemento(this.content);
}
// 从备忘录恢复状态
public void restore(EditorMemento memento) {
if (memento != null) {
this.content = memento.getSavedContent();
}
}
// Memento 内部类
// 只有 Editor 类可以访问其 getSavedContent() 方法（如果设置为 private，则通过 Editor 访问）
// 或者可以设为包级私有，或者像这里一样，通过外部类间接控制访问
public static class EditorMemento { // 为了简单，这里设为 public static 内部类
private final String savedContent; // Memento 存储的状态
private EditorMemento(String contentToSave) {
this.savedContent = contentToSave;
}
// 这个方法理论上应该只被 Originator (Editor) 调用
// 如果 EditorMemento 不是 public static，而是非静态内部类，Editor可以直接访问 savedContent
// 如果是 private static 内部类，Editor 也可以访问
// 这里为了Caretaker能从Editor获取，Editor能从Caretaker设置，做了一些简化
private String getSavedContent() {
return savedContent;
}
}
}
// Caretaker (负责人)
class History {
private Stack<Editor.EditorMemento> history = new Stack<>(); // 用栈来保存历史记录
public void save(Editor editor) {
history.push(editor.save()); // 从 Originator 获取 Memento 并保存
}
public void undo(Editor editor) {
if (!history.isEmpty()) {
Editor.EditorMemento lastMemento = history.pop(); // 取出最近的 Memento
editor.restore(lastMemento); // Originator 从 Memento 恢复状态
} else {
System.out.println("Nothing to undo.");
}
}
}
public class MementoPatternDemo {
public static void main(String[] args) {
Editor editor = new Editor();
History history = new History();
// 第一次操作
editor.type("This is the first sentence. ");
history.save(editor); // 保存状态1
System.out.println("Current Content: " + editor.getContent());
// 第二次操作
editor.type("This is the second sentence. ");
history.save(editor); // 保存状态2
System.out.println("Current Content: " + editor.getContent());
// 第三次操作
editor.type("And this is the third one.");
// history.save(editor); // 假设这次忘记保存了
System.out.println("Current Content: " + editor.getContent());
// 执行撤销
history.undo(editor); // 撤销到状态2
System.out.println("After first undo: " + editor.getContent());
history.undo(editor); // 撤销到状态1
System.out.println("After second undo: " + editor.getContent());
history.undo(editor); // 没有更多可撤销的了
System.out.println("After third undo (should be no change or message): " + editor.getContent());
}
}
在这个例子中：
Editor 是 Originator。
EditorMemento 是 Memento，作为 Editor 的静态内部类。它的 savedContent 字段和构造函数是私有的（或者包级私有），getSavedContent() 是私有的（理论上），确保只有 Editor 能创建和解释它。
History 是 Caretaker，它使用一个 Stack 来存储 EditorMemento 对象，实现了多步撤销。
总结：
备忘录模式是一种强大的行为模式，它通过将对象的状态封装在备忘录中，实现了状态的外部存储和恢复，同时又不破坏对象的封装性。它在需要撤销/重做、历史记录或状态快照的场景中非常有用。关键在于设计好 Memento 的接口，使其对 Originator 开放足够的信息，而对其他对象保持封闭。