备忘录模式
备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态（其实不一定是在对象之外，可以是类自主备份和恢复），这样以后就可以将该对象恢复到原先保存的状态。
通俗的说备忘录模式就是一个对象的备份模式，提供了一种程序数据的备份方法，其通用类图如下：
Originator发起人角色：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
Memento备忘录角色：负责存储Originator发起人的内部状态，在需要时提供发起人需要的内部状态。
Caretaker备忘录管理员角色：对备忘录进行管理，保存和提供备忘录。
其通用类图的源码如下：
public class Originator {
private String state = "very goood";
public void setState(String newState){
this.state = newState;
}
public String getState(){
return this.state;
}
public Memento createMemento(){
return new Memento(this.state);
}
public void restoreState(Memento _memento){
this.setState(_memento.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 _memento = null;
public void setMemento(Memento memento){
this._memento = memento;
}
public Memento getMemento(){
return this._memento;
}}
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Originator originator = new Originator();
Caretaker _caretaker = new Caretaker();
_caretaker.setMemento(originator.createMemento());
originator.setState("very bad");
System.out.println(originator.getState());
originator.restoreState(_caretaker.getMemento());
System.out.println(originator.getState());
}}
View Code
由于备忘录模式有很多变形和处理，每种方式都有自身的优点和缺点，标准模式很难在项目中遇到，基本上都是一些变换处理。备忘录模式主要适用于:1、需要保存和恢复数据的场景；2、提供一个可回滚的操作，如win常见的Ctrl+Z，浏览器中的后退按钮，文本管理器上的backspace键等；3、需要监控副本的场景。例如监控一个对象的属性，但是监控又不应该作为系统的主要业务来调用，即使出现监控不准、错误报警也影响不大，因此一般的做法是备份一个主线程中的对象，然后由分析程序分析；4、数据库连接的事务管理就是用的备忘录模式。
备忘录模式的扩展
clone方式的备忘录模式
在原型模式中，我们通过clone的方式产生一个对象的内部状态，这也是很好的一个备份方式，发起人角色只要实现Cloneable就成，其通用类图如下：
public class Originator implements Cloneable{
private String state = "very good";
public void setState(String newState){
this.state = newState;
}
public String getState(){
return this.state;
}
public Originator createMemento(){
return this.clone();
}
public void restoreState(Originator originator){
this.setState(originator.getState());
}
@Override
protected Originator clone(){
try {
return (Originator) super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}}
public class Caretaker {
private Originator originator = null;
public void setOriginator(Originator originator){
this.originator = originator;
}
public Originator getOriginator(){
return this.originator;
}}
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Originator _originator = new Originator();
Caretaker caretaker = new Caretaker();
caretaker.setOriginator(_originator.createMemento());
_originator.setState("very bad");
System.out.println(_originator.getState());
_originator.restoreState(caretaker.getOriginator());
System.out.println(_originator.getState());;
}}
View Code
当然了发起人还可以自主备份和恢复，具体代码如下：
public class Originator3 implements Cloneable{
private Originator3 backup = null;
private String state = "very bad";
public void setState(String newState){
this.state = newState;
}
public String getState(){
return this.state;
}
public void createMemento(){
this.backup = this.clone();
}
public void restoreState(){
this.setState(this.backup.getState());
}
protected Originator3 clone(){
try {
return (Originator3) super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}}
View Code
多状态的备忘录模式
如上我们讲解的都是单状态的情况，而在实际的开发中一个对象很可能有很多状态，一个JavaBean有多个属性是很常见的。因此我们讲解一个对象全状态备份方案，他有多种处理方式，比如使用clone的方式就可以解决，使用数据技术也可以解决（DTO回写到临时表中）等，如下方法是实现一个JavaBean对象的所有状态的备份和还原，类图如下所示：
public class Originator4 {
private String state1 = null;
private String state2 = null;
private String state3 = 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 Memento4 createMemento(){
return new Memento4(BeanUtils.backup(this));
}
public void restoreMemento(Memento4 _memento){
BeanUtils.restoreMap(this, _memento.getStateMap());
}}
public class BeanUtils {
public static HashMap<String,Object> backup(Object bean){
HashMap<String,Object> map = new HashMap<String,Object>();
try {
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
for(PropertyDescriptor des : descriptors){
//读取属性的名称
String fileName = des.getName();
//读取属性的方法
Method getter = des.getReadMethod();
Object fieldValue = getter.invoke(bean, new Object[]{});
if(!fileName.equalsIgnoreCase("class"))
map.put(fileName, fieldValue);
}
} catch (IntrospectionException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return map;
}
public static void restoreMap(Object bean, HashMap<String,Object> map){
try {
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//获取属性描述
PropertyDescriptor[] descriptor = beanInfo.getPropertyDescriptors();
for(PropertyDescriptor des : descriptor){
//属性名称
String fileName = des.getName();
if(map.containsKey(fileName)){
Method setter = des.getWriteMethod();
setter.invoke(bean, new Object[]{map.get(fileName)});
}
}
} catch (IntrospectionException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}}
public class Memento4 {
private HashMap<String,Object> stateMap;
public Memento4(HashMap<String,Object> map){
this.stateMap = map;
}
public HashMap<String,Object> getStateMap(){
return this.stateMap;
}}
public class Caretaker4 {
private Memento4 _memento = null;
public void setMemento(Memento4 memento){
this._memento = memento;
}
public Memento4 getMemento(){
return this._memento;
}}
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Originator4 originator = new Originator4();
Caretaker4 caretaker = new Caretaker4();
caretaker.setMemento(originator.createMemento());
originator.setState1("haha");
originator.setState2("heihei");
originator.setState3("hehe");
originator.restoreMemento(caretaker.getMemento());
}}
View Code
多备份的备忘录
如上的解决方法中还不能做到将备份的上一个状态还原，因为如上的每个对象只有个备份，那么我们把对象的状态还原到某个点怎么办呢？这就需要对每一个对象进行多备份。首先我们介绍一个名词，检查点（Check Point），也就是备份的时候的戳记，系统级的备份一般是时间戳，如下在设计的时候检查点是一个唯一的标识字符串。只需要对多状态备忘录模式中的Caretaker中的代码做如下修改就可以，修改后的代码如下：
public class Caretaker4 {
private HashMap<String,Memento4> _mementoMap = new HashMap<String,Memento4>();
public void setMemento(String id,Memento4 memento){
this._mementoMap.put(id, memento);
}
public Memento4 getMemento(String id){
return this._mementoMap.get(id);
}}
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Originator4 originator = new Originator4();
Caretaker4 caretaker = new Caretaker4();
caretaker.setMemento("001",originator.createMemento());
originator.setState1("haha");
originator.setState2("heihei");
originator.setState3("hehe");
caretaker.setMemento("002", originator.createMemento());
originator.restoreMemento(caretaker.getMemento("001"));
}}
View Code
设计具有更好的封装性
Comments | NOTHING