备忘录模式

备忘录模式相对还是比较好理解的，因此直接从定义开始讲起

定义

备忘录模式是指

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

组成结构

备忘录模式所涉及的角色有三个：备忘录，发起人，负责人

备忘录(Memento)

负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。因此简单的类图应该就是这样子的

Memento有一个状态属性保存内部状态，提供get和set方法分别用于存储和提供该状态。

发起人(Originator)

记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。因此简单的类图应该就是这样子的

Originator定义了state用于表示需要备份范围的状态，提供了create和restore方法用于创建和恢复备忘录数据。

负责人(Caretaker)

对备忘录进行管理，保存和提供备忘录。简单的类图如下

Caretaker中定义了save和retrieve方法用于保存和提供其管理的备忘录memento

代码实例

备忘录模式可以分为白箱模式和黑箱模式两种，两种模式与备忘录角色提供的接口模式有关

窄接口：负责人对象（以及其他除发起人对象之外的任何对象）看到的是备忘录的窄接口(narrow interface)，这个窄接口只允许它把备忘录对象传给其他的对象，即他们无法访问到备忘录角色的内部状态。
宽接口：与负责人对象看到的窄接口相反的是，发起人对象可以看到一个宽接口(wide interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。

白箱模式

备忘录角色对任何对象都提供一个（宽）接口，备忘录角色的内部所存储的状态就对所有对象公开。这个实现叫做“白箱实现”。实际上我们上面的组成结构中描述的就是一个简单的白箱模式的案例

类图

类图大致如下

代码

备忘录角色，将发起人对象传入的状态存储起来

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;
    }
    
}

发起人角色，定义了自身的状态，并且提供了创建备忘录和恢复备忘录中数据的方法

public class Originator {

    private String state;
    /**
     * 工厂方法，返回一个新的备忘录对象
     */
    public Memento createMemento(){
        return new Memento(state);
    }
    /**
     * 将发起人恢复到备忘录对象所记载的状态
     */
    public void restoreMemento(Memento memento){
        this.state = memento.getState();
    }
    
    public String getState() {
        return state;
    }
    
    public void setState(String state) {
        this.state = state;
        System.out.println("当前状态：" + this.state);
    }
    
}

负责人角色类，负责人角色负责保存备忘录对象，但是从不修改备忘录对象的内容（虽然它可以修改）。

public class Caretaker {

    private Memento memento;
    /**
     * 备忘录的取值方法
     */
    public Memento retrieveMemento(){
        return this.memento;
    }
    /**
     * 备忘录的赋值方法
     */
    public void saveMemento(Memento memento){
        this.memento = memento;
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        
        Originator o = new Originator();
        Caretaker c = new Caretaker();
        // 改变负责人对象的状态
        o.setState("On");
        // 创建备忘录对象
        Memento memento = o.createMemento();
        // 将发起人对象的状态储存起来
        c.saveMemento(o.createMemento());
        // 修改发起人的状态
        o.setState("Off");
        // 恢复发起人对象的状态
        o.restoreMemento(c.retrieveMemento());
        
        System.out.println(o.getState());
    }

}

上面的客户端首先创建了发起人和负责人角色，然后设置了发起人的状态，其后立刻让发起人创建自己的备忘录并将改备忘录通过负责人管理起来，而后发起人再次修改自身的状态，此时可以通过负责人角色所管理的备忘录回复自身原先的状态。

黑箱模式

备忘录角色对发起人（Originator）角色对象提供一个（宽）接口，而为其他对象提供一个（窄）接口。这样的实现叫做“黑箱实现”。
黑箱模式下，备忘录角色的状态只可以被发起人访问，其余的人无法访问，Java中可以通过将备忘录角色作为发起人的内部类来实现该能力。

类图

代码

备忘录&发起人

package memento.sample2;


/**
 * @author chen_dz
 * @date ：2012-6-2 上午10:11:08
 */
public class Originator {

    private String state;
    
    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
        System.out.println("赋值状态：" + state);
    }
    /**
     * 工厂方法，返还一个新的备忘录对象
     */
    public MementoIF createMemento(){
        return new Memento(state);
    }
    /**
     * 发起人恢复到备忘录对象记录的状态
     */
    public void restoreMemento(MementoIF memento){
        this.setState(((Memento)memento).getState());
    }

    public interface MementoIF {}
    
    private class Memento implements MementoIF{
        
        private String state;
        /**
         * 构造方法
         */
        private Memento(String state){
            this.state = state;
        }
        
        private String getState() {
            return state;
        }
        private void setState(String state) {
            this.state = state;
        }
    }
}

可以看到备忘录成为了发起人的内部类，因此private方法无法被外部类访问到，从而保证了备忘录中的状态安全性。同时由于发起人创建备忘录时生成的对象是MementoIF接口，因此负责人能够得到的备忘录对象也就是以MementoIF为接口的，由于这个接口仅仅是一个标识接口，因此负责人角色不可能改变这个备忘录对象的任何内容。
负责人的实现如下

public class Caretaker {

    private MementoIF memento;
    /**
     * 备忘录取值方法
     */
    public MementoIF retrieveMemento(){
        return memento;
    }
    /**
     * 备忘录赋值方法
     */
    public void saveMemento(MementoIF memento){
        this.memento = memento;
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        Originator o = new Originator();
        Caretaker c = new Caretaker();
        //改变负责人对象的状态
        o.setState("On");
        //创建备忘录对象，并将发起人对象的状态存储起来
        c.saveMemento(o.createMemento());
        //修改发起人对象的状态
        o.setState("Off");
        //恢复发起人对象的状态
        o.restoreMemento(c.retrieveMemento());
    }

}

Android中的备忘录模式

public class Canvas {
    /**
     *保存当前的矩阵和剪裁到一个私有的堆栈，其实矩阵和剪裁就是当前Canvas的状态State
     */
    public native int save();
    /**
     * 移除自上次保存操作后所做的修改，恢复到之前的状态，因为是堆栈实现，所以pull操作不能不等于push操作，save()和restore()应该成对使用，否则恢复的状态就很有可能是错误的
     */
    public native void restore();
}

应该是一个非常直观的例子了