Java备忘录模式详解

备忘录模式详解

一、备忘录模式概述

备忘录模式(Memento Pattern)是一种行为型设计模式，它允许在不破坏封装性的前提下捕获并外部化一个对象的内部状态，以便以后可以将该对象恢复到原先保存的状态。

核心特点

状态保存：捕获对象内部状态
封装保护：不暴露对象实现细节
撤销机制：支持回滚到之前状态
历史管理：可维护多个状态快照

二、备忘录模式的结构

主要角色

Originator：原发器，需要保存状态的对象
Memento：备忘录，存储原发器状态
Caretaker：管理者，负责保存和恢复备忘录

三、备忘录模式的实现

1. 基本实现

复制代码

// 备忘录类
public class TextMemento {
    private final String text;
    
    public TextMemento(String text) {
        this.text = text;
    }
    
    public String getText() {
        return text;
    }
}

// 原发器 - 文本编辑器
public class TextEditor {
    private String text;
    
    public void write(String text) {
        this.text = text;
    }
    
    public TextMemento save() {
        return new TextMemento(text);
    }
    
    public void restore(TextMemento memento) {
        this.text = memento.getText();
    }
    
    public void print() {
        System.out.println("当前内容: " + text);
    }
}

// 管理者
public class History {
    private Stack<TextMemento> history = new Stack<>();
    
    public void push(TextMemento memento) {
        history.push(memento);
    }
    
    public TextMemento pop() {
        return history.pop();
    }
}

// 使用示例
TextEditor editor = new TextEditor();
History history = new History();

editor.write("第一版内容");
history.push(editor.save());
editor.print();

editor.write("修改后的内容"); 
editor.print();

editor.restore(history.pop());
editor.print(); // 恢复为"第一版内容"

2. 更复杂的实现（支持多个属性）

复制代码

// 游戏角色状态
public class GameCharacter {
    private int level;
    private int health;
    private String location;
    
    public GameCharacter(int level, int health, String location) {
        this.level = level;
        this.health = health;
        this.location = location;
    }
    
    // 创建备忘录
    public CharacterMemento save() {
        return new CharacterMemento(level, health, location);
    }
    
    // 从备忘录恢复
    public void restore(CharacterMemento memento) {
        this.level = memento.getLevel();
        this.health = memento.getHealth();
        this.location = memento.getLocation();
    }
    
    // 其他方法...
}

// 角色备忘录
public class CharacterMemento {
    private final int level;
    private final int health;
    private final String location;
    
    public CharacterMemento(int level, int health, String location) {
        this.level = level;
        this.health = health;
        this.location = location;
    }
    
    // getter方法
    public int getLevel() { return level; }
    public int getHealth() { return health; }
    public String getLocation() { return location; }
}

四、备忘录模式的应用场景

1. 文本编辑器撤销功能

复制代码

public class AdvancedTextEditor {
    private StringBuilder content;
    private int cursorPosition;
    
    public AdvancedTextEditor() {
        content = new StringBuilder();
        cursorPosition = 0;
    }
    
    public EditorState saveState() {
        return new EditorState(content.toString(), cursorPosition);
    }
    
    public void restoreState(EditorState state) {
        this.content = new StringBuilder(state.getContent());
        this.cursorPosition = state.getCursorPosition();
    }
    
    // 其他编辑方法...
}

public class EditorState {
    private final String content;
    private final int cursorPosition;
    
    public EditorState(String content, int cursorPosition) {
        this.content = content;
        this.cursorPosition = cursorPosition;
    }
    
    // getter方法...
}

2. 游戏存档系统

复制代码

public class GameSaveManager {
    private List<GameSave> savePoints = new ArrayList<>();
    
    public void saveGame(GameWorld world) {
        savePoints.add(world.createSave());
    }
    
    public void loadGame(GameWorld world, int index) {
        if (index >= 0 && index < savePoints.size()) {
            world.restoreFromSave(savePoints.get(index));
        }
    }
}

public class GameWorld {
    private String worldState;
    private PlayerState playerState;
    
    public GameSave createSave() {
        return new GameSave(worldState, playerState);
    }
    
    public void restoreFromSave(GameSave save) {
        this.worldState = save.getWorldState();
        this.playerState = save.getPlayerState();
    }
}

3. 事务回滚机制

复制代码

public class DatabaseTransaction {
    private List<DatabaseMemento> mementos = new ArrayList<>();
    private Database database;
    
    public void begin() {
        mementos.add(database.createMemento());
    }
    
    public void commit() {
        mementos.clear();
    }
    
    public void rollback() {
        if (!mementos.isEmpty()) {
            database.restoreFromMemento(mementos.get(mementos.size() - 1));
            mementos.remove(mementos.size() - 1);
        }
    }
}

五、备忘录模式的变体

1. 增量备忘录

复制代码

public class IncrementalMemento {
    private final Object deltaState; // 只存储变化的部分
    
    public IncrementalMemento(Object delta) {
        this.deltaState = delta;
    }
}

2. 序列化备忘录

复制代码

import java.io.*;

public class SerializationMemento {
    public static byte[] serialize(Object obj) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        return bos.toByteArray();
    }
    
    public static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

六、备忘录模式的优缺点

优点

状态封装：不暴露对象内部细节
简化原发器：状态保存恢复逻辑分离
时间点恢复：可恢复到任意保存点
快照管理：可维护多个状态版本

缺点

内存消耗：保存多个状态可能占用大量内存
性能影响：频繁保存状态可能影响性能
实现复杂：部分对象状态可能难以捕获

七、最佳实践

合理控制快照数量：避免保存过多状态
增量保存：只保存变化的部分
考虑序列化：对于复杂对象使用序列化
清理机制：定期清理过期备忘录
访问控制：限制对备忘录内部状态的访问

八、总结

备忘录模式是状态管理的有效方案，特别适用于：

需要提供撤销/重做功能
需要保存对象历史状态
需要实现事务回滚机制
需要保存系统快照

在实际开发中，备忘录模式常见于：

文本/图像编辑软件
游戏存档系统
数据库事务管理
系统配置管理
工作流状态保存