> 什么是备忘录模式
# 前言
备忘录模式是一种**行为设计模式**，它允许我们在不暴露对象内部实现细节的情况下，**捕获并外部化一个对象的内部状态**，以便在将来需要时可以将该对象恢复到原先保存的状态。
![image.png](https://developer.qcloudimg.com/http-save/yehe-1367556/23e49e61a04014af37ae9877131854a0.png)
>类似于undo日志。
![Gemini_Generated_Image_n8actn8actn8actn.png](https://developer.qcloudimg.com/http-save/yehe-1367556/2563c7ed5653d971e53a7fdb6b4870fd.png)
# 问题
1. **破坏封装性**：为了能让外部代码保存状态，我们不得不将对象的私有字段（如 `text`、`cursorPos`、`selection` 等）设置为公有，或者提供大量的 `getter` 方法。这**违背了面向对象设计的基本原则**，使得对象的内部细节对外暴露无遗，任何代码都可以随意修改其状态，系统变得脆弱且难以维护。
2. **状态保存成本高昂**：如果对象结构复杂，包含大量数据或嵌套引用，完整复制其状态可能非常**消耗内存和计算资源**。我们可能只需要保存部分关键状态，但暴露所有细节的接口让我们失去了这种灵活性。
3. **职责混乱**：由外部代码（如UI命令处理器）负责复制和恢复对象状态，会使得这些代码与业务对象的内部结构**紧密耦合**。一旦对象的内部表示发生变化（例如，将 `text` 字段从 `string` 改为 `StringBuilder`），所有负责状态保存的代码都需要同步修改，这违反了开闭原则。
4. **历史记录管理复杂**：如何存储多个历史状态（栈、列表）、何时清理旧状态、如何实现“重做”功能，这些逻辑如果散落在各处，会使得代码难以理解和维护。

> **核心矛盾**：**对象状态的隐私性（封装）**与**需要外部化保存状态以支持历史操作**之间的矛盾。

# 解决方案
备忘录模式建议将**保存状态**和**恢复状态**的职责交还给状态拥有者本身，即“原发器”（Originator）。同时，引入一个“备忘录”（Memento）对象作为状态快照的载体，和一个“负责人”（Caretaker）来管理这些快照的历史。
**模式的主要角色**：
- **原发器 (Originator)**：产生状态的对象。它知道**如何生成自己的状态快照（创建备忘录）**，也**知道如何利用一个备忘录来恢复自身状态**。但原发器不会自己管理历史。

- **备忘录 (Memento)**：一个**值对象**，其唯一目的是存储原发器的内部状态。备忘录的内容对除了原发器之外的任何对象都是**不透明或只读**的，这保护了原发器的封装性。在Go中，我们常通过将备忘录设为原发器的嵌套类型或私有类型来实现这一点。

- **负责人 (Caretaker)**：负责保存和管理备忘录的历史，但它**不能（也不应该）操作或检查备忘录的内容**。它只知道在何时（例如，执行命令前）请求原发器创建备忘录，并在何时（例如，执行撤销时）将备忘录交还给原发器进行恢复。

工作流程如下：
1. 当需要保存状态时（例如，用户执行一个操作前），**负责人**向**原发器**请求一个**备忘录**。

2. **原发器**创建一个新的备忘录对象，并将自身的当前状态信息存入其中，然后将这个备忘录返回给负责人。

3. **负责人**将这个备忘录保存到一个历史栈或列表中。

4. 当需要撤销操作时，**负责人**从历史记录中取出最新的备忘录，并将其**交还给原发器**。

5. **原发器**接收这个备忘录，读取其中的状态数据，并**将自己的状态恢复到备忘录所记录的时刻**。

通过这种方式，状态保存和恢复的逻辑被封装在原发器内部，外部代码（负责人）无需了解状态的具体细节。同时，备忘录作为一个简单的数据容器，隔离了状态访问，完美地维护了封装性。
![Gemini_Generated_Image_pu75sopu75sopu75.png](https://developer.qcloudimg.com/http-save/yehe-1367556/850d9e798d7164788180c45e734f7c7b.png)
# 应用场景
1. **编辑器、绘图软件等工具的撤销/重做功能**：这是最经典的应用。每一个用户操作（输入、删除、格式化、移动图形）之前，都可以保存一个状态快照。
2. **游戏进度保存与读取**：游戏角色（生命值、位置、装备）、关卡状态、世界地图探索进度等，都可以通过备忘录模式来保存和加载。
3. **事务操作与回滚**：在数据库或业务逻辑操作中，如果一系列操作中的某一步失败，需要回滚到事务开始前的状态。可以将初始状态保存为备忘录，失败时进行恢复。
4. **配置管理**：当用户修改了复杂的系统配置后，如果对结果不满意，可以提供“恢复默认”或“恢复到上次保存”的功能。
5. **算法状态快照**：在某些复杂的算法（如回溯算法、游戏AI决策树搜索）中，需要在探索不同路径时保存和恢复中间状态。
# 代码示例
![Gemini_Generated_Image_gbpu6wgbpu6wgbpu.png](https://developer.qcloudimg.com/http-save/yehe-1367556/946325c7713259da0b2014e8a9d8b40c.png)
在Go语言中实现备忘录模式，可以遵循以下步骤。由于Go没有类的“私有”概念，但通过包（package）级别的可见性控制和将备忘录类型定义为原发器的未导出类型，我们可以模拟类似的封装效果。

让我们以一个简单的文本编辑器 `TextEditor` 为例，实现一个支持撤销操作的场景。

```
// memento.go
package main

// Originator: 文本编辑器，需要保存状态的对象
type TextEditor struct {
    text    string
    cursorX int
    cursorY int
}

func (te *TextEditor) Write(words string) {
    te.text += words
}

func (te *TextEditor) SetCursor(x, y int) {
    te.cursorX = x
    te.cursorY = y
}

func (te *TextEditor) GetState() string {
    return fmt.Sprintf("Text: '%s', Cursor at (%d, %d)", te.text, te.cursorX, te.cursorY)
}

// Save 创建当前状态的备忘录
func (te *TextEditor) Save() *editorMemento {
    // 返回一个包含当前状态拷贝的备忘录
    return &editorMemento{
        text:    te.text,
        cursorX: te.cursorX,
        cursorY: te.cursorY,
    }
}

// Restore 从备忘录恢复状态
func (te *TextEditor) Restore(m *editorMemento) {
    te.text = m.text
    te.cursorX = m.cursorX
    te.cursorY = m.cursorY
}

// editorMemento: 备忘录，存储编辑器的特定状态。
// 注意：这个结构体及其字段都是未导出的（小写），只有本包内的代码可以访问。
type editorMemento struct {
    text    string
    cursorX int
    cursorY int
}

// Caretaker: 负责人，负责保存和管理备忘录历史
type History struct {
    mementos []*editorMemento
}

func (h *History) Backup(editor *TextEditor) {
    h.mementos = append(h.mementos, editor.Save())
    fmt.Println("History: State saved.")
}

func (h *History) Undo(editor *TextEditor) {
    if len(h.mementos) == 0 {
        fmt.Println("History: Nothing to undo.")
        return
    }
    // 取出最后一个备忘录
    lastMemento := h.mementos[len(h.mementos)-1]
    h.mementos = h.mementos[:len(h.mementos)-1] // 移除它
    editor.Restore(lastMemento)
    fmt.Println("History: State restored to previous checkpoint.")
}

func (h *History) ShowHistorySize() {
    fmt.Printf("History: Currently holding %d state(s).\n", len(h.mementos))
}

// main.go
func main() {
    editor := &TextEditor{}
    history := &History{}

    // 初始状态
    editor.Write("Hello, ")
    history.Backup(editor) // 保存状态1
    fmt.Println("Editor State:", editor.GetState())

    editor.Write("world!")
    editor.SetCursor(12, 0)
    history.Backup(editor) // 保存状态2
    fmt.Println("Editor State:", editor.GetState())

    editor.Write(" This is too much.")
    fmt.Println("Editor State (after more writing):", editor.GetState())

    history.ShowHistorySize()

    // 撤销到上一步
    history.Undo(editor)
    fmt.Println("Editor State (after undo):", editor.GetState())

    // 再撤销一次
    history.Undo(editor)
    fmt.Println("Editor State (after second undo):", editor.GetState())

    history.ShowHistorySize()
}
```
**输出结果**：
```
History: State saved.
Editor State: Text: 'Hello, ', Cursor at (0, 0)
History: State saved.
Editor State: Text: 'Hello, world!', Cursor at (12, 0)
Editor State (after more writing): Text: 'Hello, world! This is too much.', Cursor at (12, 0)
History: Currently holding 2 state(s).
History: State restored to previous checkpoint.
Editor State (after undo): Text: 'Hello, world!', Cursor at (12, 0)
History: State restored to previous checkpoint.
Editor State (after second undo): Text: 'Hello, ', Cursor at (0, 0)
History: Currently holding 0 state(s).
```

# 优缺点
**优点**：
- **良好的封装性**：这是备忘录模式最大的优点。你可以在不暴露对象内部细节的情况下创建其状态快照，**保护了对象的私有数据**。
- **简化原发器职责**：原发器只需负责生成和恢复自己的状态，而历史管理的复杂性（如存储、清理、撤销/重做栈）被转移到了负责人对象中，符合**单一职责原则**。
- **易于实现可恢复操作**：通过维护备忘录栈，可以轻松实现多次撤销和重做功能。

- **备忘录的惰性创建**：你可以选择只在必要时（例如状态确实改变时）才创建备忘录，优化性能。

**缺点**：
- **内存消耗**：如果客户端过于频繁地创建备忘录，或者原发器状态非常庞大，程序可能会**消耗大量内存**。需要考虑历史记录的深度限制或使用增量存储等优化策略。

- **负责人生命周期管理**：负责人必须跟踪原发器的生命周期，并在适当的时候（例如原发器被销毁时）**清理不再需要的备忘录**，否则可能导致内存泄漏。

- **在动态语言中的限制**：如文档所述，在PHP、Python、JavaScript等动态语言中，很难保证备忘录状态的不可变性，外部代码仍有可能修改其内容。但在Go这类静态语言中，通过可见性控制可以较好地解决。

> 序列化确实是一种保存状态的方法，但它通常要求对象的所有字段都是可导出的（即公有的），这同样破坏了封装性。备忘录模式提供了更精细的控制，允许你决定保存哪些状态（可能不是全部），并且保持了内部表示的私有性

# 总结
备忘录模式为我们提供了一种**优雅且安全地实现对象状态历史管理**的方案。它将状态保存和恢复的复杂逻辑封装在对象内部，对外则提供了一个简洁的“快照”接口，完美平衡了封装性与功能需求

备忘录模式是一种行为设计模式，它允许我们在不暴露对象内部实现细节的情况下，捕获并外部化一个对象的内部状态，以便在将来需要时可以将该对象恢复到原先保存的状态。

备忘录模式-使用go语言实现

十倍工程师

编程语言

架构设计

算法

备忘录模式是一种行为设计模式，能在不暴露对象内部细节的情况下保存和恢复状态。它通过原发器、备忘录和负责人三个角色实现撤销/重做功能，适用于编辑器、游戏存档等场景。该模式完美平衡封装性与功能需求，避免状态暴露，但需注意内存消耗问题。

数据库

游戏AI

容器

Python

2026新春采购季

tencentdb-catalog

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

备忘录模式-使用go语言实现-腾讯云开发者社区-腾讯云

备忘录模式-使用go语言实现

备忘录模式-使用go语言实现

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐