Design Patterns -- Memento_think in pattern memento模式-CSDN博客

本文链接：https://blog.csdn.net/dr2tr/article/details/1006226

The intent of the Memento Pattern is to provide storage and restoration of an object's state. In Design Patterns(GoF) , the intent of the Memento Pattern is stated as "Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later". A memento is a tiny repository that saves an object's state. see UML:

some description:

Memento (Memento)
- stores internal state of the Originator object.
- protect against access by objects of other than the originator. Mementos have effectively two interfaces. Caretaker can only pass the memento to the other objects. And ideally, only the originator that produces the memento would be permitted to access the memento's internal state.
Originator (SalesProspect)
- creates a memento containing a snapshot of its current internal state.
- uses the memento to restore its internal state
Caretaker (Caretaker)
- is responsible for the memento's safekeeping
- never operates on or examines the contents of a memento.

The object(memento) which is to be persisted across session(object seralization) should implement Serializable interface and the some fields initialed from files(like images) can be decleared as transient to so that these fields needn't to be saved when persistance.

On the other hand, memento can be persisted using String. This is suitable for the context that data should be able to be modified outside the system.

At last , the words below are referred:"

Rules of thumb

If you only need one Memento, combine the Originator and Caretaker into one object (Brown, 1998) .
If you need many Mementos, store only incremental changes (Brown, 1998) . This will help to save space.
Memento often used in conjunction with Command, Iterator and Singleton.
Implementation of the Memento design pattern varies depending on the programming language. Implement the Originator as a friend class to the Memento in C++. Implement the Memento as an inner-class of the Originator in Java (Achtziger, 1999) .