java设计模式——备忘录模式(Memento Pattern)

概述：
       备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，当前很多软件都提供了撤销(Undo)操作，其中就使用了备忘录模式。

定义：
       在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为Token。

结构：
Originator（原发器）：它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。
Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。
Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

UML图：





场景：如果大家玩过中国象棋的话，肯定会知道有一个悔棋的功能，当然，其他的军棋、五子棋、围棋等，都有这个功能，那么当需要悔棋时，系统会马上回到上一个状态，备忘录模式能很好的实现这个功能。

代码分析：

/**
 * Created by **
 * 原发器：定义棋子类
 */
public class Chessman {

    private String label;

    private int x;

    private int y;

    public Chessman(String label,int x,int y){

        this.label = label;

        this.x = x;

        this.y = y;

    }

    public void setLabel(String label) {

        this.label = label;

    }

    public void setX(int x) {

        this.x = x;

    }

    public void setY(int y) {

        this.y = y;

    }

    public String getLabel() {

        return label;

    }

    public int getX() {

        return x;

    }

    public int getY() {

        return y;

    }

    /**
     * 保存当前状态
     * @return
     */
   
public ChessmanMemento save(){

        return new ChessmanMemento(this.label,this.x,this.y);

    }

    /**
     * 恢复状态
     * @param memento
     */
   
public void restore(ChessmanMemento memento){

        this.label = memento.getLabel();

        this.x = memento.getX();

        this.y = memento.getY();

    }

}

/**
 * Created by **
 * 备忘录
 */
public class ChessmanMemento {

    private String label;

    private int x;

    private int y;

    public ChessmanMemento(String label,int x,int y){

        this.label = label;

        this.x = x;

        this.y = y;

    }

    public void setLabel(String label) {

        this.label = label;

    }

    public void setX(int x) {

        this.x = x;

    }

    public void setY(int y) {

        this.y = y;

    }

    public String getLabel() {

        return label;

    }

    public int getX() {

        return x;

    }

    public int getY() {

        return y;

    }

}

/**
 * Created by **
 * 负责人：备忘录管理类
 */
public class MementoManager {

    private ChessmanMemento memento;

    public void setMemento(ChessmanMemento memento) {

        this.memento = memento;

    }

    public ChessmanMemento getMemento() {

        return memento;

    }

}

客户端：

MementoManager manager = new MementoManager();

    Chessman chessman = new Chessman("炮", 2, 5);

    displayChessmanLocal(chessman);

    // 保存该棋子的状态
    ChessmanMemento save = chessman.save();

    manager.setMemento(save);

    chessman.setX(5);

    displayChessmanLocal(chessman);

    // 取出备忘录对象
    ChessmanMemento memento = manager.getMemento();

    // 悔棋
    LogFactory.log("------悔棋---------");

    chessman.restore(memento);

    displayChessmanLocal(chessman);

}

private void displayChessmanLocal(Chessman chessman){

    LogFactory.log("棋子："+chessman.getLabel()+",x:"+chessman.getX()+",y:"+chessman.getY());

}

log输出：
08-17 10:50:04.728 14147-14147/? D/test: 棋子：炮,x:2,y:5
08-17 10:50:04.728 14147-14147/? D/test: 棋子：炮,x:5,y:5
08-17 10:50:04.728 14147-14147/? D/test: ------悔棋---------
08-17 10:50:04.728 14147-14147/? D/test: 棋子：炮,x:2,y:5

      上述的代码只能悔一步棋，如果用一个集合来存储棋子的状态，那么就可以实现一直悔棋的功能了，现在只需修改部分代码：

/**
 * Created by **
 * 负责人：备忘录管理类
 */
public class MementoManager {

    // 用一个list集合来存储棋子状态
   
private List<ChessmanMemento> mementoList = new ArrayList<ChessmanMemento>();

    public void setMemento(ChessmanMemento memento) {

        this.mementoList.add(memento);

    }

    public ChessmanMemento getMemento(int i) {

        return this.mementoList.get(i);

    }

}

客户端：

private int index = -1;
private MementoManager manager;

manager = new MementoManager();

    Chessman chessman = new Chessman("炮", 2, 5);

    play(chessman);

    chessman.setX(3);

    play(chessman);

    chessman.setY(6);

    play(chessman);

    LogFactory.log("index = " + index);

    undo(chessman);

    LogFactory.log("index = " + index);

    undo(chessman);

}

private void play(Chessman chessman){

    ChessmanMemento saveMemento = chessman.save();

    manager.setMemento(saveMemento);

    index +=1;

    displayChessmanLocal(chessman);

}

private void undo(Chessman chessman){

    index -=1;

    ChessmanMemento chessmanMemento = manager.getMemento(index);

    chessman.restore(chessmanMemento);

    displayChessmanLocal(chessman);

}

private void displayChessmanLocal(Chessman chessman){

    LogFactory.log("棋子："+chessman.getLabel()+",x:"+chessman.getX()+",y:"+chessman.getY());

}

log输出：
08-17 11:13:03.227 19288-19288/? D/test: 棋子：炮,x:2,y:5
08-17 11:13:03.227 19288-19288/? D/test: 棋子：炮,x:3,y:5
08-17 11:13:03.227 19288-19288/? D/test: 棋子：炮,x:3,y:6
08-17 11:13:03.227 19288-19288/? D/test: index = 2
08-17 11:13:03.227 19288-19288/? D/test: 棋子：炮,x:3,y:5
08-17 11:13:03.227 19288-19288/? D/test: index = 1
08-17 11:13:03.227 19288-19288/? D/test: 棋子：炮,x:2,y:5

优点：
它提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原。
备忘录实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码所改动。备忘录保存了原发器的状态，采用列表、堆栈等集合来存储备忘录对象可以实现多次撤销操作。

缺点：
资源消耗过大，如果需要保存的原发器类的成员变量太多，就不可避免需要占用大量的存储空间，每保存一次对象的状态都需要消耗一定的系统资源。

适用场景：
保存一个对象在某一个时刻的全部状态或部分状态，这样以后需要时它能够恢复到先前的状态，实现撤销操作。
防止外界对象破坏一个对象历史状态的封装性，避免将对象历史状态的实现细节暴露给外界对象。

扩展：
       之前我们说过原型模式，这个模式能够克隆对象，并且跟被克隆的对象相互独立，那么在备忘录模式中我们可以跟原型模式结合使用，而且只需要修改其中部分代码：

在备忘录模式中，我们保存的是备忘录类的对象，只是这个对象跟原发器对象的属性是一致的而已。

/**
 * Created by **
 * 备忘录
 */
public class ChessmanMemento implements Cloneable{

    private String label;

    private int x;

    private int y;

    public ChessmanMemento(String label,int x,int y){

        this.label = label;

        this.x = x;

        this.y = y;

    }

    public void setLabel(String label) {

        this.label = label;

    }

    public void setX(int x) {

        this.x = x;

    }

    public void setY(int y) {

        this.y = y;

    }

    public String getLabel() {

        return label;

    }

    public int getX() {

        return x;

    }

    public int getY() {

        return y;

    }

    /**
     * clone 备忘录对象
     * @return
     * @throws CloneNotSupportedException
     */
   
@Override
    protected ChessmanMemento clone() throws CloneNotSupportedException {

        ChessmanMemento memento = null;

        memento = (ChessmanMemento) super.clone();

        return memento;

    }

}

客户端：
在客户端只需要将play方法修改一下就行了。

private void play(Chessman chessman){

    LogFactory.log("play is start");

    ChessmanMemento saveMementoClone = null;

    if (saveMemento == null) {

        LogFactory.log("play first start");

        saveMemento = chessman.save();

        manager.setMemento(saveMemento);

    }else{

        try {

            LogFactory.log("clone is start");

            saveMementoClone = saveMemento.clone();

            saveMementoClone.setX(chessman.getX());

            saveMementoClone.setY(chessman.getY());

            manager.setMemento(saveMementoClone);

        } catch (CloneNotSupportedException e) {

            e.printStackTrace();

        }

    }

    index +=1;

    displayChessmanLocal(chessman);

}

log输出：
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: play first start
08-18 16:09:52.640 12943-12943/? D/test: 棋子：炮,x:2,y:5
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: clone is start
08-18 16:09:52.640 12943-12943/? D/test: 棋子：炮,x:3,y:5
08-18 16:09:52.640 12943-12943/? D/test: play is start
08-18 16:09:52.640 12943-12943/? D/test: clone is start
08-18 16:09:52.640 12943-12943/? D/test: 棋子：炮,x:3,y:6
08-18 16:09:52.640 12943-12943/? D/test: index = 2
08-18 16:09:52.640 12943-12943/? D/test: 棋子：炮,x:3,y:5
08-18 16:09:52.640 12943-12943/? D/test: index = 1
08-18 16:09:52.640 12943-12943/? D/test: 棋子：炮,x:2,y:5

log分析：
       play方法第一次执行的时候会保存备忘录对象，但是第二次之后不再去创建备忘录对象了，而是直接clone之前的备忘录对象，并且将这个对象保存在list中。这里的log跟之前的log输出都是一样的，都能恢复到前一个状态。

要了解原型模式的戳这里：http://blog.csdn.net/yj_android_develop/article/details/52242738