备忘录模式（Memento Pattern）是一种行为型设计模式，用于在不破坏封装性的前提下，捕获一个对象的内部状态-CSDN博客

本文链接：https://blog.csdn.net/blog_programb/article/details/147822102

备忘录模式（Memento Pattern）是一种行为型设计模式，用于在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样可以在以后将对象恢复到原先保存的状态。备忘录模式的核心思想是通过创建一个备忘录对象来保存对象的状态，以便在需要时可以恢复到该状态。

1. 备忘录模式的主要角色

发起人（Originator）：创建一个备忘录，用以记录当前时刻的内部状态，并可以使用备忘录恢复内部状态。
备忘录（Memento）：用于存储发起人的内部状态，备忘录对象通常由发起人创建，并由备忘录管理者保存。
备忘录管理者（Caretaker）：负责保存和提供备忘录，但不能对备忘录的内容进行操作或检查。

2. 备忘录模式的实现步骤

定义发起人类：创建一个类，包含需要保存状态的属性，并提供创建和恢复备忘录的方法。
定义备忘录类：创建一个类，用于存储发起人的内部状态。
定义备忘录管理类：创建一个类，用于保存和提供备忘录。
客户端代码：通过发起人创建备忘录，并通过备忘录管理类保存和恢复备忘录。

3. 示例代码

假设我们有一个文本编辑器，用户可以编辑文本，并且可以撤销到之前的某个状态。我们可以使用备忘录模式来实现这个需求。

3.1 定义发起人类

public class TextEditor {
    private String content;

    public TextEditor(String content) {
        this.content = content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    public Memento createMemento() {
        return new Memento(content);
    }

    public void restoreMemento(Memento memento) {
        this.content = memento.getContent();
    }
}

3.2 定义备忘录类

public class Memento {
    private String content;

    private Memento(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

3.3 定义备忘录管理类

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

public class MementoManager {
    private List<Memento> mementos = new ArrayList<>();

    public void addMemento(Memento memento) {
        mementos.add(memento);
    }

    public Memento getMemento(int index) {
        return mementos.get(index);
    }
}

3.4 客户端代码

public class Main {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor("Hello, World!");
        System.out.println("初始内容: " + editor.getContent());

        MementoManager manager = new MementoManager();
        manager.addMemento(editor.createMemento());

        editor.setContent("Hello, Java!");
        System.out.println("修改后的内容: " + editor.getContent());

        editor.restoreMemento(manager.getMemento(0));
        System.out.println("恢复后的内容: " + editor.getContent());
    }
}

4. 输出结果

运行客户端代码，输出结果如下：

初始内容: Hello, World!
修改后的内容: Hello, Java!
恢复后的内容: Hello, World!

5. 备忘录模式的优点

封装性好：备忘录模式将对象的状态封装在备忘录对象中，避免了状态的直接暴露。
简化客户端代码：客户端代码可以通过备忘录管理类来保存和恢复对象的状态，而无需直接操作对象的状态。
符合开闭原则：对扩展开放，对修改封闭，新增状态保存或恢复功能时，无需修改现有代码。

6. 适用场景

备忘录模式适用于以下场景：

当需要保存和恢复对象的状态时。
当对象的状态变化复杂，需要提供一种方式来回溯到某个特定状态时。
当对象的状态需要在外部保存和管理时。

通过备忘录模式，可以有效地保存和恢复对象的状态，使得代码更加模块化、易于维护和扩展。
备忘录模式（Memento Pattern）是一种行为设计模式，它允许在不破坏对象封装的前提下，捕获并外部化一个对象的内部状态，以便后续可以将该对象恢复到先前的状态。这种模式提供了一种"撤销"或"回滚"操作的机制，广泛应用于需要实现历史记录、撤销功能或事务管理的系统中。

核心概念

备忘录（Memento）：存储原发器（Originator）的内部状态，但不向外部暴露这些状态的具体内容。备忘录有两种接口：窄接口（Caretaker可见，只能传递备忘录）和宽接口（Originator可见，允许访问内部状态）。
原发器（Originator）：创建备忘录并使用备忘录恢复自身状态的对象。它知道如何保存自己的状态和从备忘录中恢复状态。
管理者（Caretaker）：负责保存备忘录，但不检查或修改备忘录的内容。通常管理多个备忘录，形成历史记录栈。

主要作用

保存和恢复状态：在不破坏封装的情况下，保存和恢复对象的内部状态。
简化原发器：将状态保存和恢复的逻辑封装在备忘录中，使原发器的职责更加单一。
支持撤销操作：通过保存历史状态，实现系统的撤销或回滚功能。

典型场景

需要实现撤销/重做功能：如文本编辑器、图形设计软件、游戏等。
需要实现事务管理：如数据库操作的回滚机制。
需要保存对象历史状态：如游戏存档、系统配置快照等。

示例结构

下面是备忘录模式的一个简单示例结构（Python 伪代码）：

# 备忘录类
class Memento:
    def __init__(self, state):
        self._state = state  # 内部状态，外部不可直接访问
    
    def get_state(self):
        return self._state

# 原发器类
class Originator:
    def __init__(self, state):
        self._state = state
    
    def set_state(self, state):
        print(f"设置状态为: {state}")
        self._state = state
    
    def get_state(self):
        return self._state
    
    def save_state_to_memento(self):
        print("保存状态到备忘录")
        return Memento(self._state)
    
    def restore_state_from_memento(self, memento):
        self._state = memento.get_state()
        print(f"从备忘录恢复状态为: {self._state}")

# 管理者类
class Caretaker:
    def __init__(self):
        self._mementos = []
    
    def add_memento(self, memento):
        self._mementos.append(memento)
    
    def get_memento(self, index):
        return self._mementos[index]

# 客户端代码
if __name__ == "__main__":
    originator = Originator("状态1")
    caretaker = Caretaker()
    
    # 保存当前状态
    caretaker.add_memento(originator.save_state_to_memento())
    
    # 修改状态
    originator.set_state("状态2")
    
    # 再次保存状态
    caretaker.add_memento(originator.save_state_to_memento())
    
    # 修改状态
    originator.set_state("状态3")
    
    # 恢复到第一个保存的状态
    originator.restore_state_from_memento(caretaker.get_memento(0))