Memento Design Pattern

By Sidd Bhattacharjee -

Type : Behavioral Design Pattern

Summary

Memento design pattern is used when we want to save the state of an object so that we can restore later on.

Advantages

The memento pattern provides a way of recording the internal state of an object in a separate 
object. 

Memento design pattern removes need for multiple creation of the same object for the sole purpose of saving its state. 

The memento simplifies the Originator since the responsibility of managing Memento storage is no longer centralized at the Originator but rather distributed among the Caretakers.

Disadvantages

As the Memento object stores the data of the Originator object, it generally copies the fields that represents state of the originator. Changes in the Originator object could force to change the memento object also.

Details

Memento design pattern is used when we want an option to to get previous state or restore previous version of objects. It has three key components

Originator : It is the object which can change and we want the previous state to be preserved.
Caretaker : It is the helper class that is responsible for storing and restoring the state of the Originator’s state through Memento object.
Memento : It stores internal state of the Originator, it can be an inner class to originator class

Caretaker is at the central of this pattern, only the caretaker object knows about the internal details of the memento object. Memento object is not known to the outside world. Memento object is sufficiently designed so that it can hold the key properties of the originator object.

For example lets consider a Blogpage object which contains some attributes like title, content etc. When the editor edits the blogpage its content gets changed and let's say we want to maintain the previous version of the blogpage. So that we can support undo operations if needed.

Here BlogContent class is the Originator whose state we want to save
Memento object is the object which stores a specific originator instance
Caretaker is the map which holds various versions of the BlogContent object.

Class Diagram


Sample Code


// memento object holding the contents of Originator
public class Memento {

  private String blogTitle;
  private String blogContent;
  private int version;

  public Memento(String t, String c, int v) {
    this.blogTitle = t;
    this.blogContent = c;
    this.version = v;
  }

  public BlogContent getSavedState() {
    return new BlogContent(blogTitle, blogContent);
  }

  public int getVersion() {
    return version;
  }

}


// originator object
public class BlogContent {

  private String blogTitle;
  private String blogContent;
  private int version = 0;

  public BlogContent() {}

  public void write(String bT, String bC) {
    this.blogTitle = bT;
    this.blogContent = bC;
    this.version++;
  }

  public Memento saveToMemento() {
    System.out.println("Originator: Saving to Memento.");
    return new Memento(this.blogTitle, this.blogContent, this.version);
  }

  public BlogContent restoreFromMemento(Memento m) {
    BlogContent state = m.getSavedState();
    this.blogTitle = state.blogTitle;
    this.blogContent = state.blogContent;
    return state;
  }

}

// caretake object
public class CareTaker {

  private Map savedStates = new HashMap();

  public void addMemento(Memento m) {
    savedStates.put(m.getVersion(), m);
  }

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

}

Comments

Post a Comment

Popular posts from this blog

Difference between volatile and synchronized

By -
volatile is a field modifier, while synchronized modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords: int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() accesses the value currently stored in i1 in the current thread . Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1 in it's thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a "main" memory, and this is the memory that holds the current "correct" value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the "main" memory. So in fact, it is possible for the "main...
Read more

Converting Java Map to String

By -
Java Collections framework, String manipulation etc is something that we often encounter in Development process. For processing collections (like checking null/empty, Intersection, Disjunction) We do have some of the very use full libraries. Some of the Collection related libraries are Apche Commons Collections and Google  Collections(Guava). Problem Use Case This article explains how to convert a Java Map to String(and vice versa) using different libraries and technique. One way is to use StringBuilder(Or String) and loop though the Map and build the String by applying some sort of separator ( for key:value and entry). Here we have to take care of the null value etc. Without Any Library If we want to convert the map to a String with key value separator and also individual entry seperator in the resulting String, we have to write code for that. For a simple Map, we have to iterate though the map, take care of the null values etc. Following is...
Read more

Masking Credit Card number in Java

By -
Sometimes we need to mask crucial information like Credit Card Numbers, CVV numbers etc before storing  or logging the information. This example mask Credit Card Number (Except last 4 Digit) from a Text which contains information along with Credit Card Number. The following example demonstrates how we can easily mask the credit card with Matcher and Pattern Classes. This Sample Code uses Matcher and Pattern. Pattern Used in this sample is not optimized for Credit Card Numbers, this pattern will get any numerical numbers in the String Content.  Based on the Credit Card Type a more efficient and Strict RegEx can be used to mask the Credit Card. /**Mask the Credit card number but last four digit value **/   Pattern PATTERN = Pattern.compile( "[0-9]+" ); String message = content; Matcher matcher = PATTERN.matcher(message); String maskingChar = "*"; StringBuilder finalMask = new StringBuilder(maskingChar...
Read more