备忘录模式实例：《预见未来》中男主角可以预见未来，遇到女主角可以反复尝试打动女主角。
原始状态的保留和恢复这块，如何保留一个原始状态，如何恢复一个原始状态才是最重要的，那想想看，我们应该怎么去实现呢？很简单，我们定义一个中间变量，保留这个原始状态。我们先看看类图：
太简单的类图了，state表示所有的状态，changeState方法表示状态变化
package com.nextvpu.myapplication;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class Boy {
//男孩的状态
private String state = "";
//认识女孩子后状态肯定改变，比如心情、手中的花等
public void changeState(){
this.state = "心情可能很不好";
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
我们再来看看场景类是如何进行状态的保留、恢复的
private void Client() {
//声明主角
Boy boy = new Boy();
//初始化当前状态
boy.setState("心情很棒");
Log.e("xyz"," ----男孩现在的状态---- ");
Log.e("xyz"," boy.state === "+boy.getState());
//需要记录下当前状态呀
Boy backup = new Boy();
backup.setState(boy.getState());
//男孩去追女孩，状态变化
boy.changeState();
Log.e("xyz","\n-----男孩追女孩后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
//追女孩失败，恢复原状
boy.setState(backup.getState());
Log.e("xyz","\n-----男孩恢复后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
}程序运行正确，输出结果也是我们期望的，但是结果结果正确并不表示程序是最优的，我们来看看场景类,它代表的是高层类，或者说是非“近亲”模块的调用者，注意看backup变量的使用，它对于高层模块完全是多余的，为什么一个状态的保存和恢复要让高层模块来负责呢？这应该是Boy类的职责，而不应该让高层模块来完成，也就是破坏了Boy类的封装。保留和恢复状态应该有另外一个类来担当，那我们把这个类取名就叫做备忘录。我们来修改一下类图：
改动很小，增加了一个新的类Memento，负责状态的保存和备份；同时，在Boy类中增加了创建一份备忘录createMemento和恢复一个备忘录restoreMemento，我们先看Boy类的变化：
package com.nextvpu.myapplication;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class Boy {
//男孩的状态
private String state = "";
//认识女孩子后状态肯定改变，比如心情、手中的花等
public void changeState(){
this.state = "心情可能很不好";
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//保留一个备份
public Memento createMemento(){
return new Memento(this.state);
}
//恢复一个备份
public void restoreMemento(Memento memento){
this.setState(memento.getState());
}
}
注意看，确实只增加了两个方法创建备份和恢复备份，至于什么时候创建备份和恢复备份则是有高层模块决定的。我们来看备忘录模块，代码如下：
package com.nextvpu.myapplication;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class Memento {
//男孩的状态
private String state = "";
//通过构造函数传递状态信息
public Memento(String state){
this.state = state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
我们再来看看场景类：
private void ClientChange() {
//声明主角
Boy boy = new Boy();
//初始化当前状态
boy.setState("心情很棒");
Log.e("xyz"," ----男孩现在的状态---- ");
Log.e("xyz"," boy.state === "+boy.getState());
//需要记录下当前状态呀
Memento memento = boy.createMemento();
//男孩去追女孩，状态变化
boy.changeState();
Log.e("xyz","\n-----男孩追女孩后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
//追女孩失败，恢复原状
boy.restoreMemento(memento);
Log.e("xyz","\n-----男孩恢复后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
}运行结果保持相同，虽然程序中不再重复定义Boy类的对象了，但是我们还是要关心备忘录，这对迪米特法则是一种亵渎，他告诉我们只和朋友类通信，那这个备忘录对象是我们必须要通信的朋友类吗？建立一个管理类，就是管理这个备忘录，如图：
又增加了一个JavaBean，Boy类和Memento没有任何改变，我们来看看增加的备忘录管理类，代码如下：
package com.nextvpu.myapplication;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class Caretaker {
//备忘录对象
private Memento memento;
public Memento getMemento(){
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
场景调用：
private void ClientTest() {
//声明主角
Boy boy = new Boy();
//声明出备忘录的管理者
Caretaker caretaker = new Caretaker();
//初始化当前状态
boy.setState("心情很棒");
Log.e("xyz"," ----男孩现在的状态---- ");
Log.e("xyz"," boy.state === "+boy.getState());
//需要记录下当前状态呀
caretaker.setMemento(boy.createMemento());
//男孩去追女孩，状态变化
boy.changeState();
Log.e("xyz","\n-----男孩追女孩后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
//追女孩失败，恢复原状
boy.restoreMemento(caretaker.getMemento());
Log.e("xyz","\n-----男孩恢复后的状态");
Log.e("xyz","boy.getState ==="+boy.getState());
}这个备份者就类似于一个备份的仓库管理员，创建一个丢进去，需要的时候再拿出来。这就是备忘录模式。
<1.1>备忘录模式的定义
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象保存之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态
通俗的说，备忘录模式就是一个对象的备份模式，提供了一种程序数据的备份方法，其通用类图如下：
我们来看看类图中的三个角色
Originator发起人角色
记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。Memento备忘录角色
负责存储Originator发起人对象都额内部状态，在需要的时候提供发起人需要的内部状态Caretaker备忘录管理员角色
-对备忘录进行管理、保存和提供备忘录
备忘录模式的通用代码也很简单，我们先看发起人角色，代码如下：
package com.company.section4;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Originator {
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public Memento createMemento(){
return new Memento(this.state);
}
//恢复一个备忘录
public void restoreMemento(Memento _memento){
this.setState(_memento.getState());
}
}
我们再来看备忘录角色，代码如下：
package com.company.section4;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Memento {
//发起人的内部状态
private String state = "";
//构造函数传递参数
public Memento(String _state){
this.state = _state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
备忘录管理这也是一个简单的JavaBean，代码如下：
package com.company.section4;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Caretaker {
//备忘录对象
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}最后看看场景类如何调用：
package com.company.section4;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Client {
public static void main(String[] args) {
//定义出发起人
Originator originator = new Originator();
//定义出备忘录管理员
Caretaker caretaker = new Caretaker();
//创建一个备忘录
caretaker.setMemento(originator.createMemento());
//恢复一个备忘录
originator.restoreMemento(caretaker.getMemento());
}
}
2.1备忘录模式的应用
2.2.1备忘录模式的使用场景
- 需要保存和恢复数据的相关状态场景
- 提供一个可会滚（rollback）的操作
- 需要监控的副本场景中
数据库连接的事物管理就是用的备忘录模式
2.2.2备忘录模式的注意事项备忘录的生命期
备忘录创建出来就要在“最近”的代码中使用，要主动管理它的生命周期，简历就要使用，不实用就要立刻删除其引用，等待垃圾回收器对它的回收处理。备忘录的性能
不要在平凡建立备份的场景中使用备忘录（比如一个for循环中），原因有二，一是控制不了备忘录建立的对象数量；二是，大对象的建立是要消耗资源的，系统的性能需要考虑。
3.1备忘录模式的扩展
3.1.1 clone方式的备忘录
还记得原型模式吗？我们可以通过复制的方式产生一个对象的内部状态，这是一个很好的办法，发起人角色只要实现Cloneable就成，比较简单，我们来看类图：
从类图上看，发起人角色融合了发起人角色和备忘录角色，具有双重功效，代码如下：
package com.company.section6;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Originator implements Cloneable{
private Originator backup;
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public void createMemento(){
this.backup = this.clone();
}
//恢复一个备忘录
public void restoreMemento(){
//在进行恢复前应该进行断言，防止空指针
this.setState(this.backup.getState());
}
//克隆当前对象
@Override
protected Originator clone(){
try {
return (Originator)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
增加了clone方法，产生了一个备份对象，需要使用的时候再还原，我们再来看管理员的角色，代码如下：
package com.company.section5;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Caretaker {
//发起人对象
private Originator originator;
public Originator getOriginator() {
return originator;
}
public void setOriginator(Originator originator) {
this.originator = originator;
}
}
没什么太大变化，只是备忘录角色转换成发起人角色，还是一个简单的JavaBean。我们来想想这种模式是不是还可以简化？要管理员角色干什么？就是为了备忘录角色，现在连备忘录角色都被合并了，还留它干嘛？我们想办法把它也精简掉，代码如下：
package com.company.section6;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Originator implements Cloneable{
private Originator backup;
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public void createMemento(){
this.backup = this.clone();
}
//恢复一个备忘录
public void restoreMemento(){
//在进行恢复前应该进行断言，防止空指针
this.setState(this.backup.getState());
}
//克隆当前对象
@Override
protected Originator clone(){
try {
return (Originator)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
可能你要发问了，这和备忘录模式的定义不相符，它定义是“在该对象之外保存这个状态”，而你却把这个状态保存在了发起人内部。是的，设计模式定义的诞生比java的出师略早，，在面对对象的设计中，即使把一个类封装在另一个类中也是可以做到的，何况一个小小的对象复制。
再来看看Client是如何调用的，代码如下：
package com.company.section6;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Client {
public static void main(String[] args) {
//定义发起人
Originator originator = new Originator();
//建立初始状态
originator.setState("初始状态...");
System.out.println("初始状态是："+originator.getState());
//建立备份
originator.createMemento();
//修改状态
originator.setState("修改后的状态...");
System.out.println("修改后状态是："+originator.getState());
//恢复原有状态
originator.restoreMemento();
System.out.println("恢复后状态是："+originator.getState());
}
}
现在我们来考虑一下原型模式的深拷贝和浅拷贝的问题，在复杂的场景下它会让你的程序逻辑异常混乱，出现错误也很难跟踪。因此Clone方式的备忘录模式适用于较简单的场景。
注意：使用Clone方式的备忘录模式，可以使用在比较简单的场景或者比较单一的场景中，尽量不要与其他的对象产生严重的耦合关系。
3.1.2 多状态的备忘录模式
我们以上讲解都是单状态的情况，在实际的开发中一个对象不可能只有一个状态，一个JavaBean有多个属性非常常见，这都是它的状态。
下面我们来讲解一个对象全状态备份方案，它有多种处理方式，比如使用Clone的方式就可以解决，使用数据技术也可以解决（DTO回写到临时表中）等，我们要讲的方案就对备忘录模式继续扩展一下，实现一个JavaBean对象的所有状态的备份和还原，如下图：
这是比较简单的类图，增加了一个BeanUtils类，其中backupProp是把发起人的所有属性值转换到HashMap中，方便备忘录角色存储；restoreProp方法则是把HashMap中的值返回到发起人角色中。
package com.nextvpu.myapplication;
/**
* Created by NEXTVPU on 2018/7/3.
*/
public class OriginatorMore {
//内部状态
private String state1 = "";
private String state2 = "";
private String state3 = "";
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 Memento createMento(){
return new Memento(BeanUtils.backupProp(this));
}
//恢复一个备忘录
public void restoreMemento(Memento memento){
BeanUtils.restoreProp(this,memento.getStateMap());
}
@Override
public String toString() {
return "state1 = "+state1+"\nstate2 = "+state2+"\nstate3 = "+state3;
}
}
我们再来看BeanUtils工具类，代码如下：
package com.nextvpu.myapplication;
import android.util.Log;
import com.googlecode.openbeans.BeanInfo;
import com.googlecode.openbeans.IntrospectionException;
import com.googlecode.openbeans.Introspector;
import com.googlecode.openbeans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.beans.*;
/**
* Created by NEXTVPU on 2018/7/3.
*/
public class BeanUtils {
//把bean的所有属性及数值放入到Hashmap中
public static HashMap<String,Object> backupProp(Object bean){
HashMap<String,Object> result = new HashMap<String, Object>();
//获得Bean描述
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){
e.printStackTrace();
}
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) {
//异常处理
Log.e("xyz","shit");
e.printStackTrace();
}
}
}
该类大家在项目中会经常用到，可以作为参考使用。我们再来看备忘录角色，如代码：
package com.nextvpu.myapplication;
import java.util.HashMap;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class Memento {
//接受HashMap作为状态
private HashMap<String,Object> stateMap;
//接受一个对象，建立一个备份
public Memento(HashMap<String,Object> map){
this.stateMap = map;
}
public HashMap<String, Object> getStateMap() {
return stateMap;
}
public void setStateMap(HashMap<String, Object> stateMap) {
this.stateMap = stateMap;
}
}
我们再编写一个场景类，看看我们的成果是否正确，代码如下：
private void ClientTestOne() {
//定义发起人
OriginatorMore originator = new OriginatorMore();
//定义出备忘录管理员
Caretaker caretaker = new Caretaker();
//初始化
originator.setState1("中国");
originator.setState2("强盛");
originator.setState3("繁荣");
Log.e("xyz","---初始化状态---\n"+originator);
//创建一个备忘录
caretaker.setMemento(originator.createMento());
//修改状态值
originator.setState1("软件");
originator.setState2("架构");
originator.setState3("优秀");
Log.e("xyz","---修改后状态---\n"+originator);
//恢复一个备忘录
originator.restoreMemento(caretaker.getMemento());
Log.e("xyz","---恢复后状态---\n"+originator);
}注意：
如果要设计一个在运行期决定备份状态的框架，则建议采用AOP框架来实现，避免采用动态代理无谓的增加程序逻辑复杂性。
3.1.3 多备份的备忘录
我们先来说一个名词，检查点（Check Point），也就是你在备份的时候做的戳记，系统级的备份一般是时间戳，那我们程序的检查点该怎么设计？一般是一个有意义的字符串。
我们只要把通用代码中的Caretaker管理员稍作修改就可以了，代码如下：
package com.nextvpu.myapplication;
import java.util.HashMap;
/**
* Created by NEXTVPU on 2018/6/28.
*/
public class CaretakerChange {
//容纳备忘录的容器
private HashMap<String,Memento> mementoHashMap = new HashMap<String, Memento>();
public Memento getMementoHashMap(String idx) {
return mementoHashMap.get(idx);
}
public void setMemento(String idx,Memento memento) {
this.mementoHashMap.put(idx,memento);
}
}
把容纳备忘录的容易修改为Map类型就可以了，场景类也稍作改动，代码如下：
private void ClientTestTwo() {
//定义发起人
OriginatorMore originator = new OriginatorMore();
//定义出备忘录管理员
CaretakerChange caretaker = new CaretakerChange();
//创建两个备忘录
caretaker.setMemento("001",originator.createMento());
caretaker.setMemento("002",originator.createMento());
//恢复一个指定标记的备忘录
originator.restoreMemento(caretaker.getMementoHashMap("001"));
}注意：
内存溢出问题，该备份一旦产生就装入内存，没有任何销毁的意向，这是非常危险的。因此，在系统设计时，要严格限定备忘录的创建，建议增加Map的上限，否则系统很容易产生内存溢出情况。
3.1.4 封装得更好一点
在系统管理上，一个备份的数据是完全、绝对不能修改的，它保证数据的洁净，避免数据污染而失去备份的意义。在我们的设计领域中，也存在着同样的问题，备份是不能呗篡改的，也就是说需要缩小备份出的备忘录的阅读权限，保证只能是发起人可读就成了，那怎么才能做到这一点呢？使用内置类，如图：
这是比较简单的，建立一个空接口IMemento–什么方法属性都没有的接口，然后在发起人Originator类建立一个内置类（也叫类种类）Memento实现IMemento接口，同时实现自己的业务逻辑，代码如下：
package com.company.section9;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Originator {
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public IMemento createMemento(){
return new Memento(this.state);
}
//恢复一个备忘录
public void restoreMemento(IMemento _memento){
this.setState(((Memento)_memento).getState());
}
//内置类
private class Memento implements IMemento{
//发起人的内部状态
private String state = "";
//构造函数传递参数
private Memento(String _state){
this.state = _state;
}
private String getState() {
return state;
}
private void setState(String state) {
this.state = state;
}
}
}
内置类Memento全部是private 的访问权限，也就是说除发起人外，别人休想访问到，那如果要产生关联关系又应如何处理呢？通过接口！别忘记了我们还有一个空接口是公共访问权限，代码如下：
package com.company.section9;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
*/
public class Caretaker {
//备忘录对象
private IMemento memento;
public IMemento getMemento() {
return memento;
}
public void setMemento(IMemento memento) {
this.memento = memento;
}
}
全部通过接口访问，这当然没有问题，如果你想访问它的属性那是肯定不行的。但是安全是相对的，没有绝对的安全，可以使用refelect反射修改Memento的数据。
在这里我们使用了一个新的设计方法：双接口设计，我们的一个类可以实现多个接口，在系统设计时，如果考虑对象的安全问题，则可以提供两个接口，一个是业务的正常接口，实现必要的业务逻辑，叫做宽接口；另外一个接口是一个空接口，什么方法都没有，其目的是提供给子系统外的模块访问，比如容器对象，这个叫做窄接口，由于窄接口中没有提供任何操作数据的方法，因此相对来说编辑哦安全。
177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
