当前位置：首页 > news >正文

23种设计模式-备忘录(Memento)设计模式

news 来源：原创 2025/6/18 4:03:50

备忘录设计模式

🚩什么是备忘录设计模式？
🚩备忘录设计模式的特点
🚩备忘录设计模式的结构
🚩备忘录设计模式的优缺点
🚩备忘录设计模式的Java实现
🚩代码总结
🚩总结

🚩什么是备忘录设计模式？

备忘录设计模式（Memento Pattern） 是一种 行为型设计模式，用于在不破坏对象封装性的前提下，捕获对象的内部状态，并在未来的某个时间点恢复到该状态。该模式可以帮助我们实现 撤销（Undo） 操作，常用于文本编辑器、事务管理等场景。

使用场景

需要 保存和恢复对象的状态，比如 撤销/重做 功能
需要 防止外部对象直接访问对象的私有状态，保持封装性
需要 在历史记录中存储对象的多个状态，支持回溯

🚩备忘录设计模式的特点

封装性：对象的状态被存储在备忘录中，避免外部访问
状态恢复：允许对象恢复到之前的状态，支持回溯操作
简化历史记录管理：可以存储多个历史状态，支持撤销、重做等功能
解耦设计：原发器（Originator）与管理者（Caretaker）解耦，原发器只负责创建和恢复状态，管理者负责存储

🚩备忘录设计模式的结构

备忘录模式主要包含以下部分：

Originator（原发器）：负责创建备忘录（Memento）并存储当前状态，支持从备忘录恢复状态
Memento（备忘录）：存储原发器的状态，并提供恢复该状态的方法
Caretaker（管理者）：负责存储多个备忘录对象，可以提供回溯功能

🚩备忘录设计模式的优缺点

✅ 优点

封装性好，外部对象无法直接访问对象的状态
支持撤销和重做功能，适用于编辑器、事务管理等场景
解耦原发器和管理者，增强了代码的可维护性

❌ 缺点

内存消耗大，如果存储大量状态，可能会影响系统性能
状态存储复杂，如果对象的状态较大，存储和恢复的成本较高

🚩备忘录设计模式的Java实现

代码地址：GitHub

创建 Memento（备忘录）类

/**
 * @author hanson
 * @description: 备忘录
 * @date 2025-03-25 22:57:26
 * @version: 1.0
 */
public class Memento {// 备忘录
    private String state;

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

    public String getState() {
        return state;
    }
}

创建Originator（原发器）类

/**
 * @author hanson
 * @description: 原发器
 * @date 2025-03-25 22:56:35
 * @version: 1.0
 */
public class Originator {// 原发器
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

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

    public void setMemento(Memento memento) {
        state = memento.getState();
    }
}

创建Caretaker（管理者）类

/**
 * @author hanson
 * @description: 管理者
 * @date 2025-03-25 22:58:35
 * @version: 1.0
 */
public class Caretaker {// 管理者

    private List<Memento> mementoList = new ArrayList<>();

    public void addMemento(Memento state) {
        mementoList.add(state);
    }

    public Memento getMemento(int index) {
        // 判断参数是否合法
        if (index >= 1 && index <= mementoList.size()) {
            return mementoList.get(index - 1);
        }

        return null;
    }

    public void showMemento() {
        int cnt = 1;
        // for (遍历对象类型 对象名 : 遍历对象)
        for (Memento memento : mementoList) {
            System.out.println("第" + cnt + "次备份，状态为：" + memento.getState());

            cnt++;
        }
    }
}

测试备忘录模式

/**
 * @author hanso
 * @description: 测试备忘录模式
 * @date 2025-03-25 23:00:25
 * @version: 1.0
 */
public class MementoPattern {
    public static void main(String[] args) {
        Caretaker caretaker = new Caretaker();
        Originator originator = new Originator();

        originator.setState("1024");
        Memento backup1 = originator.createMemento();
        caretaker.addMemento(backup1);

        originator.setState("2048");
        Memento backup2 = originator.createMemento();
        caretaker.addMemento(backup2);

        originator.setState("4096");
        Memento backup3 = originator.createMemento();
        caretaker.addMemento(backup3);

        System.out.println(originator.getState());

        caretaker.showMemento();

        Memento memento1 = caretaker.getMemento(2);
        originator.setMemento(memento1);

        System.out.println("根据第2次备份还原之后的状态为：" + originator.getState());
    }
}