Java实现备忘录模式

一、简介

1、定义

  备忘录模式 (Memento Pattern) 又称为快照模式，是一种行为型设计模式，它提供了一种保存和恢复对象状态的机制。它允许在不破坏封装性的前提下，捕获一个对象（发起人）的内部状态，并在该对象之外（管理者）保存这个状态（备忘录），以便以后需要的时候，能将该对象（发起人）恢复到原先的状态（备忘录）。

2、备忘录模式的结构

备忘录模式涉及以下几个角色：
发起人 (Originator)：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能。
备忘录 (Memento)：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
管理者 (Caretaker) ：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。
客户端(Client)：初始化发起人、管理者，给发起人设置状态，发起人通过管理者保存当前的状态、恢复到之前的状态。

二、Java实现案例

1、发起人通过管理者的备忘录恢复到之前状态

/**
 * @Description: 发起人  保存状态、获取状态，获取当前状态的备忘录，将当前状态恢复到备忘录的状态
 * @Date: 2025-01-21 9:38
 * @Author: gaoyufei
 **/
public class Originator {
    private String state;
    public void setState(String state){
        this.state=state;
    }
    public String getState(){
        return state;
    }
    public Memento getCurrentMemento(){
        return new Memento(state);
    }
    public void setStateFromMemento(Memento memento){
        this.state=memento.getState();
    }
}
/**
 * @Description: 备忘录 保存状态 获取状态
 * @Date: 2025-01-21 9:36
 * @Author: gaoyufei
 **/
public class Memento {
    private String state;
    public Memento(String state){
        this.state=state;
    }
    public String getState(){
        return state;
    }
}

/**
 * @Description: 管理者 持有备忘录，可以设置和获取备忘录
 * @Date: 2025-01-21 9:40
 * @Author: gaoyufei
 **/
public class CareTaker {
    private Memento memento;
    public Memento getMemento(){
        return this.memento;
    }
    public void setMemento(Memento memento){
        this.memento=memento;
    }
}

/**
 * @Description: 客户端 初始化发起人、管理者，给发起人设置状态，发起人通过管理者保存当前的状态、恢复到之前的状态
 * @Date: 2025-01-21 9:41
 * @Author: gaoyufei
 **/
public class Client {
    public static void main(String[] args) {
        //发起人
        Originator originator=new Originator();
        //管理者
        CareTaker careTaker=new CareTaker();
        originator.setState("State1");
        careTaker.setMemento(originator.getCurrentMemento());
        originator.setState("State2");
        System.out.println("Current State:"+originator.getState());
        originator.setStateFromMemento(careTaker.getMemento());
        System.out.println("Restored State:"+originator.getState());
    }
}

2、编辑器

用户在编辑器中输入文本，进行编辑操作。可以实现撤销和恢复功能，即用户可以撤销之前的编辑操作，并恢复到之前的状态。

/**
 * @Description: 备忘录接口
 * @Date: 2025-01-21 13:07
 * @Author: gaoyufei
 **/
public interface Memento {
}
/**
 * @Description: 编辑器，相当于发起人，保存和获取的编辑器内容，
 * 并提供了创建备忘录和从备忘录恢复内容的方法
 * @Date: 2025-01-21 11:07
 * @Author: gaoyufei
 **/
public class Editor {
    private String text;
    public void setText(String text){
        this.text=text;
    }
    public String getText(){
        return this.text;
    }
    public Memento getCurrentEditorMemento(){
        return new EditorMemento(this.text);
    }
    public void recoverFromEditorMemento(Memento memento){
        EditorMemento editorMemento=(EditorMemento)memento;
        this.text=editorMemento.getText();
    }

    /**
     * @Description: 编辑器备忘录 保存编辑器的内容
     * @Date: 2025-01-21 11:03
     * @Author: gaoyufei
     **/
    private class EditorMemento implements Memento{
        private String text;
        public EditorMemento(String text){
            this.text=text;
        }
        public String getText(){
            return this.text;
        }
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * @Description: 历史记录，相当于管理者，存储和恢复编辑器历史备忘录对象，可以撤销到上一步、恢复撤销、获取指定的备忘录对象
 * @Date: 2025-01-21 11:05
 * @Author: gaoyufei
 **/
public class HistoryRecord {
    private List<Memento> mementos;
    private int index;
    public HistoryRecord(){
        mementos=new ArrayList<>();
        index=-1;
    }
    public void addEditorMemento(Memento memento){
        this.mementos.add(memento);
        this.index++;
    }
    public Memento getBeforeEditorMemento(){
        if(index<=0){
            return this.mementos.get(0);
        }
        index--;
        return this.mementos.get(index);
    }
    public Memento getAfterEditorMemento(){
        index++;
        if(index>=mementos.size()){
            return this.mementos.get(mementos.size()-1);
        }
        return this.mementos.get(index);
    }
    public Memento getEditorMementoByIndex(int index){
        return this.mementos.get(index);
    }
}

/**
 * @Description: 用户 相当于客户端，操作编辑器，并可以撤销、恢复到不同的历史版本
 * @Date: 2025-01-21 11:22
 * @Author: gaoyufei
 **/
public class Person {
    public static void main(String[] args) {
        Editor editor=new Editor();
        HistoryRecord historyRecord=new HistoryRecord();
        // 用户在编辑器输入内容
        editor.setText("Version 1.0");
        // 获取备忘录对象并保存到历史记录
        historyRecord.addEditorMemento(editor.getCurrentEditorMemento());
        editor.setText("Version 2.0");
        historyRecord.addEditorMemento(editor.getCurrentEditorMemento());
        editor.setText("Version 3.0");
        historyRecord.addEditorMemento(editor.getCurrentEditorMemento());
        System.out.println("编辑器当前内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getBeforeEditorMemento());
        System.out.println("编辑器撤销一步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getBeforeEditorMemento());
        System.out.println("编辑器撤销二步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getBeforeEditorMemento());
        System.out.println("编辑器撤销三步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getAfterEditorMemento());
        System.out.println("编辑器前进一步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getAfterEditorMemento());
        System.out.println("编辑器前进二步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getAfterEditorMemento());
        System.out.println("编辑器前进三步内容:"+editor.getText());
        editor.recoverFromEditorMemento(historyRecord.getEditorMementoByIndex(1));
        System.out.println("编辑器第二版本内容:"+editor.getText());
    }
}