Java 设计模式(21) —— 备忘录模式

一、备忘录模式

在不破坏封装的前提下，存储关键对象的重要状态，从而可以在将来把对象还原到存储的那个状态

备忘录模式

二、示例

游戏进度保存：游戏开发过程中需要对人物的属性进行缓存，例如血量、经验值等等，但是一个大的项目中时多人协同开发，每个开发人员完成不同的功能时需要保存不同的属性，并且保存的数据格式不同

为了解决多人协同开发，且每个开发者保存的数据属性，格式都不相同的缓存数据的问题，引入备忘录模式

备忘录模式通过定义一个统一的备忘录对象，用来存储和读取缓存信息，并定义一个统一的接口，开发人员将保存的对象都实现该接口即可实现统一的读取操作

1.定义备忘录对象

/**
 * 备忘录模式，开发人员使用的存储方法，用来保存和返回外部开发人员需要缓存的数据
 */
public class MementoCaretaker {
    private HashMap<String, MementoIF> mementomap;

    public MementoCaretaker() {
        mementomap = new HashMap<String, MementoIF>();
    }

    public MementoIF retrieveMemento(String name) {
        return mementomap.get(name);
    }

    /**
     * 备忘录赋值方法
     */
    public void saveMemento(String name, MementoIF memento) {
        this.mementomap.put(name, memento);
    }
}

2.定义开发者缓存对象需实现的接口

/**
 * 备忘录模式，定义接口，不需要写方法，起到安全保护和统一存储的作用
 */
public interface MementoIF {

}

3.不同的开发者内部实现自己不同的缓存方法和对象

/**
 * 备忘录模式，第一个开发者，使用HashMap缓存数据，通过Memento类实现接口MementoIF统一封装
 */
public class Originator {
    private HashMap<String, String> state;

    public Originator() {
        state = new HashMap();

    }

    public MementoIF createMemento() {
        return new Memento(state);
    }

    public void restoreMemento(MementoIF memento) {
        state = ((Memento) memento).getState();
    }

    public void showState() {
        System.out.println("now state:" + state.toString());
    }

    public void testState1() {
        state.put("blood", "500");
        state.put("progress", "gate1 end");
        state.put("enemy", "5");

    }

    public void testState2() {
        state.put("blood", "450");
        state.put("progress", "gate3 start");
        state.put("enemy", "3");

    }

    private class Memento implements MementoIF {

        private HashMap<String, String> state;

        private Memento(HashMap state) {
            this.state = new HashMap(state);
        }

        private HashMap getState() {
            return state;
        }

        private void setState(HashMap state) {
            this.state = state;
        }
    }
}

/**
 * 备忘录模式，第一个开发者，使用ArrayList缓存数据，通过Memento类实现接口MementoIF统一封装
 */
public class Originator2 {
    private ArrayList<String> state;

    public Originator2() {
        state = new ArrayList<String>();
    }

    public MementoIF createMemento() {
        return new Memento(state);
    }

    public void restoreMemento(MementoIF memento) {
        state = ((Memento) memento).getState();
    }

    public void testState1() {
        state = new ArrayList<String>();
        state.add("blood:320");
        state.add("progress:gate2 mid");
        state.add("enemy:15");

    }

    public void testState2() {
        state = new ArrayList<String>();
        state.add("blood:230");
        state.add("progress:gate8 last");
        state.add("enemy:12");

    }

    public void showState() {
        System.out.println("now state:" + state.toString());
    }

    private class Memento implements MementoIF {

        private ArrayList<String> state;

        private Memento(ArrayList<String> state) {
            this.state = new ArrayList(state);
        }

        private ArrayList<String> getState() {
            return state;
        }

        private void setState(ArrayList<String> state) {
            this.state = state;
        }
    }

}

4.外部直接使用备忘录对象进行存储，开发者之间互不干扰

/**
 * 备忘录模式：在不破坏封装的前提下，存储关键对象的重要状态，从而可以在将来把对象还原到存储的那个状态
 */
public class MainTest {

    public static void main(String[] args) {
        MementoCaretaker mMementoCaretaker = new MementoCaretaker();
        Originator mOriginator = new Originator();
        Originator2 mOriginator2 = new Originator2();

        System.out.println("*****Originator*****");
        mOriginator.testState1();

        // 保存第一个人的数据
        mMementoCaretaker.saveMemento("Originator", mOriginator.createMemento());
        mOriginator.showState();
        mOriginator.testState2();
        mOriginator.showState();

        // 重置数据
        mOriginator.restoreMemento(mMementoCaretaker.retrieveMemento("Originator"));
        mOriginator.showState();

        System.out.println("*****Originator 2*****");
        mOriginator2.testState1();
        mOriginator2.showState();

        // 保存第二个人的进度
        mMementoCaretaker.saveMemento("Originator2", mOriginator2.createMemento());
        mOriginator2.testState2();
        mOriginator2.showState();

        // 重置数据
        mOriginator2.restoreMemento(mMementoCaretaker.retrieveMemento("Originator2"));
        mOriginator2.showState();
}

三、总结

• 优点：

  • 状态存储在外面，不和关键对象混在一起，这可以帮助维护内聚
  • 提供了容易实现的恢复能力
  • 保持了关键对象的数据封装

• 缺点：

  • 资源消耗上面备忘录对象会很昂贵
  • 存储和恢复状态的过程比较耗时

• 适用场合：

  • 必须保存一个对象在某一个时刻的(整体或部分)状态，在对象以外的地方, 以后需要时恢复到先前的状态时

Java设计模式所有示例代码，持续更新中