设计模式教程：备忘录模式（Memento Pattern）

备忘录模式（Memento Pattern）详解

一、模式概述

备忘录模式（Memento Pattern）是一种行为型设计模式，允许在不暴露对象实现细节的情况下，保存对象的内部状态，并在需要时恢复该状态。备忘录模式的核心思想是将对象的状态保存在一个独立的备忘录对象中，从而提供一种可以撤销操作、恢复历史状态的机制。

这种模式特别适用于需要提供“撤销/恢复”功能的应用场景，例如文本编辑器中的撤销操作、游戏中的进度保存和恢复等。

二、模式角色和类图

备忘录模式主要由三个角色组成：

1. Originator（发起人）: 负责创建一个备忘录，用以保存当前的内部状态，并可以恢复到之前的状态。
2. Memento（备忘录）: 存储发起人的内部状态，但不允许外部修改或查看这些状态。
3. Caretaker（负责人）: 负责保存和管理备忘录。Caretaker不能直接访问备忘录的内容，它只能保存和获取备忘录。

类图

+--------------------+
|    Originator      | <------------+
+--------------------+              |
| - state            |              |
| + createMemento()  |              |
| + restoreMemento() |              |
+--------------------+              |
          |                         |
          v                         |
+--------------------+    +-----------------+
|     Memento        |    |  Caretaker      |
+--------------------+    +-----------------+
| - state            |    | - mementos      |
| + getState()       |    | + addMemento()  |
+--------------------+    | + getMemento()  |
                          +-----------------+

三、备忘录模式的关键概念

• Originator: 负责保存和恢复对象的状态。它通过 createMemento() 方法创建一个备忘录，并通过 restoreMemento() 方法恢复备忘录中的状态。

• Memento: 储存一个对象的内部状态，且不允许外部直接修改。它仅提供获取状态的接口，而不会暴露对象内部的实现细节。

• Caretaker: 负责保存和管理备忘录。它不直接操作或修改备忘录的内容，只能通过接口获取和存储备忘录。

四、代码实现

接下来通过一个简单的 Java 示例，详细说明备忘录模式的使用。

// Memento类，用于保存对象的状态
class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

// Originator类，负责创建和恢复备忘录
class Originator {
    private String state;

    public void setState(String state) {
        System.out.println("Setting state to: " + state);
        this.state = state;
    }

    public String getState() {
        return state;
    }

    // 创建一个备忘录，将当前状态保存
    public Memento createMemento() {
        return new Memento(state);
    }

    // 从备忘录恢复状态
    public void restoreMemento(Memento memento) {
        this.state = memento.getState();
        System.out.println("Restoring state to: " + state);
    }
}

// Caretaker类，负责管理备忘录
class Caretaker {
    private Memento memento;

    // 保存备忘录
    public void saveMemento(Memento memento) {
        this.memento = memento;
    }

    // 获取备忘录
    public Memento getMemento() {
        return memento;
    }
}

public class MementoPatternDemo {
    public static void main(String[] args) {
        // 创建发起人
        Originator originator = new Originator();
        
        // 创建负责人
        Caretaker caretaker = new Caretaker();
        
        // 设置状态并保存备忘录
        originator.setState("State #1");
        caretaker.saveMemento(originator.createMemento());
        
        // 设置另一个状态并保存备忘录
        originator.setState("State #2");
        caretaker.saveMemento(originator.createMemento());
        
        // 恢复状态
        originator.restoreMemento(caretaker.getMemento());  // 恢复到State #2
        originator.restoreMemento(caretaker.getMemento());  // 恢复到State #1
    }
}

五、代码解释

1. Memento 类: 存储状态并提供一个 getState() 方法来获取状态。它只负责数据的保存，不提供任何修改操作。

2. Originator 类: 负责创建备忘录和恢复状态。它通过 createMemento() 方法创建一个新的备忘录对象，并通过 restoreMemento() 方法将状态恢复到备忘录中的状态。

3. Caretaker 类: 负责保存和管理备忘录对象。它不直接修改备忘录的状态，只提供保存和获取备忘录的接口。

4. 主函数: 在主函数中，我们创建了一个 Originator 对象，设置其状态并创建了多个备忘录，然后通过 Caretaker 来管理备忘录，最后演示了如何通过备忘录恢复状态。

六、输出

Setting state to: State #1
Setting state to: State #2
Restoring state to: State #2
Restoring state to: State #1

七、实际应用场景

1. 文本编辑器的撤销功能

在文本编辑器中，每次用户修改文本时，程序都会保存当前的文本内容作为一个备忘录。当用户点击“撤销”按钮时，程序就可以恢复到用户修改前的状态。

// 伪代码示例
Editor editor = new Editor();
Caretaker caretaker = new Caretaker();

editor.setContent("Hello World");
caretaker.saveMemento(editor.createMemento());

editor.setContent("Hello Java");
caretaker.saveMemento(editor.createMemento());

// 用户点击撤销按钮
editor.restoreMemento(caretaker.getMemento()); // 恢复到 "Hello World"

2. 游戏进度保存

在游戏中，玩家的进度可以定期保存为备忘录。玩家可以选择恢复到之前的某个保存点。

// 伪代码示例
GameProgress game = new GameProgress();
Caretaker caretaker = new Caretaker();

game.setProgress("Level 1 - Score: 100");
caretaker.saveMemento(game.createMemento());

game.setProgress("Level 2 - Score: 200");
caretaker.saveMemento(game.createMemento());

// 玩家选择恢复
game.restoreMemento(caretaker.getMemento()); // 恢复到Level 1

八、优点与缺点

优点

1. 封装性: 备忘录模式提供了很好的封装性，发起人的内部状态对外部不可见，外部只能通过备忘录来恢复状态，避免了直接暴露对象的实现细节。

2. 支持撤销功能: 备忘录模式非常适用于实现撤销功能，能够轻松实现历史状态的恢复。

3. 松耦合: Caretaker 和 Originator 之间的耦合较低，它们只通过备忘录进行通信，不直接互相依赖。

缺点

1. 空间开销: 每次修改状态时都需要创建一个新的备忘录对象，这可能会带来额外的内存开销。尤其是当状态对象很大时，备忘录模式可能会成为性能瓶颈。

2. 管理复杂性: 如果需要管理大量备忘录对象，可能会增加系统的复杂性。此时，需要提供有效的备忘录管理机制，避免内存泄漏或冗余备忘录的创建。

九、总结

备忘录模式通过引入备忘录对象来保存和恢复对象的状态，实现了一个灵活的历史记录和撤销恢复机制。它特别适用于需要保存对象状态并在后续恢复的场景，比如文本编辑器中的撤销操作、游戏中的进度保存等。尽管备忘录模式在实现时可能会带来额外的内存开销，但它为复杂系统中的状态管理提供了非常强大的支持。

希望这篇文章能够帮助你更好地理解备忘录模式，并在实际项目中合理地运用它。

版权声明

1. 本文内容属于原创，欢迎转载，但请务必注明出处和作者，尊重原创版权。
2. 转载时，请附带原文链接并注明“本文作者：扣丁梦想家
3. 禁止未经授权的商业转载。

如果您有任何问题或建议，欢迎留言讨论。