如何在Golang中实现备忘录模式？Go状态保存与恢复方案详解

备忘录模式是常用的行为型设计模式之一，核心目标是让对象可以保存自身的历史状态，同时不暴露内部实现的细节，在需要时可以将状态恢复到之前的某个版本。在Golang开发中，这类需求十分常见，比如文本编辑器的撤销重做、游戏的角色存档、分布式系统的配置回滚等场景，都可以借助备忘录模式实现。

备忘录模式的核心角色

备忘录模式的实现通常包含三个核心角色，各角色的职责划分清晰，共同完成状态的保存与恢复工作：

• 原发器（Originator）：需要保存状态的对象，它可以创建备忘录来保存当前内部状态，也可以通过备忘录恢复之前的状态。
• 备忘录（Memento）：用于存储原发器的内部状态，同时防止原发器之外的对象访问备忘录的内部数据，通常会对外部只暴露有限的接口。
• 管理者（Caretaker）：负责保存备忘录对象，但是不能对备忘录的内容进行操作或者检查，仅在需要的时候将对应的备忘录返回给原发器。

Golang实现备忘录模式的基本步骤

第一步：定义原发器结构体

原发器需要包含需要被保存的状态字段，同时提供创建备忘录和恢复状态的方法。以下是一个简单的文本编辑器原发器示例，需要保存的文本内容就是需要管理的状态：

package main

import "fmt"

// 原发器：文本编辑器
type TextEditor struct {
	content string // 需要保存的状态：文本内容
}

// 设置文本内容
func (t *TextEditor) SetContent(content string) {
	t.content = content
}

// 获取当前文本内容
func (t *TextEditor) GetContent() string {
	return t.content
}

// 创建备忘录，保存当前状态
func (t *TextEditor) CreateMemento() *Memento {
	return &Memento{content: t.content}
}

// 从备忘录恢复状态
func (t *TextEditor) RestoreFromMemento(m *Memento) {
	t.content = m.GetContent()
}

第二步：定义备忘录结构体

备忘录需要存储原发器的状态，同时为了保证封装性，备忘录的内部状态字段应该只对原发器可见，在Golang中可以通过小写字母开头的字段实现包内私有，或者仅在同一个文件中定义来限制访问范围：

// 备忘录：存储文本编辑器的状态
type Memento struct {
	content string // 存储的文本内容，仅对同包或同文件内的原发器可见
}

// 获取备忘录中保存的内容，仅暴露读取接口，不暴露修改接口
func (m *Memento) GetContent() string {
	return m.content
}

第三步：定义管理者结构体

管理者负责维护备忘录的列表，支持添加备忘录、获取指定索引的备忘录等操作，本身不关心备忘录内部的具体存储内容：

// 管理者：管理备忘录集合
type Caretaker struct {
	mementos []*Memento // 存储多个备忘录，支持多状态保存
}

// 添加新的备忘录
func (c *Caretaker) AddMemento(m *Memento) {
	c.mementos = append(c.mementos, m)
}

// 获取指定索引的备忘录
func (c *Caretaker) GetMemento(index int) *Memento {
	if index < 0 || index >= len(c.mementos) {
		return nil
	}
	return c.mementos[index]
}

第四步：组合使用完成状态保存与恢复

将三个角色组合起来，就可以实现状态的保存和恢复功能，以下是完整的测试示例：

func main() {
	// 创建原发器
	editor := &TextEditor{}
	// 创建管理者
	caretaker := &Caretaker{}

	// 第一次编辑内容，保存状态
	editor.SetContent("第一次输入的内容")
	caretaker.AddMemento(editor.CreateMemento())
	fmt.Println("当前内容：", editor.GetContent())

	// 第二次编辑内容，保存状态
	editor.SetContent("第二次修改的内容")
	caretaker.AddMemento(editor.CreateMemento())
	fmt.Println("当前内容：", editor.GetContent())

	// 恢复到第一次保存的状态
	firstMemento := caretaker.GetMemento(0)
	if firstMemento != nil {
		editor.RestoreFromMemento(firstMemento)
		fmt.Println("恢复到第一次保存的状态：", editor.GetContent())
	}

	// 恢复到第二次保存的状态
	secondMemento := caretaker.GetMemento(1)
	if secondMemento != nil {
		editor.RestoreFromMemento(secondMemento)
		fmt.Println("恢复到第二次保存的状态：", editor.GetContent())
	}
}

运行上述代码，输出结果如下：

当前内容： 第一次输入的内容
当前内容： 第二次修改的内容
恢复到第一次保存的状态： 第一次输入的内容
恢复到第二次保存的状态： 第二次修改的内容

实际应用场景扩展

上述示例是比较基础的备忘录模式实现，在实际的Golang项目中，还可以根据需求做更多的扩展：

• 如果需要保存的状态比较大，可以考虑在备忘录中只存储状态的差异，而不是全量状态，减少内存占用。
• 如果管理者需要管理大量的备忘录，可以添加备忘录的清理策略，比如只保留最近N个状态的备忘录，或者根据时间过期清理。
• 如果原发器的状态包含引用类型，需要注意备忘录保存状态时是深拷贝还是浅拷贝，避免恢复状态时出现数据联动修改的问题。

注意事项

在使用Golang实现备忘录模式时，需要注意以下几点：

• 备忘录的封装性要保证，除了原发器之外，其他对象不应该能修改备忘录内部的状态，避免状态被意外篡改。
• 如果原发器的状态字段很多，创建备忘录的时候需要保证所有需要保存的字段都被正确拷贝，避免遗漏关键状态。
• 管理者不需要关心备忘录的具体内容，只需要负责存储和返回备忘录，职责划分要清晰，符合单一职责原则。

Golang备忘录模式状态保存状态恢复Memento_Pattern修改时间：2026-06-19 07:00:16