Memento Pattern

Memento Pattern (Memento Pattern), also known as Snapshot Pattern (Snapshop Pattern), is a behavioral pattern.

What is the memo pattern?

The memento pattern (Memento Pattern) saves a certain state of an object so that the object can be restored at an appropriate time. (regret drug mode)

UML

Role

• Originator role: responsible for organizing the whole process of the memorandum, and backing up and restoring data by creating and importing memos.
• Memento role: responsible for storing the internal state of the initiating role object, and preventing objects other than the corresponding initiating role from accessing the memento. The memo has two interfaces, and the manager can only see the narrow interface of the memo, and it can only pass the memo to other objects. The initiator is able to see a wide interface allowing it to access all the data needed to return to the previous state.
• Manager (Caretaker): responsible for saving the Memento, and cannot operate or check the content of the Memento.

application

use template

public class MementoPattern {
    public static void main(String[] args) {
        //Create a manager to manage saved memos
        Caretaker caretaker = new Caretaker();
        //Create initiator
        Originator originator = new Originator();
        //Set the status of the initiator
        originator.setState("A");
        originator.print();
        System.out.println("Revise");
        caretaker.setMemento(originator.createMemento());
        originator.setState("B");
        originator.print();
        System.out.println("revoke");
        //perform undo
        originator.restoreMemento(caretaker.getMemento());
        originator.print();
    }
}

/
//Initiator
class Originator {
    //properties to save
    private String state;
    public String getState() { return state; }
    public void setState(String state) { this.state = state; }

    //create memo
    public Memento createMemento() { return new Memento(state); }
    //Restore the memo, import Memento and restore related data
    public void restoreMemento(Memento memento) { this.state = memento.getState(); }

    //Display Data
    public void print() { System.out.println("state = " + getState()); }
}
/
//memorandum
class Memento {
    //Memo data (memo data can be complex data)
    private String state;
    //Import data on creation
    public Memento(String state) { this.state = state; }
    //retrieve data
    public String getState() { return state; }
}

/
//manager
class Caretaker {
    //Memo object (more memo data can be saved through some data structures)
    private Memento memento;
    //get memo
    public Memento getMemento() { return memento; }
    //set memo
    public void setMemento(Memento memento) { this.memento = memento; }
}

Why use the memento pattern?

Capture the internal state of an object and save that state outside the object without breaking encapsulation.

advantage:

• Encapsulation of information is achieved, so that users do not need to care about the details of state preservation.
• Provide users with a mechanism that can restore the state, allowing users to return to a certain historical state more conveniently.

shortcoming:

• If there are too many member variables or snapshots, relatively large resources will be occupied.

How to use memo mode?

scenes to be used

• Undo operation: save/restore data related business scenarios;
  For example: when writing a document in Word, if you want to undo the previous input/delete operation, use Ctrl + Z to perform the undo operation;
• State recovery: when "regret", restore the object to the previous state;
  Such as: archive use in the game;

Use in JDK

java.util.Date

When using the constructor Date(long date), this part of the data is backed up by passing in a piece of data.

The class itself that calls this constructor not only plays the role of initiator, but also plays the role of manager.

And this class corresponds to the role of memo.

public class Date
    implements java.io.Serializable, Cloneable, Comparable<Date>
{
    // used to store state
    private transient long fastTime;
    //constructor, save time
    public Date(long date) {
        fastTime = date;
    }
}