[设计模式]备忘录模式

1. 定义

　　在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。

　　一个备忘录是一个对象，它存储另一个对象在某个瞬间的内部状态，后者被称为备忘录的原发器。

2. 类图

　　

　　Memento: 备忘录。主要用来存储原发器对象的内部状态，但是具体需要存储哪些数据是由原发器对象来决定的。另外备忘录应该只能由原发器对象来访问它内部的数据，原发器外部的对象不应该访问到备忘录对象的内部数据。

　　Originator：原发器。使用备忘录来保存某个时刻原发器自身的状态，也可以使用备忘录来恢复内部状态。

　　Caretaker：备忘录管理者，或者成为备忘录负责人。主要负责保存备忘录对象，但是不能对备忘录对象的内容进行操作或检查。

3. 实例

　　

package com.jerry.designpattern.demo;
/**
 * 备忘录接口
 * @author Jerry
 * @date 2015年2月1日 下午9:18:38
 */
public interface FlowAMockMemento {

}

package com.jerry.designpattern.demo;

import java.io.Serializable;

/**
 * 
 * @author Jerry
 * @date 2015年2月1日 下午9:21:32
 */
public class FlowAMock implements Serializable{
    /**
     * 流程名称
     */
    private String flowName;
    
    private int tempResult;
    private String tempState;
    
    public FlowAMock(String flowName) {
        this.flowName = flowName;
    }
    
    public void runPhaseOne() {
        this.tempResult = 3;
        this.tempState = "phase one";
    }
    
    public void schema1() {
        this.tempState += ", schema1";
        System.out.println(this.tempState + ",now run:" + this.tempResult);
        this.tempResult += 11;
    }
    
    public void schema2() {
        this.tempState += ", schema2";
        System.out.println(this.tempState + ",now run:" + this.tempResult);
        this.tempResult += 22;
    }
    
    public FlowAMockMemento createMemento() {
        return new MementoImpl(this.tempResult, this.tempState);
    }
    
    public void setMemento(FlowAMockMemento memento) {
        MementoImpl mementoImpl = (MementoImpl)memento;
        this.tempResult = mementoImpl.getTempResult();
        this.tempState = mementoImpl.getTempState();
    }
    
    private class MementoImpl implements FlowAMockMemento, Serializable {
        private int tempResult;
        private String tempState;
        
        public MementoImpl(int tempResult, String tempState) {
            this.tempResult = tempResult;
            this.tempState = tempState;
        }
        
        public int getTempResult() {
            return tempResult;
        }
        
        public String getTempState() {
            return tempState;
        }
    }
}

package com.jerry.designpattern.demo;
/**
 * 
 * @author Jerry
 * @date 2015年2月1日 下午9:41:43
 */
public class FlowAMockCareTaker {
    
    private FlowAMockMemento memento;
    
    public void saveMemento(FlowAMockMemento memento) {
        this.memento = memento;
    }
    
    public FlowAMockMemento retrieveMemento() {
        return this.memento;
    }
}

package com.jerry.designpattern.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 将对象保存到文件中
 * @author Jerry
 * @date 2015年2月1日 下午10:38:39
 */
public class FlowAMockFileCareTaker {
    public void saveMemento(FlowAMockMemento memento) {
        ObjectOutputStream output = null;
        try {
            output = new ObjectOutputStream(
                                            new BufferedOutputStream(
                                                    new FileOutputStream("FileMemento")));
            output.writeObject(memento);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                output.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                output = null;
            }
        }
    }
    
    public FlowAMockMemento retrieveMemento() {
        FlowAMockMemento memento = null;
        ObjectInputStream in = null;
        try {
            in = new ObjectInputStream(
                    new BufferedInputStream(
                            new FileInputStream("FileMemento")));
            memento = (FlowAMockMemento) in.readObject();
        } catch (Exception e) {
            // TODO: handle exception
            try {
                in.close();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                in = null;
            }
        }
        return memento;
    }
}

package com.jerry.designpattern.demo;
/**
 * 
 * @author Jerry
 * @date 2015年2月1日 下午9:53:10
 */
public class Client {
    public static void main(String[] args) {
        FlowAMock mock = new FlowAMock("TestFlow");
        mock.runPhaseOne();
        
        //FlowAMockCareTaker careTaker = new FlowAMockCareTaker();
        FlowAMockFileCareTaker careTaker = new FlowAMockFileCareTaker();
        careTaker.saveMemento(mock.createMemento());
        
        mock.schema1();
        mock.setMemento(careTaker.retrieveMemento());
        mock.schema2();
    }
}

4. 优缺点

　　优点：更好的封装性，简化了原发器，引入窄接口和款接口。

　　缺点：可能导致高开销。