备忘录模式定义

  • ①：备忘录模式，是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。
  • ②：备忘录模式属于行为型模式。
  • ③：给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。
  • 实现了信息的封装，使得用户不需要关心状态的保存细节。

备忘录模式类图

  • Originator：原始对象
  • Caretaker：负责保存好备忘录
  • Memento：备忘录，存储原始对象的状态。
    备忘录实际上有两个接口：
    • ①：一个是提供给Caretaker的窄接口：它只能将备忘录传递给其它对象；
    • ②：一个是提供给Originator的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许Originator访问本备忘录的内部状态。

备忘录模式 - 图1

Originator创建并在Memento对象中存储状态：

  1. /*`Originator`创建并在`Memento`对象中存储状态*/
  2. public class Originator {
  3.     private String state;
  5.     public void setState(String state) {
  6.         this.state = state;
  7.     }
  9.     public String getState() {
  10.         return state;
  11.     }
  13.     /*保存`Originator`的状态到`Memento`*/
  14.     public Memento saveStateToMemento() {
  15.         return new Memento(state);
  16.     }
  18.     /*`Originator`从`Memento`获取之前保存的状态，并进行回滚*/
  19.     public void recoveryStateFromMemento(Memento Memento) {
  20.         state = Memento.getState();
  21.     }
  22. }

Memento包含了要被恢复的Originator状态：

  1. /*`Memento`包含了要被恢复的`Originator`状态*/
  2. public class Memento {
  3.     private String state;
  5.     public Memento(String state) {
  6.         this.state = state;
  7.     }
  9.     public String getState() {
  10.         return state;
  11.     }
  12. }

Caretaker负责保存Memento，是一个仓库：

  1. /*`Caretaker`负责保存`Memento`，是一个仓库*/
  2. public class CareTaker {
  3.     private List<Memento> mementoList = new ArrayList<Memento>();
  5.     public void add(Memento state){
  6.         mementoList.add(state);
  7.     }
  9.     public Memento get(int index){
  10.         return mementoList.get(index);
  11.     }
  12. }

客户端调用：

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         CareTaker careTaker = new CareTaker();
  4.         Originator originator = new Originator();
  5.         originator.setState("State #1");
  6.         originator.setState("State #2");
  7.         careTaker.add(originator.saveStateToMemento()); /*保存当前的状态*/
  8.         originator.setState("State #3");
  9.         careTaker.add(originator.saveStateToMemento()); /*保存当前的状态*/
  10.         originator.setState("State #4");
  11.         System.out.println("Current State: " + originator.getState());
  13.         originator.recoveryStateFromMemento(careTaker.get(0)); /*恢复之前指定的具体某个状态*/
  14.         System.out.println("First saved State: " + originator.getState());
  15.         originator.recoveryStateFromMemento(careTaker.get(1)); /*恢复之前指定的具体某个状态*/
  16.         System.out.println("Second saved State: " + originator.getState());
  17.     }
  18. }

输出内容如下：

  1. Current State: State #4
  2. First saved State: State #2
  3. Second saved State: State #3