[设计模式/Java] 设计模式之备忘录模式【25】

概述：备忘录模式 ∈ 行为型模式

模式定义

  • 备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象
  • 备忘录模式属于行为型模式。
  • 备忘录模式允许在不破坏封装性的前提下，捕获和恢复对象的内部状态。
  • 模式的意图

在不破坏封装性的前提下，捕获一个对象的内部状态，并允许在对象之外保存和恢复这些状态。

  • 主要解决的问题
  • 允许捕获并保存一个对象的内部状态，以便在将来可以恢复到该状态，实现撤销和回滚操作。

模式的组成

模式组成

  • Originator(发起人)：

负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复状态。
Originator可根据需求决定Memento存储Originator的哪些内部状态。

  • Memento(备忘录)：

负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问备忘录Memento。
备忘录有两个接口，Caretaker只能看到备忘录的窄接口，它只能将备忘录传递给其他对象。
Originator能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据。

  • Caretaker(管理者)：

负责保存好备忘录Memento，但不能对备忘录的内容进行操作或检查。
管理者只能将备忘录传递给其他对象。

实现方式(1)

Originator : 发起者

public class Originator {

    //需要保存的属性
    private String state;

    //创建备忘录，将当前需要保存的信息导入并实例化出一个Memento对象
    public Memento createMemento() {
        return new Memento(state);
    }

    //恢复状态，通过将`Memento`导入并将相关数据恢复
    public void recoveryState(Memento memento) {
        this.state = memento.getState();
    }

    //显示数据
    public void show() {
        System.out.println("state = " + state);
    }

    public String getState() {
        return state;
    }

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

Memento : 备忘者

public class Memento {
    private String state;

    //构造方法，将相关数据导入
    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

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

CareTaker : 管理者

public class Caretaker {

    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

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

Client

public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        originator.setState("On");
        originator.show();
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMemento());

        originator.setState("Off");
        originator.show();
        originator.recoveryState(caretaker.getMemento());
        originator.show();
    }
}

out

state = On
state = Off
state = On

简单实现(2)

备忘录模式使用3个类 Memento、Originator 和 CareTaker。

Memento 包含了要被恢复的对象的状态。
Originator 创建并在 Memento 对象中存储状态。
Caretaker 对象负责从 Memento 中恢复对象的状态。

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

Memento

public class Memento {
   private String state;
 
   public Memento(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }  
}

Originator

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();
   }
}

CareTaker

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);
   }
}

Client

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());
   }
}

out

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

适用场景

  • 当需要提供一种撤销机制，允许用户回退到之前的状态时。

实现方式

  • 创建备忘录类：用于存储和封装对象的状态。
  • 创建发起人角色：负责创建备忘录，并根据需要恢复状态。
  • 创建备忘录管理类（可选）：负责管理所有备忘录对象。

关键代码

  • 备忘录：存储发起人的状态信息。
  • 发起人：创建备忘录，并根据备忘录恢复状态。

模式特点

优点

  • 提供状态恢复机制：允许用户方便地回到历史状态。
  • 封装状态信息：用户不需要关心状态的保存细节。

缺点

  • 资源消耗：如果对象的状态复杂，保存状态可能会占用较多资源。

使用建议

  • 在需要保存和恢复数据状态的场景中使用备忘录模式。

  • 考虑使用原型模式结合备忘录模式，以节约内存。

  • 为了降低耦合度，应通过备忘录管理类间接管理备忘录对象。

  • 备忘录模式应谨慎使用，避免过度消耗系统资源。

案例实践

CASE 后悔药

  • 后悔药：提供一种撤销操作的功能。

CASE 游戏存档

  • 游戏存档：保存游戏进度，允许玩家加载之前的存档。

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

GameRole/游戏角色类 : 发起者

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;
    }
}

RoleStateMemento/游戏状态存储类 : 备忘者

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 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/角色状态管理者 : 管理者

public class RoleStateCaretaker {
    private RoleStateMemento roleStateMemento;

    public RoleStateMemento getRoleStateMemento() {
        return roleStateMemento;
    }

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

Client

public class Client {
    public static void main(String[] args) {
        System.out.println("------------大战Boss前------------");
        //大战Boss前
        GameRole gameRole = new GameRole();
        gameRole.initState();
        gameRole.stateDisplay();

        //保存进度
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
        roleStateCaretaker.setRoleStateMemento(gameRole.saveState());
        System.out.println("------------大战Boss后------------");
        //大战Boss时，损耗严重
        gameRole.fight();
        gameRole.stateDisplay();
        System.out.println("------------恢复之前状态------------");
        //恢复之前状态
        gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
        gameRole.stateDisplay();
    }
}

out

------------大战Boss前------------
角色生命力：100
角色攻击力：100
角色防御力：100

------------大战Boss后------------
角色生命力：0
角色攻击力：0
角色防御力：0

------------恢复之前状态------------
角色生命力：100
角色攻击力：100
角色防御力：100

CASE 操作系统的撤销操作

  • Windows中的Ctrl+Z：实现撤销操作。

CASE 浏览器的后退

  • 浏览器的后退：允许用户回退到之前的页面。

CASE 数据库的事务回滚

  • 数据库事务管理：通过事务日志保存状态，实现回滚。

Y 推荐文献

X 参考文献

posted @ 2025-04-25 01:42  千千寰宇  阅读(40)  评论(0)    收藏  举报