是小鬏鬏啊1. 备忘录模式：对象状态的时光机
刚接手一个需要撤销功能的编辑器项目时，我遇到了一个棘手问题：如何在不破坏现有代码结构的前提下，实现用户操作步骤的回退？在尝试了几种暴力方案后，最终用备忘录模式（Memento Pattern）优雅地解决了这个问题。这个看似简单的设计模式，实则是处理对象状态保存与恢复的瑞士军刀。
备忘录模式的核心在于将对象内部状态封装在独立对象中，就像给程序装上了"时光机"。当我们需要保存状态时，创建一个备忘录对象存储当前状态；需要恢复时，再从备忘录中取出之前保存的状态。这种机制在需要实现撤销/重做、事务回滚、游戏存档等场景尤为实用。
关键理解：备忘录模式不是简单的对象序列化，它通过严格限制状态访问权限，实现了状态保存与业务逻辑的解耦。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 模式结构与核心角色拆解
2.1 经典三组件架构
典型的备忘录模式包含三个关键角色：
-
Originator（原发器）：
- 需要保存状态的对象（如编辑器文档）
- 提供
createMemento()生成备忘录 - 提供
restore(memento)从备忘录恢复状态
-
Memento（备忘录）：
- 存储原发器内部状态的黑盒子
- 对除原发器外的对象隐藏状态细节
-
Caretaker（管理者）：
- 负责备忘录的存储与管理
- 不能操作备忘录内容（仅保存和传递）
java复制// 典型实现示例
class Editor {
private String content;
public Memento save() {
return new Memento(this.content);
}
public void restore(Memento m) {
this.content = m.getSavedContent();
}
}
class Memento {
private final String content;
public Memento(String content) {
this.content = content;
}
private String getSavedContent() {
return this.content;
}
}
class History {
private Stack<Memento> states = new Stack<>();
public void push(Memento m) {
states.push(m);
}
public Memento pop() {
return states.pop();
}
}
2.2 状态存储的三种策略
根据场景不同，备忘录保存状态的方式也有差异：
-
全量存储：
- 每次保存完整状态
- 简单直接但内存占用高
- 适合状态结构简单的场景
-
增量存储：
- 只存储变化的部分
- 需要实现状态差异计算
- 适合大对象频繁保存的场景
-
命令式存储：
- 记录导致状态变化的操作命令
- 恢复时重新执行命令序列
- 适合操作可逆的场景（如文本编辑）
实战经验：在图形编辑器项目中，采用增量存储+命令式混合方案，使内存占用降低了73%。
3. 深度实现与性能优化
3.1 多级撤销的栈实现
实现多级撤销时，通常采用双栈结构：
java复制class UndoRedoManager {
private Stack<Memento> undoStack = new Stack<>();
private Stack<Memento> redoStack = new Stack<>();
public void saveState(Memento m) {
undoStack.push(m);
redoStack.clear();
}
public Memento undo() {
if (undoStack.size() <= 1) return null;
redoStack.push(undoStack.pop());
return undoStack.peek();
}
public Memento redo() {
if (redoStack.isEmpty()) return null;
Memento m = redoStack.pop();
undoStack.push(m);
return m;
}
}
3.2 大对象的状态存储优化
当处理大型对象（如高清图像）时，需要考虑：
-
懒加载备忘录：
java复制class ImageMemento { private String diskPath; // 实际存储在磁盘 public BufferedImage loadImage() { return ImageIO.read(new File(diskPath)); } } -
差异算法选择：
- 文本内容：基于行的diff算法
- 图形对象：基于区域的差异检测
- 结构化数据：JSON Patch格式
-
压缩策略：
java复制class CompressedMemento { private byte[] zippedData; public Memento uncompress() { // 使用GZIP等算法解压 } }
3.3 线程安全实现要点
在多线程环境下使用备忘录模式时：
-
对备忘录对象采用不可变设计
java复制public final class ImmutableMemento { private final String state; public ImmutableMemento(String s) { this.state = s; } public String getState() { return this.state; } } -
使用并发集合管理历史记录
java复制private ConcurrentLinkedDeque<Memento> history = new ConcurrentLinkedDeque<>(); -
对原发器状态访问加锁
java复制public synchronized Memento save() { // ... }
4. 典型应用场景与实战案例
4.1 文本编辑器的撤销功能
实现一个支持深度撤销的Markdown编辑器：
typescript复制class MarkdownEditor {
private content: string;
private styles: StyleMap;
public createSnapshot(): EditorSnapshot {
return new EditorSnapshot(
this.content,
deepClone(this.styles)
);
}
public restore(snap: EditorSnapshot) {
this.content = snap.getContent();
this.styles = snap.getStyles();
}
}
class EditorHistory {
private history: EditorSnapshot[] = [];
private currentIndex = -1;
public commit(snap: EditorSnapshot) {
// 截断当前指针后的历史
this.history = this.history.slice(0, this.currentIndex + 1);
this.history.push(snap);
this.currentIndex++;
}
public undo(): EditorSnapshot | null {
if (this.currentIndex <= 0) return null;
this.currentIndex--;
return this.history[this.currentIndex];
}
}
4.2 游戏存档系统设计
RPG游戏的存档管理实现：
csharp复制// 游戏角色状态
public class GameCharacter {
public Vector3 Position { get; set; }
public int Health { get; set; }
public List<Item> Inventory { get; } = new();
public CharacterMemento Save() {
return new CharacterMemento(
this.Position,
this.Health,
new List<Item>(this.Inventory)
);
}
public void Load(CharacterMemento memento) {
this.Position = memento.Position;
this.Health = memento.Health;
this.Inventory.Clear();
this.Inventory.AddRange(memento.Inventory);
}
}
// 存档管理器
public class SaveManager {
private Dictionary<DateTime, CharacterMemento> saves = new();
public void SaveGame(string slotName, GameCharacter pc) {
saves[DateTime.Now] = pc.Save();
SerializeToFile(slotName);
}
public void LoadGame(string slotName) {
var memento = DeserializeFromFile(slotName);
pc.Load(memento);
}
}
4.3 分布式事务中的状态恢复
在微服务架构中实现补偿事务：
java复制public class OrderService {
@Transactional
public void placeOrder(Order order) {
OrderMemento memento = new OrderMemento(order);
try {
inventoryService.reserve(order.items);
paymentService.charge(order.payment);
// ...其他操作
} catch (Exception e) {
memento.restore(); // 恢复到初始状态
compensationService.compensate(order);
}
}
}
5. 模式对比与选用建议
5.1 备忘录 vs 命令模式
| 维度 | 备忘录模式 | 命令模式 |
|---|---|---|
| 状态存储 | 保存对象完整状态 | 记录执行的操作命令 |
| 内存占用 | 取决于状态大小 | 通常更节省内存 |
| 恢复精度 | 精确到具体状态点 | 依赖命令的逆操作实现 |
| 适用场景 | 需要任意时间点恢复 | 操作可逆且顺序固定 |
5.2 备忘录 vs 原型模式
虽然两者都涉及对象复制，但有本质区别：
-
备忘录：
- 专注于特定时间点的状态保存
- 通常不暴露完整状态给外部
- 强调状态恢复的精确性
-
原型：
- 用于创建新对象副本
- 副本完全独立于原对象
- 强调对象创建的成本优化
5.3 何时选择备忘录模式
建议在以下场景优先考虑：
- 需要实现多级撤销/重做功能
- 系统状态需要回滚到历史版本
- 直接暴露对象状态会破坏封装性
- 状态快照需要独立于业务逻辑管理
6. 常见陷阱与最佳实践
6.1 典型实现错误
-
过度存储问题：
java复制// 错误示范：保存不需要的字段 class BadMemento { private String content; private long timestamp; // 非必要字段 private User author; // 引用可能变化的对象 } -
浅拷贝陷阱：
javascript复制// 错误示范：嵌套对象浅拷贝 class Editor { constructor() { this.styles = { color: '#000' }; } save() { return { content: this.content, styles: this.styles // 引用相同对象！ }; } } -
忽略版本兼容：
python复制# 错误示范：没有考虑类结构变化 class OldMemento: def __init__(self, text): self.saved_text = text # 新版本移除了text字段 class NewEditor: def __init__(self): self.content = ""
6.2 性能优化技巧
-
状态序列化优化：
java复制// 使用高效序列化方案 public class EfficientMemento implements Serializable { private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField("content", String.class), // 显式声明需要序列化的字段 }; } -
备忘录生命周期管理：
csharp复制// 实现LRU缓存管理 public class MementoCache { private LinkedList<Memento> list = new(); private Dictionary<string, LinkedListNode<Memento>> dict = new(); private int capacity; public void Add(string key, Memento memento) { if (dict.ContainsKey(key)) { list.Remove(dict[key]); } var node = list.AddFirst(memento); dict[key] = node; if (list.Count > capacity) { var last = list.Last; dict.Remove(/* 获取对应的key */); list.RemoveLast(); } } } -
增量保存策略：
typescript复制// 基于操作记录的增量保存 class DiffMemento { private baseState: State; private patches: Operation[]; apply(current: State): State { return patches.reduce((s, op) => op.apply(s), baseState); } }
6.3 测试备忘录系统的要点
-
状态一致性验证：
java复制@Test public void testMementoConsistency() { Editor editor = new Editor(); editor.type("Hello"); Memento m1 = editor.save(); editor.type(" World"); editor.restore(m1); assertEquals("Hello", editor.getContent()); } -
内存泄漏检测：
javascript复制// 在长时间运行的撤销系统中 describe('Memory leak test', () => { it('should not retain unnecessary mementos', () => { const editor = new TextEditor(); const history = new History(); for (let i = 0; i < 1000; i++) { editor.insert(`text${i}`); history.push(editor.save()); } // 强制GC后检查内存占用 expect(getMemoryUsage()).toBeLessThan(MAX_MEMORY); }); }); -
并发安全测试：
python复制def test_concurrent_save_restore(): editor = ConcurrentEditor() with ThreadPoolExecutor(max_workers=8) as executor: futures = [] for i in range(100): if random() > 0.5: f = executor.submit(editor.save) else: f = executor.submit(editor.restore, last_memento) futures.append(f) for f in futures: f.result() # 不应该抛出异常
7. 扩展应用与模式变体
7.1 分层备忘录系统
对于复杂对象，可以采用分层保存策略：
cpp复制class Document {
vector<Layer> layers;
class DocumentMemento {
vector<LayerMemento> layerMementos;
};
DocumentMemento save() {
DocumentMemento dm;
for (auto& layer : layers) {
dm.layerMementos.push_back(layer.save());
}
return dm;
}
};
class Layer {
vector<Shape*> shapes;
class LayerMemento {
vector<ShapeMemento> shapeMementos;
};
};
7.2 可持久化备忘录
将备忘录保存到数据库的实现：
java复制@Entity
public class EditorMementoEntity {
@Id
private String saveId;
@Lob
@Column(length = 100000)
private byte[] serializedState;
@Temporal(TemporalType.TIMESTAMP)
private Date created;
}
public class DBMementoManager {
@PersistenceContext
private EntityManager em;
public void saveToDB(String id, Memento m) {
EditorMementoEntity entity = new EditorMementoEntity();
entity.setSaveId(id);
entity.setSerializedState(serialize(m));
em.persist(entity);
}
}
7.3 基于事件的备忘录系统
与事件溯源模式结合的实现：
csharp复制public class EventSourcedEditor {
private List<IEvent> events = new();
private string currentContent = "";
public void Apply(TextChangedEvent e) {
this.currentContent = e.NewText;
this.events.Add(e);
}
public EditorMemento Save() {
return new EditorMemento {
Version = events.Count,
Content = currentContent
};
}
public void Restore(EditorMemento m) {
// 重放事件直到指定版本
this.currentContent = "";
for (int i = 0; i < m.Version; i++) {
events[i].Apply(this);
}
}
}
在实现一个跨平台笔记应用时，我采用了混合备忘录模式：对于文本内容使用命令式备忘录记录操作命令，对于富媒体内容使用增量快照，最终在保持性能的同时实现了1000步的撤销深度。关键点在于根据数据类型选择最合适的备忘录策略，而不是机械地套用单一方案。