一文彻底搞明白备忘录模式

开发 前端
面向对象程序中,一个类在生命周期过程中,其属性构成的状态是会不断变化的。这种变化会带来很多不确定性,尤其在多线程场景下,可能也会引发一些意想不到的问题。

本篇讲解Java设计模式中的备忘录模式,分为定义、模式应用前案例、结构、模式应用后案例、适用场景、模式可能存在的困惑和本质探讨7个部分。

定义

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

在新的分类方式中,备忘录模式被划分至类属性相关需求类别中,其应对的是类的状态属性需要恢复的要求。

模式应用前案例

文本编辑器是一个备忘录模式的典型应用场景。接下来,先来看一下未使用备忘录模式之前的代码实现。

public class TextEditor {//编辑器类-直接实现保存和恢复操作
private String content;
private String previousContent;

public void write(String text) {
if(this.content == null ) {
this.content = "";
        }
this.content += text;
    }

// 保存当前内容为上一个版本的状态
public void save() {
this.previousContent = this.content;
    }

// 恢复到上一个版本的状态
public void undo(){
if(this.previousContent != null){
this.content = this.previousContent;
        }
    }

// 获取内容
public String getContent(){
return this.content;
    }

}

public class Client {//调用方代码
public static void main(String[] ars){

        TextEditor editor=new TextEditor();

        editor.write("Hello, ");
        System.out.println(editor.getContent());

        editor.save();

        editor.write("World!");

        System.out.println(editor.getContent());

        editor.undo();

        System.out.println(editor.getContent());
    }
}

在上述代码中,主要问题出现在TextEditor类中。为了实现恢复到上一步这个操作,在类中增加了previousContent属性。

如果这个功能是后来才需要增加的,则违背了OCP开闭原则。此外,如果后续要增加恢复上两步的操作,是否还要新增一个doublepreviousContent属性。显然,对于这种类状态(或属性)有变化且能够恢复的场景,应该有更好的解决方案。

结构

备忘录模式的示例实现代码如下。

public class Originator {
private String state;

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

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

public String getState() {
return state;
    }

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

public class Memento{
private final String state;

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

public String getState() {
return state;
    }

}

public class Caretaker {

private Memento memento;

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

public Memento getMemento() {
return memento;
    }
}

public class Client {
public static void main(String[] args) {
// 创建Originator对象
        Originator originator = new Originator();

// 设置初始状态
        originator.setState("State 1");
        System.out.println("Initial State: " + originator.getState());

// 创建Caretaker对象并保存备忘录
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMemento());

// 改变Originator的状态
        originator.setState("State 2");
        System.out.println("State after change: " + originator.getState());

// 恢复到之前保存的状态
        originator.setMemento(caretaker.getMemento());
        System.out.println("State after restore: " + originator.getState());
    }
}

从备忘录模式的结构和示例代码中,可以看到原有类Originator仅保留了与自身核心业务功能相关的属性,并将其需要恢复状态的属性state放在一个Memento类中保存。

Originator增加了两个比较简洁的方法,一个是创建Memento,一个是从Memento中恢复,所以setMemento方法使用restoreFromMemento会更加准确。

同时,增加了一个Caretaker类,它用于保存、恢复Memento。是恢复到上一个状态还是上两个状态都由Caretaker类专门负责。

不难发现,在备忘录模式下,各个类职责分工明确,核心类Originator专注于核心业务功能,Memento和Caretaker两个支撑类则用于实现状态的保存和恢复。

模式应用后案例

上面文本编辑器的案例,在应用备忘录模式之后的代码实现如下。

TextEditor类删掉了PreviousContent属性,职责更加单一。

public class TextEditor {// 编辑器类(Originator)- 负责创建备忘录和恢复到之前状态

private String content;

public void write(String text) {
if(this.content == null) {
this.content = "";
        }
this.content += text;
    }

// 创建当前内容对应的备份
public EditorMemento createMemento(){
return new EditorMemento(this.content);
    }

// 从传入Mememtor对象中获取内容并进行还原
public void restoreFromMemento(EditorMemento memento){
this.content = memento.getContent();
    }

public String getContent() {
return this.content;
    }
}

增加EditorMemento和UndoManager两个类,分别实现TextEditor中Content属性的保存,以及EditorMemento的管理。

public class EditorMemento {// 备忘录类(Memento)- 存储文本编辑器的状态

private final String content;

public EditorMemento(String content) {
this.content = content;
    }

public String getContent() {
return this.content;
    }

}

public class UndoManager {// 管理者类(Caretaker)-负责管理保存和恢复操作

    Stack<EditorMemento> emStack =new Stack<>();

public void save(EditorMemento memento){
this.emStack.push(memento);
    }

public EditorMemento undo(){
if(!this.emStack.empty()){
return this.emStack.pop();
        }
return null;
    }
}

最后,调用方代码如下。

public class Client {//调用方代码

public static void main(String[] ars){

        TextEditor editor = new TextEditor();

        UndoManager undoManager=new UndoManager();

        editor.write("Hello, ");

        undoManager.save(editor.createMemento());

        editor.write("World!");

//undoManager.save(editor.createMemento());

        System.out.println(editor.getContent());

        editor.restoreFromMemento(undoManager.undo());

        System.out.println(editor.getContent());
    }
}

适用场景

备忘录模式适用的场景非常明确,就是原有类在生命周期变化过程中,其属性的状态还可能需要恢复的场景。

模式可能存在的困惑

困惑1:为什么要有Caretaker类,为什么不能在Memento或Originator中实现保存和恢复功能,这样程序更加简洁?

如果在Originator中实现,又违背了SRP单一职责和OCP开闭原则;如果在Memento实现,这个类功能会变多,每次在Originator中创建Memento对象会占用更多内存,从这个角度就不合适。

困惑2:Memento类只是一个数据的封装类,为什么Originator的状态属性不能直接放在Caretaker中通过一个数据属性来实现?

实际上,许多人在考虑状态恢复的策略时,通常会优先想到这个方案。为了更好地进行说明,这里将代码实现罗列出来。

public class TextEditor {// 编辑器类(Originator)- 负责创建备忘录和恢复到之前状态

private String content;

public void write(String text) {
if(this.content == null) {
this.content = "";
        }
this.content += text;
    }

// 创建当前内容对应的备份
public void saveContent(){
        UndoManager.save(this.content);
    }

// 获取内容并进行还原
public void restoreFromContent(){
this.content = UndoManager.undo();
    }

public String getContent() {
return this.content;
    }
}

public class UndoManager {// 管理者类(Caretaker)-负责管理保存和恢复操作

private static final Stack<String> emStack =new Stack<>();

public static void save(String content){
        emStack.push(content);
    }

public static String undo(){
if(!emStack.empty()){
return emStack.pop();
        }
return null;
    }
}
public class Client {//调用方代码

public static void main(String[] ars){

        TextEditor editor = new TextEditor();

        editor.write("Hello, ");

        editor.saveContent();

        editor.write("World!");

        System.out.println(editor.getContent());

        editor.restoreFromContent();

        System.out.println(editor.getContent());
    }
}

这种方式下,似乎实现起来更加简洁清晰。然而,缺点也比较明显。TextEditor与UndoManager紧耦合的情况下,如果TextEditor要求也能够实现恢复到前两个状态,此时UndoManager增加了一个undo2的方法,那么TextEditor也需要一并修改。

但是在备忘录模式下,TextEditor相当于至于纯数据类Memento进行交互,面对上面的需求并不需要修改,只需要将上两个的Memento传参即可。

困惑3:在关于备忘录模式的一些材料中,会看到宽接口和窄接口,具体是什么含义?

宽接口指的是Memento备忘录对象提供给Originator访问其内部状态的全部信息,包括私有数据。因为Memento里的数据其实就是Originator中要保存、恢复状态的数据,因此Originator需要能访问到具体的数据信息才可以。

窄接口指的是Memento备忘录对象对Caretaker对象指提供必要的信息进行访问和恢复操作。因为Caretaker对象需要是是Memento对象自身,并不需要访问Memento中的数据,因此称之为窄接口。

困惑4:备忘录模式实现之后,对于调用方的交互似乎变得更加复杂?

一件事情往往有得必有失,很难做到两全其美。为了使得Originator不违背SRP单一职责和OCP开闭原则,Client只能增加交互。

如果在Client和备忘录模式的类之间增加一个中间代理类,这样可以减少与调用方之间的交互,但是代价是又新增一个支撑类。

本质

面向对象程序中,一个类在生命周期过程中,其属性构成的状态是会不断变化的。这种变化会带来很多不确定性,尤其在多线程场景下,可能也会引发一些意想不到的问题。因此,Java语言中经常提倡要利用不变性、局部变量等应对这种不确定性。

然而,在某些现实场景下,类随着时间不断变化是有必要的,并且要求还能沿着时间向后回退。此时,备忘录提供了一种管理对象状态的机制,并且让原有对象维持良好的封装性。

责任编辑:武晓燕 来源: 今日头条
相关推荐

2024-05-13 10:45:25

中介模式面向对象数量

2024-05-09 09:09:19

组合模式对象

2024-05-10 08:43:04

外观模式接口系统

2024-05-11 14:18:44

迭代器模式业务

2024-05-17 10:08:59

享元模式分类方式

2019-08-27 14:46:59

ElasticSearES数据库

2020-11-02 10:41:33

备忘录模式

2023-10-07 00:14:53

2020-07-10 08:03:35

DNS网络ARPAne

2023-10-31 09:07:16

备忘录模式保存

2018-12-24 21:40:12

2023-10-10 15:26:30

内存泄露OOM

2014-04-17 10:30:41

Linux 命令黑白备忘录

2017-03-21 11:02:59

基础深度学习备忘录

2011-04-11 10:03:32

钱伯斯思科

2011-08-16 18:38:23

Core Animat动画

2019-09-09 11:02:17

Nginx进程模型

2023-05-29 08:45:45

Java注解数据形式

2018-06-20 13:14:16

MySQL数据优化查询备忘录

2013-08-29 10:50:48

移动网站性能优化移动web
点赞
收藏

51CTO技术栈公众号