23种设计模式之备忘录模式

备忘录模式是一种行为模式，该模式用于保存对象当前状态，并且在之后可以再次恢复到此状态
此文主要参考《Android源码设计模式解析与实战》一书

备忘录模式的定义
在不破坏封闭的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样，以后就可将该对象恢复到原先保存的状态。

备忘录模式的使用场景
a.需要保存一个对象在某一个时刻的状态或部分状态
b.如果用一个借口来让其他对象得到这些状态，将会暴露对象的实现细节并破坏对象的封装性，一个对象不希望外界直接访问其内部状态，通过中间对象可以间接访问其内部状态。

备忘录模式的UML类图

角色介绍：
Originator：负责创建一个备忘录，可以记录、恢复自身的内部状态。同时Originator还可以根据需要决定Memento存储自身的哪些内部状态。
Memento：备忘录角色，用于存储Originator的内部状态，并且可以防止Originato以外的对象访问Memento。
Caretaker：负责存储备忘录，不能对备忘录的内部进行操作和访问，只能够将备忘录传递给其他对象。

源码实现

//使命召唤游戏
public class CallOfDuty {
    private int mCheckpoint = 1;
    private int mLifeValue = 100;
    private String mWeapon = "沙漠之鹰";

    //玩游戏
    public void play(){
        System.out.println("玩游戏："+String.format("第%d关",mCheckpoint) + "奋战杀敌中");
        mLifeValue -= 10;
        System.out.println("进度升级了");
        mCheckpoint++;
        System.out.println("到达"+String.format("第%d关",mCheckpoint));
    }

    //退出游戏
    public void quit(){
        System.out.println("-------------------");
        System.out.println("退出前的游戏熟悉："+this.toString());
        System.out.println("退出游戏");
        System.out.println("-------------------");
    }

    //创建备忘录
    public Memoto createMemoto(){
        Memoto memoto = new Memoto();
        memoto.mCheckpoint = mCheckpoint;
        memoto.mLifeValue = mLifeValue;
        memoto.mWeapon = mWeapon;
        return memoto;
    }

    //恢复游戏
    public void restore(Memoto memoto){
        this.mCheckpoint = memoto.mCheckpoint;
        this.mLifeValue = memoto.mLifeValue;
        this.mWeapon = memoto.mWeapon;
        System.out.println("恢复后的游戏属性："+this.toString());
    }

    @Override
    public String toString() {
        return "CallOfDuty{" +
                "mCheckpoint=" + mCheckpoint +
                ", mLifeValue=" + mLifeValue +
                ", mWeapon='" + mWeapon + '\'' +
                '}';
    }
}

CallOfDuty游戏类中，存储一些关键的字段，关卡，人物的生命值、武器等。当调用play()方法时对属性进行修改，在createMemoto（）函数中来创建备忘录对象，对自身状态进行保存。外部可以通过restore()函数将CallOfDuty对象的状态从备忘录对象中恢复。

下面是备忘录的类：

//备忘录类
public class Memoto {
    public int mCheckpoint;
    public int mLifeValue;
    public String mWeapon;

    @Override
    public String toString() {
        return "Memoto{" +
                "mCheckpoint=" + mCheckpoint +
                ", mLifeValue=" + mLifeValue +
                ", mWeapon='" + mWeapon + '\'' +
                '}';
    }
}

这个只负责存储Originator角色的数据进行存储，不操作实体类状态。备忘录的操作者是Caretaker角色，下面是相关代码：

//负责管理Memoto
public class Caretaker {
    Memoto mMemoto; // 备忘录
    //存档
    public void archive(Memoto memoto){
        this.mMemoto = memoto;
    }

    //获取存档
    public Memoto getmMemoto() {
        return mMemoto;
    }
}

Caretaker类的职责很简单，就是负责管理Memoto对象，也就是备忘录对象。

ok，所有事情准备就绪，现在看下客户端的代码：

public class Client {
    public static void main(String[] args){
        // 构建游戏对象
        CallOfDuty game = new CallOfDuty();
        // 1. 打游戏
        game.play();

        Caretaker caretaker = new Caretaker();
        // 2. 游戏存档
        caretaker.archive(game.createMemoto());
        // 3. 退出游戏
        game.quit();
        // 4. 恢复游戏
        CallOfDuty newGame = new CallOfDuty();
        newGame.restore(caretaker.getmMemoto());
    }
}

运行结果：

玩游戏：第1关奋战杀敌中
进度升级了
到达第2关
-------------------
退出前的游戏熟悉：CallOfDuty{mCheckpoint=2, mLifeValue=90, mWeapon='沙漠之鹰'}
退出游戏
-------------------
恢复后的游戏属性：CallOfDuty{mCheckpoint=2, mLifeValue=90, mWeapon='沙漠之鹰'}

在这个过程中，各个角色职责清晰、单一，代码也比较简单，即对外屏蔽了对CallOfDuty角色的直接访问，在满足了对象状态存取功能的同时也使得该模块的结构保持清晰、整洁。

总结
备忘录模式是在不破坏封装的条件下，通过备忘录对象（Memoto）存储另外一个对象内部状态的快照，在将来合适的时候把这个对象还原到存储起来的状态。

优点

• 给用户提供了一种可以恢复的机制，可以使用户能够比较方便地回到某个历史的状态。
• 实现了信息的封装，使得用户不需要关心状态的保存细节。

缺点
消耗资源，如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的资源。