瑞_23种设计模式_备忘录模式(快照模式)

文章目录

    • [1 备忘录模式(Memento Pattern)★](#1 备忘录模式(Memento Pattern)★)
      • [1.1 介绍](#1.1 介绍)
      • [1.2 概述](#1.2 概述)
      • [1.3 备忘录模式的结构](#1.3 备忘录模式的结构)
      • [1.4 备忘录模式的优缺点](#1.4 备忘录模式的优缺点)
      • [1.5 备忘录模式的使用场景](#1.5 备忘录模式的使用场景)
    • [2 案例一](#2 案例一)
      • [2.1 需求](#2.1 需求)
      • [2.2 "白箱"备忘录模式](#2.2 “白箱”备忘录模式)
      • [2.3 "黑箱"备忘录模式★★★](#2.3 “黑箱”备忘录模式★★★)
    • [3 案例二](#3 案例二)
      • [3.1 需求](#3.1 需求)
      • [3.2 代码实现](#3.2 代码实现)

🙊 前言:本文章为瑞_系列专栏之《23种设计模式》的备忘录模式篇。本文中的部分图和概念等资料,来源于博主学习设计模式的相关网站《菜鸟教程 | 设计模式》《黑马程序员Java设计模式详解》,特此注明。本文中涉及到的软件设计模式的概念、背景、优点、分类、以及UML图的基本知识和设计模式的6大法则等知识,建议阅读 《瑞_23种设计模式_概述》
本系列 - 设计模式 - 链接:《瑞_23种设计模式_概述》

⬇️本系列 - 创建型模式 - 链接🔗

单例模式:《瑞_23种设计模式_单例模式》

工厂模式:《瑞_23种设计模式_工厂模式》

原型模式:《瑞_23种设计模式_原型模式》

抽象工厂模式:《瑞_23种设计模式_抽象工厂模式》

建造者模式:《瑞_23种设计模式_建造者模式》

⬇️本系列 - 结构型模式 - 链接🔗

代理模式:《瑞_23种设计模式_代理模式》

适配器模式:《瑞_23种设计模式_适配器模式》

装饰者模式:《瑞_23种设计模式_装饰者模式》

桥接模式:《瑞_23种设计模式_桥接模式》

外观模式:《瑞_23种设计模式_外观模式》

组合模式:《瑞_23种设计模式_组合模式》

享元模式:《瑞_23种设计模式_享元模式》

⬇️本系列 - 行为型模式 - 链接🔗

模板方法模式:《瑞_23种设计模式_模板方法模式》

策略模式:《瑞_23种设计模式_策略模式》

命令模式:《瑞_23种设计模式_命令模式》

职责链模式:《瑞_23种设计模式_职责链模式》

状态模式:《瑞_23种设计模式_状态模式》

观察者模式:《瑞_23种设计模式_观察者模式》

中介者模式:《瑞_23种设计模式_中介者模式》

迭代器模式:《瑞_23种设计模式_迭代器模式》

访问者模式:《瑞_23种设计模式_访问者模式》

备忘录模式:《后续更新》

解释器模式:《后续更新》

1 备忘录模式(Memento Pattern)★

备忘录模式(Memento Pattern)保存一个对象的某个状态,以便在适当的时候恢复对象。备忘录模式属于行为型模式

瑞:行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。

瑞:行为型模式分为类行为模式对象行为模式 ,前者采用继承机制来在类间分派行为,后者采用组合或聚合 在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足"合成复用原则",所以对象行为模式比类行为模式具有更大的灵活性

备忘录模式属于:对象行为模式

1.1 介绍

  • 意图:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。

  • 主要解决:所谓备忘录模式就是在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态。

  • 何时使用:很多时候我们总是需要记录一个对象的内部状态,这样做的目的就是为了允许用户取消不确定或者错误的操作,能够恢复到他原先的状态,使得他有"后悔药"可吃。

  • 如何解决:通过一个备忘录类专门存储对象状态。

  • 关键代码:客户不与备忘录类耦合,与备忘录管理类耦合。

  • 应用实例

    1️⃣ 后悔药。

    2️⃣ 打游戏时的存档。

    3️⃣ Windows 里的 ctrl + z。

    4️⃣ IE 中的后退。

    5️⃣ 数据库的事务管理。

  • 优点

    1️⃣ 给用户提供了一种可以恢复状态的机制,可以使用户能够比较方便地回到某个历史的状态。

    2️⃣ 实现了信息的封装,使得用户不需要关心状态的保存细节。

  • 缺点

    1️⃣ 消耗资源。如果类的成员变量过多,势必会占用比较大的资源,而且每一次保存都会消耗一定的内存。

  • 使用场景

    1️⃣ 需要保存/恢复数据的相关状态场景。

    2️⃣ 提供一个可回滚的操作。

  • 注意事项

    1️⃣ 为了符合迪米特原则,还要增加一个管理备忘录的类。

    2️⃣ 为了节约内存,可使用原型模式+备忘录模式。

1.2 概述

定义:备忘录模式又叫快照模式,在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,以便以后当需要时能将该对象恢复到原先保存的状态。

备忘录模式提供了一种状态恢复的实现机制,使得用户可以方便地回到一个特定的历史步骤,当新的状态无效或者存在问题时,可以使用暂时存储起来的备忘录将状态复原,很多软件都提供了撤销(Undo)操作,如 Word、记事本、Photoshop、IDEA等软件在编辑时按 Ctrl+Z 组合键时能撤销当前操作,使文档恢复到之前的状态;还有在 浏览器 中的后退键、数据库事务管理中的回滚操作、玩游戏时的中间结果存档功能、数据库与操作系统的备份操作、棋类游戏中的悔棋功能等都属于这类。

1.3 备忘录模式的结构

  • 备忘录模式主要包含以下角色:
      1️⃣ 发起人(Originator)角色:记录当前时刻的内部状态信息,提供创建备忘录和恢复备忘录数据的功能,实现其他业务功能,它可以访问备忘录里的所有信息。
      2️⃣ 备忘录(Memento)角色:负责存储发起人的内部状态,在需要的时候提供这些内部状态给发起人。
      3️⃣ 管理者(Caretaker)角色:对备忘录进行管理,提供保存与获取备忘录的功能,但其不能对备忘录的内容进行访问与修改。

备忘录有两个等效的接口:

  • 窄接口:管理者(Caretaker)对象(和其他发起人对象之外的任何对象)看到的是备忘录的窄接口(narror Interface),这个窄接口只允许他把备忘录对象传给其他的对象。
  • 宽接口:与管理者看到的窄接口相反,发起人对象可以看到一个宽接口(wide Interface),这个宽接口允许它读取所有的数据,以便根据这些数据恢复这个发起人对象的内部状态。

1.4 备忘录模式的优缺点

优点

  • 提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。

  • 实现了内部状态的封装。除了创建它的发起人之外,其他对象都不能够访问这些状态信息。

  • 简化了发起人类。发起人不需要管理和保存其内部状态的各个备份,所有状态信息都保存在备忘录中,并由管理者进行管理,这符合单一职责原则。

缺点

  • 资源消耗大。如果要保存的内部状态信息过多或者特别频繁,将会占用比较大的内存资源。

1.5 备忘录模式的使用场景

  • 需要保存与恢复数据的场景,如玩游戏时的中间结果的存档功能。
  • 需要提供一个可回滚操作的场景,如 Word、记事本、Photoshop,idea等软件在编辑时按 Ctrl+Z 组合键,还有数据库中事务操作。

2 案例一

【案例】游戏挑战BOSS

2.1 需求

游戏中的某个场景,一游戏角色有生命力、攻击力、防御力等数据,在打Boss前和后一定会不一样的,我们允许玩家如果感觉与Boss决斗的效果不理想可以让游戏恢复到决斗之前的状态。

要实现上述案例,有两种方式:

  • "白箱"备忘录模式
  • "黑箱"备忘录模式

2.2 "白箱"备忘录模式

备忘录角色对任何对象都提供一个接口,即宽接口,备忘录角色的内部所存储的状态就对所有对象公开。类图如下:

代码如下:
游戏角色类(属于发起人角色)(类)

java 复制代码
/**
 * 游戏角色类(属于发起人角色)
 *
 * @author LiaoYuXing-Ray
 **/
public class GameRole {

    private int vit; // 生命力
    private int atk; // 攻击力
    private int def; // 防御力

    // 初始化内部状态
    public void initState() {
        this.vit = 100;
        this.atk = 100;
        this.def = 100;
    }

    // 战斗
    public void fight() {
        this.vit = 0;
        this.atk = 0;
        this.def = 0;
    }

    // 保存角色状态功能
    public RoleStateMemento saveState() {
        return new RoleStateMemento(vit,atk,def);
    }

    // 恢复角色状态
    public void recoverState(RoleStateMemento roleStateMemento) {
        // 将备忘录对象中存储的状态赋值给当前对象的成员
        this.vit = roleStateMemento.getVit();
        this.atk = roleStateMemento.getAtk();
        this.def = roleStateMemento.getDef();
    }

    // 展示状态功能
    public void stateDisplay() {
        System.out.println("角色生命力:" + vit);
        System.out.println("角色攻击力:" + atk);
        System.out.println("角色防御力:" + def);
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }
}

游戏状态存储类(备忘录角色类)(类)

java 复制代码
/**
 * 游戏状态存储类(备忘录角色类)
 *
 * @author LiaoYuXing-Ray
 **/
public class RoleStateMemento {

    private int vit; // 生命力
    private int atk; // 攻击力
    private int def; // 防御力

    public RoleStateMemento(int vit, int atk, int def) {
        this.vit = vit;
        this.atk = atk;
        this.def = def;
    }

    public RoleStateMemento() {
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }
}

备忘录对象管理对象(类)

java 复制代码
/**
 * 备忘录对象管理对象
 *
 * @author LiaoYuXing-Ray
 **/
public class RoleStateCaretaker {

    // 声明RoleStateMemento类型的变量
    private RoleStateMemento roleStateMemento;

    public RoleStateMemento getRoleStateMemento() {
        return roleStateMemento;
    }

    public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
        this.roleStateMemento = roleStateMemento;
    }
}

测试类

java 复制代码
/**
 * 测试类
 *
 * @author LiaoYuXing-Ray
 **/
public class Client {
    public static void main(String[] args) {
        System.out.println("---------------大战boos前-----------------");
        // 创建游戏角色对象
        GameRole gameRole = new GameRole();
        gameRole.initState();// 初始化状态操作
        gameRole.stateDisplay();

        // 将该游戏角色内部状态进行备份
        // 创建管理者对象
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
        roleStateCaretaker.setRoleStateMemento(gameRole.saveState());

        System.out.println("---------------大战boos后-----------------");
        // 损耗严重
        gameRole.fight();
        gameRole.stateDisplay();

        System.out.println("---------------恢复之前的状态-----------------");
        gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
        gameRole.stateDisplay();
    }
}

代码运行结果如下:

	---------------大战boos前-----------------
	角色生命力:100
	角色攻击力:100
	角色防御力:100
	---------------大战boos后-----------------
	角色生命力:0
	角色攻击力:0
	角色防御力:0
	---------------恢复之前的状态-----------------
	角色生命力:100
	角色攻击力:100
	角色防御力:100

分析:白箱备忘录模式是破坏封装性的。但是通过程序员自律,同样可以在一定程度上实现模式的大部分用意。

2.3 "黑箱"备忘录模式★★★

瑞:使用私有内部类进行封装

备忘录角色对发起人对象提供一个宽接口,而为其他对象提供一个窄接口。在Java语言中,实现双重接口的办法就是将备忘录类 设计成发起人类的内部成员类。

RoleStateMemento 设为 GameRole 的内部类,从而将 RoleStateMemento 对象封装在 GameRole 里面;在外面提供一个标识接口 MementoRoleStateCaretaker 及其他对象使用。这样 GameRole 类看到的是 RoleStateMemento 所有的接口,而RoleStateCaretaker 及其他对象看到的仅仅是标识接口 Memento 所暴露出来的接口,从而维护了封装型。

类图如下:

代码如下:

窄接口Memento,这是一个标识接口,因此没有定义出任何的方法
备忘录接口(窄接口)

java 复制代码
/**
 * 备忘录接口,对外提供窄接口
 *
 * @author LiaoYuXing-Ray
 **/
public interface Memento {
}

定义发起人类 GameRole,并在内部定义备忘录内部类 RoleStateMemento(该内部类设置为私有的)
游戏角色类(属于发起人角色)(类)

java 复制代码
/**
 * 游戏角色类(属于发起人角色)
 *
 * @author LiaoYuXing-Ray
 **/
public class GameRole {

    private int vit; // 生命力
    private int atk; // 攻击力
    private int def; // 防御力

    // 初始化内部状态
    public void initState() {
        this.vit = 100;
        this.atk = 100;
        this.def = 100;
    }

    // 战斗
    public void fight() {
        this.vit = 0;
        this.atk = 0;
        this.def = 0;
    }

    // 保存角色状态功能
    public Memento saveState() {
        return new RoleStateMemento(vit, atk, def);
    }

    // 恢复角色状态
    public void recoverState(Memento memento) {
        RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
        // 将备忘录对象中存储的状态赋值给当前对象的成员
        this.vit = roleStateMemento.getVit();
        this.atk = roleStateMemento.getAtk();
        this.def = roleStateMemento.getDef();
    }

    // 展示状态功能
    public void stateDisplay() {
        System.out.println("角色生命力:" + vit);
        System.out.println("角色攻击力:" + atk);
        System.out.println("角色防御力:" + def);
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    private static class RoleStateMemento implements Memento {
        private int vit; // 生命力
        private int atk; // 攻击力
        private int def; // 防御力

        public RoleStateMemento(int vit, int atk, int def) {
            this.vit = vit;
            this.atk = atk;
            this.def = def;
        }

        public RoleStateMemento() {
        }

        public int getVit() {
            return vit;
        }

        public void setVit(int vit) {
            this.vit = vit;
        }

        public int getAtk() {
            return atk;
        }

        public void setAtk(int atk) {
            this.atk = atk;
        }

        public int getDef() {
            return def;
        }

        public void setDef(int def) {
            this.def = def;
        }
    }
}

负责人角色类 RoleStateCaretaker 能够得到的备忘录对象是以 Memento 为接口的,由于这个接口仅仅是一个标识接口,因此负责人角色不可能改变这个备忘录对象的内容
备忘录对象管理对象(类)

java 复制代码
/**
 * 备忘录对象管理对象
 *
 * @author LiaoYuXing-Ray
 **/
public class RoleStateCaretaker {

    // 声明RoleStateMemento类型的变量
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

测试类

java 复制代码
/**
 * 测试类
 *
 * @author LiaoYuXing-Ray
 **/
public class Client {
    public static void main(String[] args) {
        System.out.println("---------------大战boos前-----------------");
        // 创建游戏角色对象
        GameRole gameRole = new GameRole();
        gameRole.initState(); // 初始化状态操作
        gameRole.stateDisplay();

        // 将该游戏角色内部状态进行备份
        // 创建管理者对象
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
        roleStateCaretaker.setMemento(gameRole.saveState());

        System.out.println("---------------大战boos后-----------------");
        // 损耗严重
        gameRole.fight();
        gameRole.stateDisplay();

        System.out.println("---------------恢复之前的状态-----------------");
        gameRole.recoverState(roleStateCaretaker.getMemento());
        gameRole.stateDisplay();
    }
}

代码运行结果如下:

	---------------大战boos前-----------------
	角色生命力:100
	角色攻击力:100
	角色防御力:100
	---------------大战boos后-----------------
	角色生命力:0
	角色攻击力:0
	角色防御力:0
	---------------恢复之前的状态-----------------
	角色生命力:100
	角色攻击力:100
	角色防御力:100

3 案例二

本案例为菜鸟教程中的案例

3.1 需求

备忘录模式使用三个类 Memento、Originator 和 CareTaker。Memento 包含了要被恢复的对象的状态。Originator 创建并在 Memento 对象中存储状态。Caretaker 对象负责从 Memento 中恢复对象的状态。

MementoPatternDemo,我们的演示类使用 CareTaker 和 Originator 对象来显示对象的状态恢复。

3.2 代码实现

步骤 1

创建 Memento 类。
Memento.java

java 复制代码
public class Memento {
   private String state;
 
   public Memento(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }  
}

步骤 2

创建 Originator 类。
Originator.java

java 复制代码
public class Originator {
   private String state;
 
   public void setState(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }
 
   public Memento saveStateToMemento(){
      return new Memento(state);
   }
 
   public void getStateFromMemento(Memento Memento){
      state = Memento.getState();
   }
}

步骤 3

创建 CareTaker 类。
CareTaker.java

java 复制代码
import java.util.ArrayList;
import java.util.List;
 
public class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();
 
   public void add(Memento state){
      mementoList.add(state);
   }
 
   public Memento get(int index){
      return mementoList.get(index);
   }
}

步骤 4

使用 CareTaker 和 Originator 对象。
MementoPatternDemo.java

java 复制代码
public class MementoPatternDemo {
   public static void main(String[] args) {
      Originator originator = new Originator();
      CareTaker careTaker = new CareTaker();
      originator.setState("State #1");
      originator.setState("State #2");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #3");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #4");
 
      System.out.println("Current State: " + originator.getState());    
      originator.getStateFromMemento(careTaker.get(0));
      System.out.println("First saved State: " + originator.getState());
      originator.getStateFromMemento(careTaker.get(1));
      System.out.println("Second saved State: " + originator.getState());
   }
}

步骤 5

执行程序,输出结果:

	Current State: State #4
	First saved State: State #2
	Second saved State: State #3

本文是博主的粗浅理解,可能存在一些错误或不完善之处,如有遗漏或错误欢迎各位补充,谢谢

如果觉得这篇文章对您有所帮助的话,请动动小手点波关注💗,你的点赞👍收藏⭐️转发🔗评论📝都是对博主最好的支持~

相关推荐
九圣残炎8 分钟前
【从零开始的LeetCode-算法】1456. 定长子串中元音的最大数目
java·算法·leetcode
wclass-zhengge10 分钟前
Netty篇(入门编程)
java·linux·服务器
Re.不晚37 分钟前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
雷神乐乐43 分钟前
Maven学习——创建Maven的Java和Web工程,并运行在Tomcat上
java·maven
码农派大星。1 小时前
Spring Boot 配置文件
java·spring boot·后端
顾北川_野1 小时前
Android 手机设备的OEM-unlock解锁 和 adb push文件
android·java
江深竹静,一苇以航1 小时前
springboot3项目整合Mybatis-plus启动项目报错:Invalid bean definition with name ‘xxxMapper‘
java·spring boot
confiself1 小时前
大模型系列——LLAMA-O1 复刻代码解读
java·开发语言
Wlq04151 小时前
J2EE平台
java·java-ee
XiaoLeisj1 小时前
【JavaEE初阶 — 多线程】Thread类的方法&线程生命周期
java·开发语言·java-ee