Java设计模式之备忘录模式：从入门到架构级实践

原创于 2025-04-15 07:00:00 发布 · 2.3k 阅读

33 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #备忘录模式

java设计模式专栏收录该内容

24 篇文章

订阅专栏

一、备忘录模式核心思想

备忘录模式（Memento Pattern）是一种行为型设计模式，核心在于捕获对象内部状态并在不破坏封装性的前提下保存该状态。当需要回滚操作、实现撤销功能或提供系统快照时，该模式能优雅地实现对象状态的历史记录。

1.1 核心价值

状态隔离：将对象状态存储与业务逻辑解耦
历史管理：支持多时间点的状态存档/恢复
封装保护：外部无法直接访问对象内部状态

二、三大核心角色详解

2.1 Originator（原发器）

public class TextEditor {
    private String content;
    
    // 创建备忘录
    public TextMemento createMemento() {
        return new TextMemento(content);
    }
    
    // 从备忘录恢复
    public void restoreFromMemento(TextMemento memento) {
        this.content = memento.getSavedContent();
    }
    
    // 业务方法
    public void append(String text) {
        content += text;
    }
}

2.2 Memento（备忘录）

// 使用包级私有访问控制
final class TextMemento {
    private final String content;
    
    TextMemento(String content) {
        this.content = content;
    }
    
    String getSavedContent() {
        return content;
    }
}

2.3 Caretaker（管理者）

public class HistoryManager {
    private final Stack<TextMemento> history = new Stack<>();
    
    public void saveState(TextMemento memento) {
        history.push(memento);
    }
    
    public TextMemento getLastSavedState() {
        if (history.isEmpty()) return null;
        return history.pop();
    }
    
    public int getHistorySize() {
        return history.size();
    }
}

三、六种典型应用场景

文本编辑器的撤销/重做：支持多级编辑历史
游戏存档系统：保存玩家进度和游戏状态
事务回滚机制：数据库操作的事务管理
配置管理：系统参数的版本控制
画图软件的历史记录：笔触操作的步骤回溯
金融交易系统：交易记录的原子性操作

四、进阶实现技巧

4.1 增量备忘录

class DeltaMemento {
    private final String deltaChange;
    private final long timestamp;
    
    // 只存储差异部分
}

4.2 多级撤销栈

class MultiLevelHistory {
    private final Deque<Memento> undoStack = new ArrayDeque<>();
    private final Deque<Memento> redoStack = new ArrayDeque<>();
    
    public void saveState(Memento memento) {
        undoStack.push(memento);
        redoStack.clear();
    }
    
    public Memento undo() {
        if (undoStack.size() <= 1) return null;
        redoStack.push(undoStack.pop());
        return undoStack.peek();
    }
}

4.3 大对象优化

class BigDataMemento implements Serializable {
    // 使用原型模式减少创建开销
    @Override
    public BigDataMemento clone() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (BigDataMemento) ois.readObject();
        } catch (Exception e) {
            return null;
        }
    }
}

五、生产级架构实践

5.1 分布式快照系统

public class ClusterSnapshot {
    private Map<String, List<Memento>> shardHistory = new ConcurrentHashMap<>();
    
    public void saveClusterState(Map<String, Originator> nodes) {
        nodes.forEach((nodeId, originator) -> {
            shardHistory.computeIfAbsent(nodeId, k -> new ArrayList<>())
                       .add(originator.createMemento());
        });
    }
    
    public void restoreClusterState(int snapshotVersion) {
        shardHistory.forEach((nodeId, mementos) -> {
            Originator node = getNodeById(nodeId);
            node.restoreFromMemento(mementos.get(snapshotVersion));
        });
    }
}

5.2 数据库事务管理器

public class TransactionManager {
    private static final ThreadLocal<Stack<Memento>> transactionStack = 
        ThreadLocal.withInitial(Stack::new);
    
    public void beginTransaction(Originator originator) {
        transactionStack.get().push(originator.createMemento());
    }
    
    public void commit() {
        transactionStack.get().clear();
    }
    
    public void rollback(Originator originator) {
        if (!transactionStack.get().isEmpty()) {
            originator.restoreFromMemento(transactionStack.get().pop());
        }
    }
}

六、性能优化方案

状态压缩：使用差异算法存储变化量
懒加载：非活跃状态的备忘录持久化到磁盘
LRU缓存：限制内存中保存的历史记录数量
多版本合并：定期合并历史版本减少存储量
原型模式+备忘录：结合对象复制提升创建效率

七、设计模式对比

模式	关注点	数据流向	典型场景
备忘录模式	对象状态保存与恢复	双向	撤销操作、事务回滚
命令模式	请求封装与参数化	单向	操作队列、任务调度
原型模式	对象复制	单向	创建成本高的对象实例
状态模式	状态驱动的行为变化	内部状态转换	状态机实现

八、高频面试问题

如何保证备忘录的线程安全？
- 答：采用线程局部存储+不可变对象设计
深拷贝和浅拷贝如何选择？
- 答：根据对象复杂度决定，推荐结合原型模式实现深拷贝
如何避免内存泄漏？
- 答：1）限制历史记录数量 2）使用弱引用 3）定期清理过期状态
与数据库事务的异同？
- 同：都支持回滚机制
- 异：备忘录是内存级操作，数据库事务包含持久化保证

九、最佳实践原则

状态粒度控制：合理划分需要保存的状态范围
生命周期管理：明确备忘录的创建和销毁机制
访问控制：严格限制备忘录的访问权限
序列化优化：对大型对象采用高效序列化方案
版本兼容：考虑状态结构的版本升级问题

十、典型应用案例：智能文档系统

public class SmartDocument {
    private String content;
    private Style style;
    
    // 复合备忘录
    public DocumentMemento createMemento() {
        return new DocumentMemento(
            new ContentSnapshot(content),
            new StyleSnapshot(style)
        );
    }
    
    private static class DocumentMemento {
        private final ContentSnapshot content;
        private final StyleSnapshot style;
        
        // 分部件恢复支持
        void restoreContent() { /* ... */ }
        void restoreStyle() { /* ... */ }
    }
}