在Java中实现Memento Pattern的不同方式 [英] Different ways to implement the Memento Pattern in Java

问题描述

我正在对Memento模式进行一些研究，似乎我遇到的大多数示例似乎都是相似的（将String保存到数组中并在需要时还原它）现在如果我错了就纠正我我相信我刚刚描述的方法是对象克隆，但是实现美图形式的其他方法是什么？

从我也已经在序列化中获得被使用，但似乎有一个灰色的地方，人们说它违反了对象的封装，并不是一种方法来实现对于纪念图案由于这个。

谢谢

解决方案

Java Collections框架定义了 Queue ，这可以帮助。

候选代码：

  public final class Memento< T> 
 {
 //保存值列表
 private final Queue< T> queue = new ArrayDeque< T>（）; 
 
 //最后输入的值，是否已保存
 private T currentValue; 
 
 //没有初始状态，即currentValue在构造时将为空，因此
 //无构造函数
 
 //设置值，不保存
 public void set（final T value）
 {
 currentValue = value; 
} 
 
 //保持当前保存的值
 public void persist（）
 {
 queue.add（currentValue）; 
} 
 
 //返回最后保存的值
 public T lastSaved（）
 {
 return queue.element（）; 
} 
 
 //返回最后输入的值
 public T lastEntered（）
 {
 return currentValue; 
} 
} 
  

从这段代码中值得注意的是很多东西，但是轻松实现：

• 还原到上次保存的值;


• 不检查nulls; li>
  
• T 不实现可序列化;


• 方便方法（例如添加一个值，使之成为最后保存的状态）;


• 代码不是线程安全的！

等等。

示例代码：

  public static void main（final String ... args）
 {
 final Memento< String> memento = new Memento< String>（）; 
 
 memento.set（state1）; 
 System.out.println（memento.lastEntered（））; //state1
 memento.persist（）; 
 memento.set（state2）; 
 System.out.println（memento.lastEntered（））; //state2
 System.out.println（memento.lastSaved（））; //state1
} 
  

实际上，这是一个脑电图实现，可以改进，但可用作基础 - 扩展它取决于您的需要;）

I am doing some research into the Memento Pattern and it seems that most of the examples I have come across seem to be relatively similar (Saving a String into an array and restoring it when needed) now correct me if I am wrong but I believe the method that i just described is "Object Cloning" but what are the other ways of implementing the Memento Pattern?

From what I have also picked up on Serialization can be used but there seems to be a grey area with people saying that it violates the encapsulation of the object and isn't a way to implement to Memento Pattern due to this.

So will anybody be able to shed some light on the ways to implement the pattern? My research has came up with a sort of mixture of all different things and has just made everything confusing.

Thanks

解决方案

The Java Collections framework defines Queue, which can help.

Candidate code:

public final class Memento<T>
{
    // List of saved values
    private final Queue<T> queue = new ArrayDeque<T>();

    // Last entered value, whether it has been saved or not
    private T currentValue;

    // No initial state, ie currentValue will be null on construction, hence
    // no constructor

    // Set a value, don't save it
    public void set(final T value)
    {
        currentValue = value;
    }

    // Persist the currently saved value
    public void persist()
    {
        queue.add(currentValue);
    }

    // Return the last saved value
    public T lastSaved()
    {
        return queue.element();
    }

    // Return the last entered value
    public T lastEntered()
    {
        return currentValue;
    }
}

Notably missing from this code are many things, but are easily implementable:

• revert to the last saved value;
• no check for nulls;
• T does not implement Serializable;
• convenience method (like, add a value and make it the last saved state);
• code is not thread safe!

Etc.

Sample code:

public static void main(final String... args)
{
    final Memento<String> memento = new Memento<String>();

    memento.set("state1");
    System.out.println(memento.lastEntered()); // "state1"
    memento.persist();
    memento.set("state2");
    System.out.println(memento.lastEntered()); // "state2"
    System.out.println(memento.lastSaved()); // "state1"
}

In effect: this is a braindead implementation which can be improved, but which can be used as a basis -- extending it depends on your needs ;)

这篇关于在Java中实现Memento Pattern的不同方式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！