设计模式_备忘录模式

Mememento Pattern 

     Without violating encapsulation,capture and externalize an object's internal state so that the object can be restored to this state later.(在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可将该对象恢复到原先保存的状态。)

又称Tonken模式

不认识的单词

violating  违反，亵渎

externalize  给…以外形，使客观化，使具体化 

internal  国内的；内部的；体内的；内心的 

1) 备忘录（Memento）角色：备忘录角色存储“备忘发起角色”的内部状态。“备忘发起角色”根据需要决定备忘录角色存储“备忘发起角色”的哪些内部状态。为了防止“备忘发起角色”以外的其他对象访问备忘录。备忘录实际上有两个接口，“备忘录管理者角色”只能看到备忘录提供的窄接口——对于备忘录角色中存放的属性是不可见的。“备忘发起角色”则能够看到一个宽接口——能够得到自己放入备忘录角色中属性。 

2) 备忘发起（Originator）角色：“备忘发起角色”创建一个备忘录，用以记录当前时刻它的内部状态。在需要时使用备忘录恢复内部状态。

3) 备忘录管理者（Caretaker）角色：负责保存好备忘录。不能对备忘录的内容进行操作或检查。

带目的去看问题往往会很清晰。

public class Originator {
 private String state="";
 
 public void changeState(){
  this.state="maybe not so good";
 }
 public String getState() {
  return state;
 }
 public void setState(String state) {
  this.state = state;
 }
 
 public Memento createMemote(){
  return new Memento(this.state);
 }
 
 public void restoreMomoto(Memento _memoto){
  this.setState(_memoto.getState());
 }
}

public class Memento {
 private String state="";
 
 public Memento(String _state) {
  this.state=_state;
 }
 public String getState() {
  return this.state;
 }
 
}

public class Caretaker {
 private Memento memoto;
 
 public Memento getMemoto(){
  return memoto;
 }
 
 public void setMemoto(Memento memoto){
  this.memoto=memoto;
 }
}

public class Client {
 
 public static void main(String[] args) {
  Originator orihinator=new Originator();	 //发起人
  Caretaker caretaker=new Caretaker();  	 //备忘录管理者，不能改变内容
  orihinator.setState("It's so good");	 //设置状态
  caretaker.setMemoto(orihinator.createMemote());  //创建备份点
  orihinator.changeState();                        //改变状态
  orihinator.restoreMomoto(caretaker.getMemoto());  //恢复至备份点
 }
}
/*
 *  这样看来，Memoto备忘录就是一个JavaBean，存储数据。
 *  为什么还需要Caretaker？ 为了不违背迪米特原则，只和朋友类交流，备份类不是朋友，系统需求只是在某个点创建备份
 *  所以备忘录管理类就出来了，看起来又是一个JavaBean，在备忘录之上又包装了一层，麻烦，但是这样结构清晰了许多
 *  发起人不需要和备份类交流
 *  
 *  例子 ：  网站   ->　浏览器　－> cookie -> 网站...  
 *  用户发送一个请求给服务器，服务器会创建一个相对应的session对象，发送数据至浏览器并设置cookie，在一段时间里
 *  用户可以访问服务器，服务器可以根据sessionID来判断是哪个session对象
 */

多状态备份 

在发起人中成员属性多个状态，在备忘录类就是一个hashMap，存放多个状态，通过BeanUtils工具类注入参数和返回参数。 

public class BeanUtils {
//把bean的所有属性及数值放入到Hashmap中
public static HashMap<String,Object> backupProp(Object bean){
HashMap<String,Object> result = new HashMap<String,Object>();
try {
//获得Bean描述
BeanInfo beanInfo=Introspector.getBeanInfo(bean.getClass());
//获得属性描述
PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();
//遍历所有属性
for(PropertyDescriptor des:descriptors){
//属性名称
String fieldName = des.getName();
//读取属性的方法
Method getter = des.getReadMethod();
//读取属性值
Object fieldValue=getter.invoke(bean,new Object[]{});
if(!fieldName.equalsIgnoreCase("class")){
result.put(fieldName, fieldValue);
}
}
} catch (Exception e) {
//异常处理
}
return result;
}
//把HashMap的值返回到bean中
public static void restoreProp(Object bean,HashMap<String,Object> propMap){
try {
//获得Bean描述
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//获得属性描述
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
//遍历所有属性
for(PropertyDescriptor des:descriptors){
//属性名称
String fieldName = des.getName();
//如果有这个属性
if(propMap.containsKey(fieldName)){
//写属性的方法
Method setter = des.getWriteMethod();
setter.invoke(bean, new Object[]{propMap.get(fieldName)});
}
}
} catch (Exception e) {
//异常处理
System.out.println("shit");
e.printStackTrace();
}
}
}

多备份备忘录 

    检查点，在caretaker中稍微做点修改

public class Caretaker {
//容纳备忘录的容器
private HashMap<String,Memento> memMap = new HashMap<String,Memento>();
public Memento getMemento(String idx) {
return memMap.get(idx);
}
public void setMemento(String idx,Memento memento) {
this.memMap.put(idx, memento);
}
}

权限设计

    只能由发起人访问，私有的内置类，但是备忘录管理需要关联，这个时候就可以使用空接口，但是访问属性可以通过反射和修改数据，这是一种设计方法，叫做"双接口设计"，将Memento类内置于Originator ，这样只能由Originator 访问了。

双接口设计

双接口设计，我们的一个类可以实现多个接口， 在系统设计时，如果考虑对象的安全问题，则可以提供两个接口，一个是业务的正常接口， 实现必要的业务逻辑，叫做宽接口；另外一个接口是一个空接口，什么方法都没有，其目的 是提供给子系统外的模块访问，比如容器对象，这个叫做窄接口，由于窄接口中没有提供任 何操纵数据的方法，因此相对来说比较安全。

因为一个一个写例子的确看起来很简单，我修改了大约40分钟把三者功能合一，其中有些地方确实该的不好，但是至少明白了其中的道。

public class Originator { 
 private String state1="";  //状态1
 private String state2="";  //状态2
 private String state3="";  //状态3
 
 public String getState1() {
  return state1;
 }
 public void setState1(String state1) {
  this.state1 = state1;
 }
 public String getState2() {
  return state2;
 }
 public void setState2(String state2) {
  this.state2 = state2;
 }
 public String getState3() {
  return state3;
 }
 public void setState3(String state3) {
  this.state3 = state3;
 }
 /**
  * 创建备份，将该实例的所有属性通过反射得到HashMap集合
  * 然后通过Memento的构造方法注入startMap中
  * @return
  */
 public Memento createMemote(){
  return new Memento(BeanUtils.backupProp(this));
 }
 
 /**
  * 因为权限的关系，外部不可能传进来一个Memento对象，这里就将就的使用了一个HashMap集合
  * 通过反射，将该实例的所有属性值替换成hashMap中的值
  * @param map
  */
 public void restoreMomoto(HashMap<String,Object> map){
  BeanUtils.restoreProp(this, map);
 }
 
 /**
  * 内置类，别人不可能访问
  * 实现一个空接口是为了与外部关联，在实际的开发中一个业务接口，一个空接口用于其它子模块，通过反射就可以为所欲为了
  * @author suibian
  */
 private class Memento implements IMemento{
  private HashMap<String,Object> startMap;
   
  public Memento(HashMap<String,Object> _startMap) {
   this.startMap=_startMap;
  }
  public HashMap<String, Object> getStartMap() {
   return startMap;
  }
  public void setStartMap(HashMap<String, Object> startMap) {
   this.startMap = startMap;
  }
 }
 /*测试使用
  */
 @Override
 public String toString() {
  return "state1="+state1+"\t state2="+state2+"\t state3="+state3;
 }
}

public class Caretaker {
 
 private HashMap<String,IMemento> map=new HashMap<String,IMemento>();
 
 public IMemento getMemoto(String idx){
  return map.get(idx);
 }
 /**
  * 多个备份
  * @param idx  时间锉
  * @param memoto 备份接口
  */
 public void setMemoto(String idx,IMemento memoto){
  this.map.put(idx, memoto);
 }
}

public class Client {
 @SuppressWarnings("unchecked")
 public static void main(String[] args) {
  Originator ori1 = new Originator();
  Caretaker caretaker = new Caretaker();
  ori1.setState1("备份1状态1");
  ori1.setState2("备份1状态2");
  ori1.setState3("备份1状态3");
  caretaker.setMemoto("第一个", ori1.createMemote());
  Originator ori2 = new Originator();
  ori2.setState1("备份2状态1");
  ori2.setState2("备份2状态2");
  ori2.setState3("备份2状态3");
  caretaker.setMemoto("第二个", ori2.createMemote());
  System.out.println(ori1.toString());
  System.out.println(ori2.toString());
  System.out.println("----------------------备份完毕----------------------------");
 
  ori1.setState1("备份1状态1改变了");
  System.out.println("改变后的:"+ori1.toString());
 
  System.out.println("-----------------------开始恢复-----------------------------");
 
  IMemento memento = caretaker.getMemoto("第一个");  //从备份管理获取备份实例
  //得到是Memento中的属性startMap再转化成能注参的map对象
  HashMap<String,Object> data=(HashMap<String, Object>) BeanUtils.backupProp(memento).get("startMap");
 
  for(Entry<String, Object> e:data.entrySet()){
   System.out.println("这是存起来的备份数据:"+e.getKey()+"\t"+e.getValue());
  }
  //将备份实例中的数据data通过反射注入到ori1中去
  ori1.restoreMomoto(data);
  System.out.println("------------------恢复完后的数据-------------------------");
  System.out.println(ori1.toString());
  System.out.println(ori2.toString());
 }
}
/*错误地方
 *通过 BeanUtils.backupProp(memento)获取的是对象Memento类的所有属性值
 *而Originator恢复需要的是一个hashMap通过反射注参，一个属性名对应一个值，而上面获取的hashMap是一个属性名，一个hashMap对象
 *因为权限只能由Originator来恢复，所以修改了restoreMomoto()方法，不传Memento，而传一个HashMap对象
 */

不得不说，这个真麻烦。 

我是菜鸟，我在路上。