1. 首页
  2. 设计模式

「补课」进行时:设计模式(17)——备忘录模式

「补课」进行时:设计模式(17)——备忘录模式

1. 前文汇总

「补课」进行时:设计模式系列

2. 从版本控制开始

相信每个程序猿,每天工作都会使用版本控制工具,不管是微软提供的 vss 还是 tfs ,又或者是开源的 svn 或者 git ,每天下班前,总归会使用版本控制工具提交一版代码。

版本管理工具是让我们在代码出问题的时候,可以方便的获取到之前的版本进行版本回退,尤其是在项目发布投运的时候,当出现问题的时候直接获取上一个版本进行回滚操作。

在这个操作中间,最重要的就是保存之前的状态,那么如何保存之前的状态?

操作很简单,我们可以定义一个中间变量,保留这个原始状态。

先定义一个版本管理 Git 类:

public class Git {
    private String state;
    // 版本发生改变,现在是 version2
    public void changeState() {
        this.state = "version2";
    }

    public String getState() {
        return state;
    }

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

然后是一个场景 Client 类:

public class Client {
    public static void main(String[] args) {
        Git git = new Git();
        // 初始化版本
        git.setState("version1");
        System.out.println("当前的版本信息:");
        System.out.println(git.getState());
        // 记录下当前的状态
        Git backup = new Git();
        backup.setState(git.getState());
        // 提交一个版本,版本进行改变
        git.changeState();
        System.out.println("提交一个版本后的版本信息:");
        System.out.println(git.getState());
        // 回退一个版本,版本信息回滚
        git.setState(backup.getState());
        System.out.println("回退一个版本后的版本信息:");
        System.out.println(git.getState());
    }
}

执行结果:

当前的版本信息:
version1
提交一个版本后的版本信息:
version2
回退一个版本后的版本信息:
version1

程序运行正确,输出结果也是我们期望的,但是结果正确并不表示程序是合适的。

在场景类 Client 类中,这个是高层模块,现在却在高层模块中做了中间临时变量 backup 的状态的保持,为什么一个状态的保存和恢复要让高层模块来负责呢?

这个中间临时变量 backup 应该是 Git 类的职责,而不是让一个高层次的模块来进行定义。

我们新建一个 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;
    }
}

新建一个 Memento ,用构造函数来传递状态 state ,修改上面的 Git 类,新增两个方法 createMemento()restoreMemento(),用来创建备忘录以及恢复一个备忘录。

public class Git {
    private String state;
    // 版本发生改变,现在是 version2
    public void changeState() {
        this.state = "version2";
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
    // 创建一个备忘录
    public Memento createMemento(String state) {
        return new Memento(state);
    }
    // 恢复一个备忘录
    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }
}

修改后的场景类:

public class Client {
    public static void main(String[] args) {
        Git git = new Git();
        // 初始化版本
        git.setState("version1");
        System.out.println("当前的版本信息:");
        System.out.println(git.getState());
        // 记录下当前的状态
        Memento mem = git.createMemento(git.getState());
        // 提交一个版本,版本进行改变
        git.changeState();
        System.out.println("提交一个版本后的版本信息:");
        System.out.println(git.getState());
        // 项目发布失败,回滚状态
        git.restoreMemento(mem);
        System.out.println("回退一个版本后的版本信息:");
        System.out.println(git.getState());
    }
}

运行结果和之前的案例保持一致,那么这就结束了么,当然没有,虽然我们在 Client 中不再需要重复定义 Git 类了,但是这是对迪米特法则的一个亵渎,它告诉我们只和朋友类通信,那这个备忘录对象是我们必须要通信的朋友类吗?对高层模块来说,它最希望要做的就是创建一个备份点,然后在需要的时候再恢复到这个备份点就成了,它不用关心到底有没有备忘录这个类。

那我们可以对这个备忘录的类再做一下包装,创建一个管理类,专门用作管理这个备忘录:

public class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

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

非常简单纯粹的一个 JavaBean ,甭管它多简单,只要有用就成,我们来看场景类如何调用:

public class Client {
    public static void main(String[] args) {
        Git git = new Git();
        // 创建一个备忘录管理者
        Caretaker caretaker = new Caretaker();
        // 初始化版本
        git.setState("version1");
        System.out.println("当前的版本信息:");
        System.out.println(git.getState());
        // 记录下当前的状态
        caretaker.setMemento(git.createMemento(git.getState()));
        // 提交一个版本,版本进行改变
        git.changeState();
        System.out.println("提交一个版本后的版本信息:");
        System.out.println(git.getState());
        // 项目发布失败,回滚状态
        git.restoreMemento(caretaker.getMemento());
        System.out.println("回退一个版本后的版本信息:");
        System.out.println(git.getState());
    }
}

现在这个备份者就类似于一个备份的仓库管理员,创建一个丢进去,需要的时候再拿出来。这就是备忘录模式。

3. 备忘录模式

3.1 定义

备忘录模式(Memento Pattern)提供了一种弥补真实世界缺陷的方法,让“后悔药”在程序的世界中真实可行,其定义如下:

Without violating encapsulation,capture and externalize an object’s internalstate so that the object can be restored to this state later.(在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。)

3.2 通用类图

「补课」进行时:设计模式(17)——备忘录模式

  • Originator 发起人角色:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和恢复备忘录数据。
  • Memento 备忘录角色:负责存储 Originator 发起人对象的内部状态,在需要的时候提供发起人需要的内部状态。
  • Caretaker 备忘录管理员角色:对备忘录进行管理、保存和提供备忘录。

3.3 通用代码

发起人:

public class Originator {
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
    // 创建一个备忘录
    public Memento createMemento() {
        return new Memento(this.state);
    }
    // 恢复一个备忘录
    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }
}

备忘录:

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

备忘录管理员:

public class Caretaker {
    // 备忘录对象
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

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

场景类:

public class Client {
    public static void main(String[] args) {
        // 定义发起人
        Originator originator = new Originator();
        // 定义备忘录管理员
        Caretaker caretaker = new Caretaker();
        // 创建一个备忘录
        caretaker.setMemento(originator.createMemento());
        // 恢复一个备忘录
        originator.restoreMemento(caretaker.getMemento());
    }
}

4. clone 方式的备忘录

我们可以通过复制的方式产生一个对象的内部状态,这是一个很好的办法,发起人角色只要实现 Cloneable 就成,比较简单:

public class Originator implements Cloneable {
    // 内部状态
    private String state;

    public String getState() {
        return state;
    }

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

    private Originator backup;

    // 创建一个备忘录
    public void createMemento() {
        this.backup = this.clone();
    }
    // 恢复一个备忘录
    public void restoreMemento() {
        this.setState(this.backup.getState());
    }
    // 克隆当前对象
    @Override
    protected Originator clone() {
        try {
            return (Originator) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

备忘录管理员:

public class Caretaker {
    // 发起人对象
    private Originator originator;

    public Originator getOriginator() {
        return originator;
    }

    public void setOriginator(Originator originator) {
        this.originator = originator;
    }
}

场景类:

public class Client {
    public static void main(String[] args) {
        // 定义发起人
        Originator originator = new Originator();
        // 创建初始状态
        originator.setState("初始状态");
        System.out.println("初始状态:" + originator.getState());
        // 创建备份
        originator.createMemento();
        // 修改状态
        originator.setState("修改后的状态");
        System.out.println("修改后的状态:" + originator.getState());
        // 恢复状态
        originator.restoreMemento();
        System.out.println("恢复后的状态:" + originator.getState());
    }
}

运行结果是我们所希望的,程序精简了很多,而且高层模块的依赖也减少了,这正是我们期望的效果。

但是我们来考虑一下原型模式深拷贝和浅拷贝的问题,在复杂的场景下它会让我们的程序逻辑异常混乱,出现错误也很难跟踪。因此 Clone 方式的备忘录模式适用于较简单的场景。

5. 多备份的备忘录

我们每天使用的 Windows 是可以拥有多个备份时间点的,系统出现问题,我们可以自由选择需要恢复的还原点。

我们上面的备忘录模式尚且不具有这个功能,只能有一个备份,想要有多个备份也比较简单,我们在备份的时候做一个标记,简单一点可以使用一个字符串。

我们只要把通用代码中的 Caretaker 管理员稍做修改就可以了:

public class Caretaker {
    // 容纳备忘录的容器
    private Map mementoMap = new HashMap<>();

    public Memento getMemento(String keys) {
        return mementoMap.get(keys);
    }

    public void setMemento(String key, Memento memento) {
        this.mementoMap.put(key, memento);
    }
}

对场景类做部分修改:

public class Client {
    public static void main(String[] args) {
        // 定义发起人
        Originator originator = new Originator();
        // 定义备忘录管理员
        Caretaker caretaker = new Caretaker();
        // 创建两个备忘录
        caretaker.setMemento("001", originator.createMemento());
        caretaker.setMemento("002", originator.createMemento());
        // 恢复一个指定的备忘录
        originator.restoreMemento(caretaker.getMemento("002"));
    }
}

6. 更好的封装

在系统管理上,一个备份的数据是完全、绝对不能修改的,它保证数据的洁净,避免数据污染而使备份失去意义。

在我们的程序中也有着同样的问题,备份是不能被褚篡改的,那么也就是需要缩小备忘录的访问权限,保证只有发起人可读就可以了。

这个很简单,直接使用内置类就可以了:

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

        public String getState() {
            return state;
        }

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

这里使用了一个 IMemento 接口,这个接口实际上是一个空接口:

public interface IMemento {
}

这个空接口的作用是用作公共的访问权限。

下面看一下备忘录管理者的变化:

public class Caretaker {
    // 备忘录对象
    private IMemento memento;

    public IMemento getMemento() {
        return memento;
    }

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

上面这段示例全部通过接口访问,如果我们想访问它的属性貌似是无法访问到了。

但是安全是相对的,没有绝对的安全,我们可以使用 refelect 反射修改 Memento 的数据。

在这里我们使用了一个新的设计方法:双接口设计,我们的一个类可以实现多个接口,在系统设计时,如果考虑对象的安全问题,则可以提供两个接口,一个是业务的正常接口,实现必要的业务逻辑,叫做宽接口;另外一个接口是一个空接口,什么方法都没有,其目的是提供给子系统外的模块访问,比如容器对象,这个叫做窄接口,由于窄接口中没有提供任何操纵数据的方法,因此相对来说比较安全。

转载声明:本博客由极客挖掘机创作,采用 CC BY 3.0 CN 许可协议。可自由转载、引用,但需署名作者且注明文章出处。如转载至微信公众号,请在文末添加作者公众号二维码。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

QR code