Achieve Ultimate Excellence

Memento Design Pattern - Capture and Restore the internal State of an Object

5 min read

Introduction

In software design, there are various design patterns that help us create flexible, maintainable, and reusable code. One such pattern is the "Memento design pattern." The Memento pattern is a behavioral pattern that allows us to capture and restore the internal state of an object without exposing its implementation details. This blog post will delve into the Memento pattern, explaining its concept, structure, and implementation in Java, along with a practical example.

Understanding the Memento Pattern

The Memento pattern follows the principle of encapsulation, which is one of the core principles of object-oriented programming. It is often used to implement undo/redo functionality or to provide snapshots of an object's state for later restoration. The pattern consists of three main components:

1. Originator

This is the object whose state we want to save or restore. The Originator creates a Memento object to save its state and uses it to restore the state later if needed.

2. Memento

The Memento is a simple data container that stores the state of the Originator. It should have methods to get and set the state without exposing any internal details of the Originator.

3. Caretaker

The Caretaker is responsible for holding and managing the Memento objects. It requests a Memento from the Originator to save the state and returns it to the Originator for state restoration when required.

Implementation of Memento Pattern in Java

Let's now demonstrate the Memento pattern with a simple example. We'll create a basic text editor that allows users to write and edit text. The editor will have an undo feature, which will use the Memento pattern to revert to previous states of the text.

Step 1: Create the Memento - TextEditorMemento

public class TextEditorMemento {
    private final String state;

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

    public String getState() {
        return state;
    }
}

Step 2: Create the Originator - TextEditor

public class TextEditor {
    private String text;

    public TextEditor() {
        this.text = "";
    }

    public void write(String text) {
        this.text += text;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public TextEditorMemento save() {
        return new TextEditorMemento(text);
    }

    public void restore(TextEditorMemento memento) {
        this.text = memento.getState();
    }
}

Step 3: Create the Caretaker - History

import java.util.Stack;

public class History {
    private Stack mementos = new Stack<>();

    public void push(TextEditorMemento memento) {
        mementos.push(memento);
    }

    public TextEditorMemento pop() {
        return mementos.pop();
    }
}

Step 4: Test the implementation

public class Main {
    public static void main(String[] args) {
        TextEditor textEditor = new TextEditor();
        History history = new History();

        // Write some text and save the state
        textEditor.write("Hello, ");
        history.push(textEditor.save());

        textEditor.write("world!");
        System.out.println("Current text: " + textEditor.getText());

        // Undo to the previous state
        textEditor.restore(history.pop());
        System.out.println("Undone text: " + textEditor.getText());
    }
}

Explanation

In this example, we created a simple TextEditor class, which acts as the Originator. The TextEditor has methods to write text and get/set the current text. It also provides a save() method to create a TextEditorMemento and store the current state.

The TextEditorMemento class is the Memento, which simply stores the state (text) of the TextEditor. The History class acts as the Caretaker and manages a stack of TextEditorMementos. It provides methods to push a new Memento onto the stack and pop the top Memento when needed.

In the Main class, we create an instance of the TextEditor and the History. We write some text to the TextEditor and save its state using the push() method. After writing more text, we use the restore() method to undo the changes and revert to the previous state.

Conclusion

The Memento design pattern provides an elegant solution for capturing and restoring an object's state without violating encapsulation. By applying the Memento pattern, you can implement features like undo/redo functionality, version control systems, or any scenario where you need to save and restore object states. As demonstrated in the example above, the Memento pattern helps create more flexible and maintainable code, enhancing the overall design of your applications.

Article By,