Gof设计模式之备忘录模式 (Memento)

2019独角兽企业重金招聘Python工程师标准>>>

备忘录模式定义：备忘录是一个对象，它保存另一个对象在某一时刻的状态。

备忘录模式功能：在不破坏对象的封装性的前提下，保存对象的某一时刻的内部状态。

不破坏封装性，即不暴露对象不必要的细节。

备忘录模式中涉及的名词与解释。

1、备忘录

备忘录，它是一个封装数据的对象，它保存某一对象的某个时刻的状态，它不同于普通的封装数据的对象，它不应包含多于的细节（方法）。

为了实现对象的封装性，通常备忘录的实现代码放到原发器类中，作为原发器类的内部私有类，只通过原发器对其操作；

2、原发器

原发器，它是我们要用备忘录去保存状态的对象。通过它来操作备忘录，创建和恢复它的某一时刻的备忘录。

3、备忘录管理器

用于缓存备忘录，并且可以缓存多个。

备忘录模式的优缺点

1、优点：

  （1）更好的封装性

     通过备忘录对象保存原发器对象的内部状态，虽然备忘录对象保存在管理器中（外部），但由于通过窄接口的方式实现的备忘录，致使外部对象无法操作原发器对象的内部数据。

  （2）简化了原发器

     备忘录对象被保存在原发器对象外，由客户来管理他们请求的状态，从而简化了原发器对象。

  （3）窄接口与宽接口

     窄接口与宽接口实现了原发器对象在不同的地方有不同的访问方式。原发器外部通过窄接口访问备忘录，保护原发器对象的状态。

     在原发器内部，可以通过宽接口设置备忘录，保存某一时刻的备忘录。

2、缺点

  可以会导致高开销。

  备忘录的基本功能，就是创建、恢复备忘录中的状态，备忘录的基本实现方式就是缓存备忘录对象。

  如果高频率的创建备忘录，或是备忘录中缓存的数据量较大，都会导致高开销。

示例：

示例说明：一个对象初始化后，经过初步处理得到某一状态，用备忘录保存此状态。再用不同的处理，处理此状态。

代码：

1、备忘录的窄接口
public class Memeto{
}

2、备忘录的原发器（备忘录为某一对象保存某一状态，这个对象就是原发器）。
package gof.memeto;

/**
 * @author andy
 * 备忘录的原发器
 */
public class Originator {
 // 原发器名称
 private String name;
 // 原发器某一状态时的值
 private String state;
 // 原发器某一状态时的值
 private String result;

 public Originator(String n) {
 this.name = n;
 }

 /**
  * 初始化原发器，得到要保存的状态
  */
 public void runInit() {
 this.state = "state0";
 this.result = "result0";
 }

 /**
  * 方案1改变保存的状态
  */
 public void runSchema1() {
 this.state += "----state1";
 this.result += "----result1";
 System.out.println("state:" + this.state);
 System.out.println("result:" + this.result);
 }

 /**
  * 方案2改变保存的状态
  */
 public void runSchema2() {
 this.state += "----state2";
 this.result += "----result2";
 System.out.println("state:" + this.state);
 System.out.println("result:" + this.result);
 }

 public Memeto createMemeto() {
 return new MemetoImpl(this.state, this.result);
 }

 public void setMemeto(Memeto m) {
 MemetoImpl mi = (MemetoImpl) m;
 this.state = mi.state;
 this.result = mi.result;
 }

 private static class MemetoImpl implements Memeto {
 // 保存原发器某一状态时的值
 private String state;
 // 保存原发器某一状态时的值
 private String result;

 public MemetoImpl(String s, String r) {
 this.state = s;
 this.result = r;
 }

 /**
  * @return the state
  */
 public String getState() {
 return state;
 }

 /**
  * @return the result
  */
 public String getResult() {
 return result;
 }

 }
}

3、备忘录的管理者
package gof.memeto;

/**
 * @author andy
 * 备忘录的管理者
 */
public class MemetoCareTaker {
 private Memeto memeto = null;

 public void savaMemeto(Memeto memeto) {
 this.memeto = memeto;
 }

 public Memeto retriveMemeto() {
 return memeto;
 }

}

4、测试Main方法
package gof.memeto;

public class Main {

 /**
  * @param args
  */
 public static void main(String[] args) {
 // 原发器
 Originator ori = new Originator("memeto test");
 // 初始化原发器
 ori.runInit();
 
 // 备忘录的管理者
 MemetoCareTaker mct = new MemetoCareTaker();
 mct.savaMemeto(ori.createMemeto());
 
 // 运行方案1
 ori.runSchema1();
 
 // 不用备忘录恢复状态，运行方案2
 ori.runSchema2();
 
 // 用备忘录恢复状态，运行方案2
 ori.setMemeto(mct.retriveMemeto());
 ori.runSchema2();
 }

}

转载于:https://my.oschina.net/andylucky/blog/38562