19、行为型模式-备忘录设计模式

备忘录设计模式(Memento Pattern)

• 在不破坏封闭的前提下，捕获一个对象的内部状态，保存对象的某个状态，以便在适当的时候恢复对象，又叫做快照模式，属于行为模式
• 备忘录模式实现的方式需要保证被保存的对象状态不能被对象从外部访问，

应用场景

• 玩游戏的时候肯定有存档功能，下一次登录游戏时可以从上次退出的地方继续游戏
• 棋盘类游戏的悔棋、数据库事务回滚
• 需要记录一个对象的内部状态时，为了允许用户取消不确定或者错误的操作，能够恢复到原先的状态
• 提供一个可回滚的操作，如ctrl+z、浏览器回退按钮

角色

• Originator: 发起者，记录当前的内部状态，并负责创建和恢复备忘录数据，允许访问返回到先前状态所需的所有数据，可以根据需要决定Memento存储自己的哪些内部状态
• Memento: 备忘录，负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态
• Caretaker: 管理者，对备忘录进行管理、保存和提供备忘录，只能将备忘录传递给其他角色
• Originator 和 Memento属性类似

备忘录设计模式

需求背景

小滴课堂 - 二当家小D 开发了一个游戏存档功能 拳皇97，无限生命，每次快要死的的时候就恢复成刚开始的状态

使用备忘录设计模式帮他完成

代码：
角色发起者：

public class RoleOriginator {
    /**
     * 生命力，会下降
     */
    private int live = 100;
    /**
     * 攻击力，会上涨
     */
    private int attack = 50;

    public int getLive() {
        return live;
    }

    public void setLive(int live) {
        this.live = live;
    }

    public int getAttack() {
        return attack;
    }

    public void setAttack(int attack) {
        this.attack = attack;
    }

    public void display(){
        System.out.println("开始=========");
        System.out.println("生命力："+live);
        System.out.println("攻击力："+attack);
        System.out.println("结束=========");
    }

    public void fight(){
        //攻击力会上涨
        this.attack = attack+2;
        //打架生命力会下降
        this.live = live - 10;

    }
    /**
     * 保存快照，存储状态
     * @return
     */
    public RoleStateMemento saveState(){
        return new RoleStateMemento(live,attack);
    }
    /**
     * 恢复
     */
    public void recoveryState(RoleStateMemento memento){
        this.attack = memento.getAttack();
        this.live = memento.getLive();
    }
}

角色快照：

public class RoleStateMemento {
    /**
     * 生命力，会下降
     */
    private int live;
    /**
     * 攻击力，会上涨
     */
    private int attack ;
    public RoleStateMemento(int live, int attack) {
        this.live = live;
        this.attack = attack;
    }
    public int getLive() {
        return live;
    }
    public void setLive(int live) {
        this.live = live;
    }
    public int getAttack() {
        return attack;
    }
    public void setAttack(int attack) {
        this.attack = attack;
    }
}

管理者:

public class RoleStateCaretaker {
    private RoleStateMemento memento;
    public RoleStateMemento getMemento() {
        return memento;
    }
    public void setMemento(RoleStateMemento memento) {
        this.memento = memento;
    }
}

Main函数：

public class Main {

    public static void main(String[] args) {
        RoleOriginator role = new RoleOriginator();
        role.display();
        role.fight();
        role.display();

        System.out.println("保存上面的快照");
        RoleStateCaretaker caretaker = new RoleStateCaretaker();
        caretaker.setMemento(role.saveState());

        role.fight();
        role.fight();
        role.fight();
        role.fight();
        role.display();

        System.out.println("准备恢复快照");
        role.recoveryState(caretaker.getMemento());
        role.display();
    }
}

执行结果：

开始=========
生命力：100
攻击力：50
结束=========
开始=========
生命力：90
攻击力：52
结束=========
保存上面的快照
开始=========
生命力：50
攻击力：60
结束=========
准备恢复快照
开始=========
生命力：90
攻击力：52
结束=========

优点

• 给用户提供了一种可以恢复状态的机制
• 实现了信息的封装，使得用户不需要关心状态的保存细节

缺点

• 消耗更多的资源，而且每一次保存都会消耗一定的内存