行为型-备忘录模式

概述

备忘录模式（Memento Pattern）在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

适用场景

• 需要保存/恢复数据的相关状态场景
• 提供一个可回滚的操作
• 需要监控的副本场景

角色组成

• Originator（发起人）：记录当前时刻的内部状态，负责创建和恢复备忘录
• Memento（备忘录）：负责存储发起人对象的内部状态
• Caretaker（管理者）：负责保存备忘录，不能对备忘录内容进行操作

代码实现

1. 备忘录

public class Memento {
    private String state;
    
    public Memento(String state) {
        this.state = state;
    }
    
    public String getState() {
        return state;
    }
}

2. 发起人

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 restoreMemento(Memento memento) {
        this.state = memento.getState();
    }
}

3. 管理者

public class Caretaker {
    private List<Memento> mementos = new ArrayList<>();
    
    public void addMemento(Memento memento) {
        mementos.add(memento);
    }
    
    public Memento getMemento(int index) {
        return mementos.get(index);
    }
    
    public Memento getLastMemento() {
        if (mementos.isEmpty()) {
            return null;
        }
        return mementos.get(mementos.size() - 1);
    }
}

4. 客户端

public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        
        // 设置状态并保存
        originator.setState("状态1");
        System.out.println("当前状态: " + originator.getState());
        caretaker.addMemento(originator.createMemento());
        
        originator.setState("状态2");
        System.out.println("当前状态: " + originator.getState());
        caretaker.addMemento(originator.createMemento());
        
        originator.setState("状态3");
        System.out.println("当前状态: " + originator.getState());
        
        // 恢复到状态1
        originator.restoreMemento(caretaker.getMemento(0));
        System.out.println("恢复后状态: " + originator.getState());
    }
}

# 输出
当前状态: 状态1
当前状态: 状态2
当前状态: 状态3
恢复后状态: 状态1

类图

实际案例：文本编辑器撤销

// 编辑器状态
public class EditorMemento {
    private final String content;
    
    public EditorMemento(String content) {
        this.content = content;
    }
    
    public String getContent() {
        return content;
    }
}

// 编辑器
public class TextEditor {
    private StringBuilder content = new StringBuilder();
    
    public void write(String text) {
        content.append(text);
    }
    
    public String getContent() {
        return content.toString();
    }
    
    public EditorMemento save() {
        return new EditorMemento(content.toString());
    }
    
    public void restore(EditorMemento memento) {
        content = new StringBuilder(memento.getContent());
    }
}

// 历史记录
public class History {
    private Stack<EditorMemento> history = new Stack<>();
    
    public void push(EditorMemento memento) {
        history.push(memento);
    }
    
    public EditorMemento pop() {
        return history.pop();
    }
}

优缺点

优点：

• 给用户提供了一种可以恢复状态的机制
• 实现了信息的封装

缺点：

• 消耗资源，如果类的成员变量过多，会占用较大的资源