Memento Design Pattern Example

The word 'memento' refers to an object that is kept as a reminder or souvenir of a person or event. Memento pattern is a behavioral pattern in GoF, as it captures and externalizes an object's internal state. This allows the object to be restored to its previous state at a later time.

source: GoF

overview

The Memento is a class that represents a snapshot of an object's state and contains the state to be restored to an Originator. You can access the state encapsulated in a Memento by using its get and set methods.

The Originator has a member function that creates and return a Memento with the current state of the Originator stored in the returned Memento. Originator also has a member function that sets its current state with the state of a given Memento object. In other words, it can create snapshot (Memento), or restore the state to the given snapshot (Memento).

The Caretaker class is a helper class that is responsible for storing and restoring the state of one Originator through Memento objects. A Caretaker object holds and maintains Mementos, but never modifies them. The Caretaker class is responsible for the safekeeping of Mementos. For example, a Caretaker encapsulates a list of Mementos that can be added to or retrieved from the list.

memento code example

Memento class:

public class Memento {
  private String state;

  public Memento(String state){
    this.state = state;
  }

  public String getState(){
    return state;
  }
}

Originator class:

public class Originator {
   private String state;

   public void setState(String state){
      this.state = state;
   }

   public String getState(){
      return state;
   }

   public Memento createMemento(){           // return a current snapshot
      return new Memento(state);
   }

   public void setMemento(Memento Memento){  // restore from a snapshot
      state = Memento.getState();
   }
}

Caretaker class:

public class Caretaker {
   private List<Memento> mementoList = new ArrayList<Memento>();

   public void add(Memento state){
      mementoList.add(state);
   }

   public Memento get(int index){
      return mementoList.get(index);
   }
}

main():

public class MementoPatternDemo {
   public static void main(String[] args) {
   
      Originator originator = new Originator();
      Caretaker caretaker = new Caretaker();
      
      originator.setState("State #1");
      originator.setState("State #2");
      caretaker.add(originator.createMemento()); // take/save a current snapshot
      
      originator.setState("State #3");
      caretaker.add(originator.createMemento()); // take/save a current snapshot
      
      originator.setState("State #4");
      System.out.println("Current State: " + originator.getState());
      
      originator.setState(caretaker.get(0));
      System.out.println("First saved State: " + originator.getState());
      originator.setState(caretaker.get(1));
      System.out.println("Second saved State: " + originator.getState());
   }
}

Output:

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

when to use memento

• Need an undo and restore mechanism.
• Database rollback. To be able to rollback, have the Originator create a snapshot (memento) before performing an operation and thus in case of failure, the memento object would be used to restore the Originator to its previous state.
• Want to simplify Originator code so it does not need to keep track of its previous state by moving such responsibility to the Caretaker code.

comparison

Memento vs Command

• Both can act as magic tokens to be passed around and invoked at a later time.
• ​In Command, the token represents a request; in Memento, it represents the internal state of an object at a particular time.
• Both can support muti-level undos.
• Memento pattern's capturing and restoring object state is more expensive then Command patterns for Undo/Redo functionality.

Memento vs Temporal Collection

• The memento is a kind of snapshot implementation with help of an external Caretaker class as the Temporal Collection
• Fowler's Snapshot pattern has a Originator (which I call it a Snapshot Parent) class references Temporal Collection(s) without utilizing an external Caretaker class.

references

• Memento Pattern
• Multilevel Undo and Redo Implementation in C# - Part III (Using Memento Pattern)​