备忘录模式---Memento

Posted 2021-09-05 高高for 循环

备忘录模式

定义:

备忘录模式（Memento Pattern）又称之为快照模式(Snapshop Pattern)或者令牌模式(Token Pattern).

是指在不破坏封装的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，这样我们就可以在需要的时候将该对象恢复到原先保存的状态了，备忘录模式属于行为型模式。

备忘录模式----应用实例:

1. 打游戏时的存档
2. 记录快照
3. Windows 里的 ctri + z。
4. IE 中的后退。
5. 数据库的事务管理。

组成:

备忘录模式 分类:

备忘录角色要保持完整的封装。最好的情况便是：备忘录角色只应该暴露操作内部存储属性的的接口给“备忘发起角色”。而对于其他角色则是不可见的

备忘录模式又可以分为“白箱”备忘录模式和“黑箱”备忘录模式。

“白箱”备忘录模式

• 备忘录角色提供一个宽接口的话，备忘录的内部存储状态就对所有对象公开，这就是“白箱实现”。
• “白箱”实现破坏了封装性，但是通过程序员自律，可以方便地实现备忘录模式。

“黑箱”备忘录模式

采用内部类来控制访问权限。将备忘录角色作为“备忘发起角色”的一个私有内部类。

1. 将Memento设成Originator类的内部类；
2. 将Memento的方法全部设成私有方法，这样只有它自己和发起人Originator可以调用；
3. 在外部提供一个标识接口MementoIF给Caretaker以及其他对象，标识接口MementoIF没有提供任何方法，因此对外部来说Memento对象的内容都是不可见的。

案例实现

需求: 建立一个类来保存最新文章信息：

“白箱”备忘录模式

文本类 : ArticleText

public class ArticleText {
    private String title;
    private String content;
    private Date createTime;

    public ArticleText(String title, String content, Date createTime) {
        this.title = title;
        this.content = content;
        this.createTime = createTime;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public ArticleMemento saveToMemento(){
        ArticleMemento articleMemento = new ArticleMemento(this.title,this.content,this.createTime);
        return articleMemento;
    }

    public void getArticleFromMemento(ArticleMemento articleMemento){
        this.title = articleMemento.getTitle();
        this.content = articleMemento.getContent();
        this.createTime = articleMemento.getCreateTime();
    }

    @Override
    public String toString() {
        return "ArticleText{" +
                "title='" + title + '\\'' +
                ", content='" + content + '\\'' +
                ", createTime=" + createTime +
                '}';
    }
}

备忘录角色 : ArticleMemento

• 建立一个类用来保存历史数据，这个类的信息必须要和原始类一样，否则无法完全备份：

//备忘录角色
public class ArticleMemento {

    private String title;
    private String content;
    private Date createTime;

    public ArticleMemento(String title, String content, Date createTime) {
        this.title = title;
        this.content = content;
        this.createTime = createTime;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

}

备忘录管理者角色: ArticleCaretaker

//备忘录管理者角色
public class ArticleCaretaker {
    private final List<ArticleMemento> list = new ArrayList<>();

    public ArticleMemento getArticle(int index){
        return list.get(index);
    }

    public void setArticle(ArticleMemento articleMemento){
        list.add(articleMemento);
    }
}

测试类 ArticleTest01

public class ArticleTest01 {
    public static void main(String[] args) {

        //1. 新创建一个文本
        ArticleText articleText = new ArticleText("标题1","内容1",new Date());
        System.out.println("新建时 :  "+articleText.toString());

        //保存文本,备忘录
        ArticleMemento articleMemento = articleText.saveToMemento();
        //创建备忘录管理真
        ArticleCaretaker articleCaretaker = new ArticleCaretaker();
        articleCaretaker.setArticle(articleMemento);//备忘1次

        //2.修改文本
        articleText = new ArticleText("标题2","内容2",new Date());
        System.out.println("修改后 :  "+articleText.toString());


        //3.回退到记录之前的版本
        articleText.getArticleFromMemento(articleCaretaker.getArticle(0));
        System.out.println("还原后 :  "+articleText.toString());
    }

}

“黑箱”备忘录模式

• 将Memento设成Originator类的内部类；
• 将Memento的方法全部设成私有方法，这样只有它自己和发起人Originator可以调用；
• 在外部提供一个标识接口MementoIF给Caretaker以及其他对象，标识接口MementoIF没有提供任何方法，因此对外部来说Memento对象的内容都是不可见的。

标识接口: MementoIF

• 标识接口MementoIF没有提供任何方法，因此对外部来说Memento对象的内容都是不可见的。

public interface MementoIF {
}

文本类 : ArticleText02

将Memento设成Originator类的内部类；

import java.util.Date;

public class ArticleText02 {
    private String title;
    private String content;
    private Date createTime;

    //保持一个“备忘录管理者角色”的对象
    private ArticleCaretaker02 caretaker = new ArticleCaretaker02();

    public ArticleText02(String title, String content, Date createTime) {
        this.title = title;
        this.content = content;
        this.createTime = createTime;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public int saveToMemento() {
        int stateIndex = caretaker.setArticle(new ArticleMemento2(this.title, this.content, this.createTime));
        return stateIndex;
    }

    public void getArticleFromMemento(int index) {
        ArticleMemento2 articleMemento = (ArticleMemento2)caretaker.getArticle(index);
        this.title = articleMemento.getTitle();
        this.content = articleMemento.getContent();
        this.createTime = articleMemento.getCreateTime();
    }


    public void modifyState(String title, String content, Date createTime){
        this.title = title;
        this.content = content;
        this.createTime = createTime;
    }


    @Override
    public String toString() {
        return "ArticleText{" +
                "title='" + title + '\\'' +
                ", content='" + content + '\\'' +
                ", createTime=" + createTime +
                '}';
    }


    //作为私有内部类的备忘录角色，它实现了窄接口，可以看到在第二种方法中宽接口
    private class ArticleMemento2 implements MementoIF {
        //注意：里面的属性和方法都是私有的
        private String title;
        private String content;
        private Date createTime;

        private ArticleMemento2(String title, String content, Date createTime) {
            this.title = title;
            this.content = content;
            this.createTime = createTime;
        }

        private String getTitle() {
            return title;
        }

        private void setTitle(String title) {
            this.title = title;
        }

        private String getContent() {
            return content;
        }

        private void setContent(String content) {
            this.content = content;
        }

        private Date getCreateTime() {
            return createTime;
        }

        private void setCreateTime(Date createTime) {
            this.createTime = createTime;
        }

    }
}

备忘录管理者角色: ArticleCaretaker02

public class ArticleCaretaker02 {
    int stateIndex=-1;

    private final List<MementoIF> list = new ArrayList<>();

    public MementoIF getArticle(int index){
        return list.get(index);
    }

    public int setArticle(MementoIF articleMemento){
        list.add(articleMemento);
        return ++stateIndex;
    }
}

测试类: ArticleTest02

public class ArticleTest02 {
    public static void main(String[] args) {

        //1. 新创建一个文本
        ArticleText02 articleText = new ArticleText02("标题1","内容1",new Date());
        System.out.println("新建时 :  "+articleText.toString());

        //保存文本,备忘录
        int state = articleText.saveToMemento();

        //2.修改文本
        articleText.modifyState("标题888","内容888",new Date());
        System.out.println("修改后 :  "+articleText.toString());

        //3.回退到记录之前的版本
        articleText.getArticleFromMemento(state);
        System.out.println("还原后 :  "+articleText.toString());
    }

}

备忘录模式Spring源码中的提现

类StateManageableMessageContext中

总结

应用场景:

1. 需要保存历史快照的场景
2. 希望在对象之外保存状态，且除了自己其他对象无法访问状态的具体保存内容
3. 如果系统需要提供回滚操作时，使用备忘录模式非常合适。例如文本编辑器的Ctrl+Z撤销操作的实现，
4. 数据库中事务操作。

优点:

• 简化了发起人的的职责，将状态的存储和获取进行了隔离，而且客户端无需关心状态的保存细节。

缺点:

• 消耗资源，如果每个快照的内容都非常大，会消耗大量内存。

注意事项:

1. 为了符合迪米特原则，还要增加一个管理备忘录的类。
2. 为了节约内存，可使用原型模式+备忘录模式。