当前位置:首页 > 开发 > 编程语言 > 正则表达式 > 正文

Memento Design Pattern

发表于: 2013-08-07   作者:cywhoyi   来源:转载   浏览次数:
摘要: Memento pattern is one of the behavioral design pattern. Memento design pattern is used when we want to save the state of an object so that we can restore later on. Memento pattern is used t

Memento pattern is one of the behavioral design pattern. Memento design pattern is used when we want to save the state of an object so that we can restore later on. Memento pattern is used to implement this in such a way that the saved state data of the object is not accessible outside of the object, this protects the integrity of saved state data.

Memento pattern is implemented with two objects – Originator and Caretaker. Originator is the object whose state needs to be saved and restored and it uses aninner class to save the state of Object. The inner class is called Memento and its private, so that it can’t be accessed from other objects.

Caretaker is the helper class that is responsible for storing and restoring the Originator’s state through Memento object. Since Memento is private to Originator, Caretaker can’t access it and it’s stored as a Object within the caretaker.

One of the best real life example is the text editors where we can save it’s data anytime and use undo to restore it to previous saved state. We will implement the same feature and provide a utility where we can write and save contents to a File anytime and we can restore it to last saved state. For simplicity, I will not use any IO operations to write data into file.

Originator Class

01 package com.journaldev.design.memento;
02  
03 public class FileWriterUtil {
04  
05     private String fileName;
06     private StringBuilder content;
07  
08     public FileWriterUtil(String file){
09         this.fileName=file;
10         this.content=new StringBuilder();
11     }
12  
13     @Override
14     public String toString(){
15         return this.content.toString();
16     }
17  
18     public void write(String str){
19         content.append(str);
20     }
21  
22     public Memento save(){
23         return new Memento(this.fileName,this.content);
24     }
25  
26     public void undoToLastSave(Object obj){
27         Memento memento = (Memento) obj;
28         this.fileName= memento.fileName;
29         this.content=memento.content;
30     }
31  
32     private class Memento{
33         private String fileName;
34         private StringBuilder content;
35  
36         public Memento(String file, StringBuilder content){
37             this.fileName=file;
38             //notice the deep copy so that Memento and FileWriterUtil content variables don't refer to same object
39             this.content=new StringBuilder(content);
40         }
41     }
42 }

Notice the Memento inner class and implementation of save and undo methods. Now we can continue to implement Caretaker class.

Caretaker Class

01 package com.journaldev.design.memento;
02  
03 public class FileWriterCaretaker {
04  
05     private Object obj;
06  
07     public void save(FileWriterUtil fileWriter){
08         this.obj=fileWriter.save();
09     }
10  
11     public void undo(FileWriterUtil fileWriter){
12         fileWriter.undoToLastSave(obj);
13     }
14 }

Notice that caretaker object contains the saved state in the form of Object, so it can’t alter its data and also it has no knowledge of it’s structure.

Memento Test Class

Lets write a simple test program that will use our memento implementation.

01 package com.journaldev.design.memento;
02  
03 public class FileWriterClient {
04  
05     public static void main(String[] args) {
06  
07         FileWriterCaretaker caretaker = new FileWriterCaretaker();
08  
09         FileWriterUtil fileWriter = new FileWriterUtil("data.txt");
10         fileWriter.write("First Set of Data\n");
11         System.out.println(fileWriter+"\n\n");
12  
13         // lets save the file
14         caretaker.save(fileWriter);
15         //now write something else
16         fileWriter.write("Second Set of Data\n");
17  
18         //checking file contents
19         System.out.println(fileWriter+"\n\n");
20  
21         //lets undo to last save
22         caretaker.undo(fileWriter);
23  
24         //checking file content again
25         System.out.println(fileWriter+"\n\n");
26  
27     }
28  
29 }

Output of above program is:

1 First Set of Data
2  
3 First Set of Data
4 Second Set of Data
5  
6 First Set of Data

The pattern is simple and easy to implement, one of the thing needs to take care is that Memento class should be accessible only to the Originator object. Also in client application, we should use caretaker object for saving and restoring the originator state.

Also if Originator object has properties that are not immutable, we should use deep copy or cloning to avoid data integrity issue like I have used in above example. We can use Serialization to achieve memento pattern implementation that is more generic rather than Memento pattern where every object needs to have it’s own Memento class implementation.

Memento Design Pattern

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
1.Memento 模式的关键是在不破坏封装的前提下,捕获并保存一个类的内部状态,这样就可以利用该保存
Now, I’m using Microsoft word to write these articles. These word processor programs are ver
Decorator Pattern 1) Motivation: Extending an object's functionality can be done statically (
一个最简单的组合模式的使用例子 1. 问题描述 计算一个网络中的计算机个数(拓扑结构为树型): 2.
模式动机: 1、为了使软件的使用更加人性化,对于误操作,我们需要提供一种类似“后悔药”的机制,
[Design Pattern] Substitute Interface 目的 将对象的成员建立为替身接口的成员,用来解耦对象之间
模板方法模式(Template Method):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。该模式
Do you use design patterns? http://stackoverflow.com/questions/11586/do-you-use-design-patter
Do you use design patterns? http://stackoverflow.com/questions/11586/do-you-use-design-patter
这篇博文是阅读老外写的博文后,自己参照了他的思想实现的PHP版本。若有不足,请善意指正。原文链接
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号