备忘录模式

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
 * 设计模式之备忘录模式
 *备忘录模式的优点有：
 *当发起人角色中的状态改变时，有可能这是个错误的改变，我们使用备忘录模式就可以把这个错误的改变还原。
 *备份的状态是保存在发起人角色之外的，这样，发起人角色就不需要对各个备份的状态进行管理。
 *
 *备忘录模式的缺点：
 *在实际应用中，备忘录模式都是多状态和多备份的，发起人角色的状态需要存储到备忘录对象中，对资源的消耗是比较严重的。
 *
 *适用场景
 *如果有需要提供回滚操作的需求，使用备忘录模式非常适合，比如jdbc的事务操作，文本编辑器的Ctrl+Z恢复等。
 */
 class Originator {
 private String state1 = "";
 private String state2 = "";
 private String state3 = "";
 private String[] state4=null;
 
 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;
 }
 
 public String[] getState4() {
  return state4;
 }
 public void setState4(String[] state4) {
  this.state4 = state4;
 }
 public Memento createMemento(){
  return new Memento(BeanUtils.backupProp(this));
 }
 
 public void restoreMemento(Memento memento){
  BeanUtils.restoreProp(this, memento.getStateMap());
 }
 public String toString(){
  return "state1="+state1+"state2="+state2+"state3="+state3+"state4="+state4.length;
 }
}
class Memento {
 private Map<String, Object> stateMap;
 
 public Memento(Map<String, Object> map){
  this.stateMap = map;
 }

 public Map<String, Object> getStateMap() {
  return stateMap;
 }

 public void setStateMap(Map<String, Object> stateMap) {
  this.stateMap = stateMap;
 }
}
class BeanUtils {
 public static Map<String, Object> backupProp(Object bean){
  Map<String, Object> result = new HashMap<String, Object>();
  try{
   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){
   e.printStackTrace();
  }
  return result;
 }
 
 public static void restoreProp(Object bean, Map<String, Object> propMap){
  try {
   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) {
   e.printStackTrace();
  }
 }
}
class Caretaker {
 private Map<String, Memento> memMap = new HashMap<String, Memento>();
 public Memento getMemento(String index){
  return memMap.get(index);
 }
 
 public void setMemento(String index, Memento memento){
  this.memMap.put(index, memento);
 }
}
public class Client {
 public static void main(String[] args){
  Originator ori = new Originator();//发起者
  String[] str = {"飞机"};
  ori.setState1("J10");
  ori.setState2("J11");
  ori.setState3("J20");
  ori.setState4(str);
  System.out.println("===初始化状态===\n"+ori);
  
  Caretaker caretaker = new Caretaker();//临时替代者
  caretaker.setMemento("001",ori.createMemento());//设置备忘录====>备忘录模式关键
  
  String[] str2 = {"软件","职位"};
  ori.setState1("项目组长");//修改发起者属性值
  ori.setState2("项目经理");
  ori.setState3("技术总监");
  ori.setState4(str2);
  System.out.println("===修改后状态===\n"+ori);
  
  ori.restoreMemento(caretaker.getMemento("001"));//从备忘录中恢复属性值
  System.out.println("===恢复后状态===\n"+ori);
 }
}
/*注：
 *1发起人：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
 *2备忘录：负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。
 *3管理角色：对备忘录进行管理，保存和提供备忘录。
 */