读设计模式之禅--备忘录模式

于 2021-08-25 11:46:38 发布
阅读量146 收藏
点赞数
分类专栏： java设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/he_yanghui/article/details/119907814
版权

备忘录模式 对象状态 数据备份 恢复 封装
关键词由优快云通过智能技术生成
本文详细介绍了备忘录模式的概念和应用场景，通过实例展示了如何使用备忘录模式进行对象状态的保存与恢复。从单状态到多状态，再到多备份的备忘录模式实现，最后讨论了如何通过封装提高备忘录的安全性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

通俗地说，备忘录模式就是一个对象的备份模式，提供了一种程序数据的备份方法

package design.memorandum;

/**
 * @Author: hyh
 * @Date: 2021/8/24 10:09
 * 备忘录
 **/
public class Memorandum {
    private String state;

    public Memorandum(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

// 发起人
class Initiator {
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public Initiator(String state) {
        this.state = state;
    }

    // 创建备忘录
    public Memorandum createMemorandum() {
        return new Memorandum(this.state);
    }

    // 恢复备忘录
    public void resumeMemorandum(Memorandum memorandum) {
        this.setState(memorandum.getState());
    }
}
class Test {
    public static void main(String[] args) {
        Initiator initiator = new Initiator("开心");
         System.out.println(initiator.getState());
        // 创建备忘录
        Memorandum memorandum = initiator.createMemorandum();
        //改变状态
        initiator.setState("快乐");
        System.out.println(initiator.getState());
        //恢复备忘录
        initiator.resumeMemorandum(memorandum);
        System.out.println(initiator.getState());
    }
}
输出：
开心
快乐
开心

备忘录模式的使用场景

  • 需要保存和恢复数据的相关状态场景。
  • 提供一个可回滚（rollback）的操作；比如Word中的CTRL+Z组合键，IE浏览器中的后
    退按钮，文件管理器上的backspace键等。
  • 需要监控的副本场景中。例如要监控一个对象的属性，但是监控又不应该作为系统的
    主业务来调用，它只是边缘应用，即使出现监控不准、错误报警也影响不大，因此一般的做法是备份一个主线程中的对象，然后由分析程序来分析。
  • 数据库连接的事务管理就是用的备忘录模式，想想看，如果你要实现一个JDBC驱动，你怎么来实现事务？还不是用备忘录模式嘛！

clone方式的备忘录

// 通过对象复制实现状态备忘
class Initiator implements Cloneable{
    private String state;
    // 自己备忘录
    private Initiator Memorandum;

    public String getState() {
        return state;
    }
    
    public void setState(String state) {
        this.state = state;
    }

    public Initiator(String state) {
        this.state = state;
    }

    // 创建备忘录
    public void createMemorandum()   {
        try {
            this.Memorandum = (Initiator) this.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

    // 恢复备忘录
    public void resumeMemorandum() {
        this.setState(this.Memorandum.getState());
    }
}

class Test {
    public static void main(String[] args) {
        Initiator initiator = new Initiator("开心");

        // 创建备忘录
        initiator.createMemorandum();

        System.out.println(initiator.getState());

        initiator.setState("快乐");

        System.out.println(initiator.getState());
       
        initiator.resumeMemorandum();
        System.out.println(initiator.getState());
    }
}
输出：
开心
快乐
开心

多状态的备忘录模式

// 通过 map 记录 多状态备份  代码使用了 hutool 工具类
class Initiator {
    private String state1;
    private String state2;
    private String state3;
    private Map<String,Object> Memorandum = new HashMap<>();

    public Initiator(String state1, String state2, String state3) {
        this.state1 = state1;
        this.state2 = state2;
        this.state3 = state3;
    }

    public String getState1() {
        return state1;
    }

    public void setState1(String state1) {
        this.state1 = state1;
    }

    public String getState2() {
        return state2;
    }

    public void setState2(String state2) {
        this.state2 = state2;
    }

    public String getState3() {
        return state3;
    }

    public void setState3(String state3) {
        this.state3 = state3;
    }

    // 创建备忘录
    public void createMemorandum()   {
        this.Memorandum = BeanUtil.beanToMap(this);
    }

    // 恢复备忘录
    public void resumeMemorandum() {
        BeanUtil.fillBeanWithMap(this.Memorandum,this,true);
    }
}

class Test {
    public static void main(String[] args) {
        Initiator initiator = new Initiator("开心","快乐","愉悦");

        // 创建备忘录
        initiator.createMemorandum();

        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

        initiator.setState1("悲伤");
        initiator.setState2("气愤");
        initiator.setState3("伤心");

        System.out.println(initiator.getState1() 
         + initiator.getState2()+ initiator.getState3());
        initiator.resumeMemorandum();
        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

    }
}
输出：
开心快乐愉悦
悲伤气愤伤心
开心快乐愉悦

多备份的备忘录

// 通过 map 记录 多状态备份  代码使用了 hutool 工具类  
//当然，也可以将下面代码分成 发起人 备忘录和备忘录管理三个类，就会清晰许多
class Initiator {
    private String state1;
    private String state2;
    private String state3;
    private Map<String,Object> Memorandum = new HashMap<>();
    private Map<String,Map> MemorandumManage = new HashMap<>();

    public Initiator(String state1, String state2, String state3) {
        this.state1 = state1;
        this.state2 = state2;
        this.state3 = state3;
    }

    public String getState1() {
        return state1;
    }

    public void setState1(String state1) {
        this.state1 = state1;
    }

    public String getState2() {
        return state2;
    }

    public void setState2(String state2) {
        this.state2 = state2;
    }

    public String getState3() {
        return state3;
    }

    public void setState3(String state3) {
        this.state3 = state3;
    }

    // 创建备忘录
    public void createMemorandum(String sign)   {
        this.MemorandumManage.put(sign,BeanUtil.beanToMap(this));
    }

    // 恢复备忘录
    public void resumeMemorandum(String sign) {
        BeanUtil.fillBeanWithMap(this.MemorandumManage.get(sign),this,true);
    }
}

class Test {
    public static void main(String[] args) {
        Initiator initiator = new Initiator("开心","快乐","愉悦");

        // 创建备忘录
        initiator.createMemorandum("001");

        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

        initiator.setState1("悲伤");
        initiator.setState2("气愤");
        initiator.setState3("伤心");
        // 创建备忘录
        initiator.createMemorandum("002");

        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());
        initiator.resumeMemorandum("002");
        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

    }
}
输出：
开心快乐愉悦
悲伤气愤伤心
悲伤气愤伤心
class Test {
    public static void main(String[] args) {
        Initiator initiator = new Initiator("开心","快乐","愉悦");

        // 创建备忘录
        initiator.createMemorandum("001");

        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

        initiator.setState1("悲伤");
        initiator.setState2("气愤");
        initiator.setState3("伤心");
        // 创建备忘录
        initiator.createMemorandum("002");

        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());
        initiator.resumeMemorandum("001");
        System.out.println(initiator.getState1()  
        + initiator.getState2()+ initiator.getState3());

    }
}
输出：
开心快乐愉悦
悲伤气愤伤心
开心快乐愉悦

封装得更好一点
在系统管理上，一个备份的数据是完全、绝对不能修改的，它保证数据的洁净，避免数 据污染而使备份失去意义。在我们的设计领域中，也存在着同样的问题，备份是不能被篡改的，也就是说需要缩小备份出的备忘录的阅读权限，保证只能是发起人可读就成了，那怎么才能做到这一点呢？使用内置类

interface IMemento {
}

class Originator {
    //内部状态
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    //创建一个备忘录
    public IMemento createMemento() {
        return new Memento(this.state);
    }

    //恢复一个备忘录
    public void restoreMemento(IMemento _memento) {
        this.setState(((Memento) _memento).getState());
    }

    //内置类
    private class Memento implements IMemento {
        //发起人的内部状态
        private String state = "";

        //构造函数传递参数
        private Memento(String _state) {
            this.state = _state;
        }

        private String getState() {
            return state;
        }

        private void setState(String state) {
            this.state = state;
        }
    }
}
//内置类Memento全部是private的访问权限，也就是说除了发起人外，别人休想访问到，
//那如果要产生关联关系又应如何处理呢？通过接口！别忘记了我们还有一个空接口是公共的访问权限
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值