一个专为系统数据安全而来的设计模式，一个不仅给你的数据创建备份，还在系统崩溃时，给你提供后悔药的设计模式。

大家好，欢迎关注极客架构师，极客架构师——专注架构师成长，我是码农老吴。

本期是《架构师基本功之设计模式》的第11期。

在第10期，我分享了行为型设计模式中，大名鼎鼎却很少现身的命令模式（command pattern），我们基于命令模式重构了电商系统中的降级模块。

在本期，我将给大家分享的是，行为型设计模式中的备忘录模式（Memento pattern），基于备忘录设计模式，模拟实现Redis中的RDB备份机制。

看到“备忘录”这三个字，你会联想到什么呢？

顾名思义

是贴在白板上五颜六色的便签，

还是记录了自己小秘密的日记本，

还是刚刚写完，连自己都看不懂的会议记录，

或者其他什么类似的东东。

不论什么东东，这些东东，是不是都有一个共同的特点，那就是：

要把重要的事情记录下来

对于备忘录模式，仅仅根据它的名字，我们是否可以有一个大胆的假设，那就是：

备忘录模式应该是一个，有关如何解决“备忘”问题的设计模式

是这样吗？

让我们从备忘录模式的定义说起。

定义解析

Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.

—— Gof《Design Patterns: Elements of Reusable Object-Oriented Software》

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

——Gof《设计模式：可复用面向对象软件的基础》

从它的定义，我们可以解析出以下几点。

1，备忘的内容——对象状态

它确实是用来备忘的，备忘的内容是对象的内部状态。

2，备忘的目的——恢复状态

备忘对象的内部状态，并不是它的唯一目的，它还希望在关键时刻，可以把对象状态，恢复到备忘时的状态。

3，备忘的前提——安全性

它备忘对象的前提条件，是安全性，是不破坏封装性。通俗点说，就是备份的数据，不能随意被别的对象访问，这一点，后面大家会有所体会。

总结一下

备忘录模式，就是在保障数据安全性的前提下，记录对象某个时刻的内部状态（可以是全部，也可以是一部分），以便以后，可以随时恢复对象的内部状态。

基于RAIS分析模式，备忘录模式有三种角色组成，分别是备忘录角色（Memento role），备忘录源角色（Memento source role），备忘录管理者角色（Memento manager role）。

下面，我们就用备忘录模式，来模拟实现Redis的RDB备份机制。

案例-模拟Redis RDB备份机制

在Redis如日中天的这个时代，Redis的RDB机制，大部分程序员应该都很熟悉，或者至少是有所耳闻，它也是redis面向经常被问到的问题之一。

Redis的RDB备份机制，简单的说，包括备份和还原两个步骤。

备份：将Redis某个时刻内存中的数据，保存到磁盘文件上。

还原：当需要还原数据时，redis将磁盘上的备份文件读取到内存中，将数据恢复到备份时的状态。

原理很简单，我们看看，如何用备忘录模式来模拟。

先上类图。

UML类图

接口及类：

备忘录角色（Memento role）：ISnapshot接口，静态内部类RedisSnapshot。

备忘录源角色(Memento source role):RedisServer，模拟redis 主程序。

备忘录管理者角色（Memento manager role）:RDB，模拟redis里面RDB备份策略的类

RedisServerTest：测试类

备忘录角色——ISnapshot接口

这个接口里面啥也没有，是传说中的标记接口，为什么要这样做呢？

答案就是两个字，“安全”，为了所备份的数据的安全性，备忘录角色的接口，被称为“窄接口”，越窄越好，窄到极致，就成了标记接口，当然，不是必须的，如果有些数据可以暴露，可以提供一些接口。

package com.geekarchitect.patterns.memento.demo02;

/**
 * 快照接口
 * 备忘录角色：Memento role
 *
 * @author 极客架构师@吴念
 * @createTime 2022/9/6
 */
public interface ISnapshot {
}

备忘录角色——RedisSnapshot实现类

备忘录的实现类，很明显，它是一个静态内部类，而且是private的，为什么要这么做？

答案还是两个字，“安全”，通过私有化的静态内部类，确保它里面的属性，只能被它所在的主类访问，增加了安全性。而且它执行了备忘录的“窄接口”，除了它的主类，其他类几乎没法获取它里面的数据。即使是备忘录管理者角色也不行。

RedisSnapshot（备忘录角色）是用来存放需要备份的数据，所以，它里面也有一个Map类型的数据valueMap。用来存储它的主类RedisServer（备忘录源角色）里面的valueMap属性里面的数据。

package com.geekarchitect.patterns.memento.demo02;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * 备忘录创建者角色：Memento creator role
 *
 * @author 极客架构师@吴念
 * @createTime 2022/9/6
 */
public class RedisServer {
    private static final Logger LOG = LoggerFactory.getLogger(RedisServer.class);
    private Map<String, String> valueMap = new HashMap<>();
    /**
     * 快照实现类
     */
    private static class RedisSnapshot implements ISnapshot {
        private final Map<String, String> valueMap;

        public RedisSnapshot(RedisServer redisServer) {
            this.valueMap = (Map<String, String>) ((HashMap) redisServer.valueMap).clone();
        }

        public Map<String, String> getValueMap() {
            return valueMap;
        }
    }

}

备忘录源角色——RedisServer：

它是用来模拟redis 主程序的，所以，它里面提供了如下的属性了方法。

valueMap属性：用来存储数据，redis原本支持的数据类型很多，我们这里简化为一种——字符串类型。

set方法：客户端把数据写入缓存。

get方法：客户端从缓存读取数据。

它属于备忘录源角色，是被备忘的角色，所以，也需要提供以下方法。

这里要引入一个名词，snapshot，快照，表示某个时间点，备忘录源角色，内部态的静态集合，程序员对快照一般不会陌生。

createSnapshot（）：创建快照，用来备份当前的内部状态。

restoreSnapshot（）：恢复快照，用快照来恢复内部状态。

package com.geekarchitect.patterns.memento.demo02;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * 备忘录创建者角色：Memento creator role
 *
 * @author 极客架构师@吴念
 * @createTime 2022/9/6
 */
public class RedisServer {
    private static final Logger LOG = LoggerFactory.getLogger(RedisServer.class);

    private Map<String, String> valueMap = new HashMap<>();

    public RedisServer() {
    }

    public void set(String key, String value) {
        valueMap.put(key, value);
    }

    public String get(String key) {
        return valueMap.get(key);
    }

    /**
     * 创建快照
     * @return
     */
    public ISnapshot createSnapshot() {
        ISnapshot snapshot = new RedisSnapshot(this);
        LOG.info("快照创建成功");
        return snapshot;
    }

    /**
     * 恢复快照
     * @param snapshot
     */
    public void restoreSnapshot(ISnapshot snapshot) {
        RedisSnapshot redisSnapshot = (RedisSnapshot) snapshot;
        this.valueMap = (Map<String, String>) ((HashMap) ((RedisSnapshot) snapshot).getValueMap()).clone();
        LOG.info("快照恢复成功");
    }

    /**
     * 快照实现类
     */
    private static class RedisSnapshot implements ISnapshot {
        private final Map<String, String> valueMap;

        public RedisSnapshot(RedisServer redisServer) {
            this.valueMap = (Map<String, String>) ((HashMap) redisServer.valueMap).clone();
        }

        public Map<String, String> getValueMap() {
            return valueMap;
        }
    }

}

备忘录管理者角色——RDB

它是用来模拟redis里面RDB备份策略的类，它的作用是管理快照的，一般情况下，应该可以保存多个快照，这里我们为了简化，只保存了一个快照。

重点说明：

snapshot属性：当然如果你想把快照保持到磁盘文件里面，把这里改造一下，就可以了。

package com.geekarchitect.patterns.memento.demo02;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * RDB
 * 备忘录管理者角色：Memento manager role
 *
 * @author 极客架构师@吴念
 * @createTime 2022/9/6
 */
public class RDB {
    private static final Logger LOG = LoggerFactory.getLogger(RDB.class);
    private final RedisServer redisServer;
    private ISnapshot snapshot;

    public RDB(RedisServer redisServer) {
        this.redisServer = redisServer;
    }

    /**
     * 恢复
     *
     * @author: 极客架构师@吴念
     * @date: 2022/9/7
     * @param: []
     * @return: void
     */
    public void restore() {
        if (this.snapshot != null) {
            redisServer.restoreSnapshot(this.snapshot);
            LOG.info("恢复成功");
        } else {
            LOG.info("恢复失败，尚无快照");
        }
    }

    /**
     * 备份
     *
     * @author: 极客架构师@吴念
     * @date: 2022/9/7
     * @param:
     * @return:
     */
    public void backup() {
        this.snapshot = redisServer.createSnapshot();
        LOG.info("备份成功");
    }
}

测试类RedisServerTest

单凭刚才那几个类，是无法运行出现在的结果的。

测试类里面大有乾坤，增加了三个线程，分别来模拟客户线程，备份线程，和恢复线程，不过这不是我们的重点，大家下去自己看代码。

package com.geekarchitect.patterns.memento.demo02;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

@SpringBootTest
class RedisServerTest {
    private static final Logger LOG = LoggerFactory.getLogger(RedisServerTest.class);
    @BeforeEach
    void setUp() {

    }

    @AfterEach
    void tearDown() {

    }

    @Test
    void redisBackupRestoreMock() {
        RedisServer redisServer = new RedisServer();
        RDB rdb = new RDB(redisServer);
        ClientThread clientThreadA=new ClientThread(redisServer);
        BackupThread backupThreadA=new BackupThread(redisServer,rdb);
        RestoreThread restoreThreadA=new RestoreThread(redisServer,rdb);
        clientThreadA.start();
        backupThreadA.start();
        restoreThreadA.start();
        try {
            LOG.info("等待中... ");
            new BufferedReader(new InputStreamReader(System.in)).readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 客户线程：每隔1秒钟，随机写入缓存
 */
class ClientThread extends Thread {
    private static final Logger LOG = LoggerFactory.getLogger(ClientThread.class);
    private final RedisServer redisServer;

    public ClientThread(RedisServer redisServer) {
        this.redisServer = redisServer;
    }

    @Override
    public void run() {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                Calendar calendar = Calendar.getInstance();
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                String key = String.valueOf(calendar.getTimeInMillis());
                String value = dateFormat.format(calendar.getTime());
                redisServer.set(key, value);
                LOG.info("客户端写入： key={} value={}", key, value);
            }
        };
        Timer timer = new Timer();
        timer.schedule(timerTask, 1000, 500);
    }
}

/**
 * 备份线程
 */
class BackupThread extends Thread {
    private static final Logger LOG = LoggerFactory.getLogger(BackupThread.class);
    private final RedisServer redisServer;
    private final RDB rdb;

    public BackupThread(RedisServer redisServer, RDB rdb) {
        this.redisServer = redisServer;
        this.rdb = rdb;
    }

    @Override
    public void run() {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                rdb.backup();
                LOG.info("数据备份成功");
            }
        };
        Timer timer = new Timer();
        timer.schedule(timerTask, 2000, 1000);
    }
}

/**
 * 恢复线程
 */
class RestoreThread extends Thread {
    private static final Logger LOG = LoggerFactory.getLogger(RestoreThread.class);
    private final RedisServer redisServer;
    private final RDB rdb;

    private final Random random = new Random();

    public RestoreThread(RedisServer redisServer, RDB rdb) {
        this.redisServer = redisServer;
        this.rdb = rdb;
    }

    public boolean isRestore(){
       return random.nextInt(5)==3;
    }

    @Override
    public void run() {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                if (isRestore()) {
                    LOG.info("条件成熟：恢复数据");
                    rdb.restore();
                }
            }
        };
        Timer timer = new Timer();
        timer.schedule(timerTask, 3000, 1000);
    }
}

运行结果

总结

基于RAIS分析模式，备忘录模式，有三个角色组成，分别是备忘录角色（Memento role），备忘录源角色（Memento source role），备忘录管理者角色（Memento manager role）。它的宗旨就是，备忘录管理者角色，在保证备忘录数据安全性的前提下，通过备忘录角色，备份备忘录源角色的当前状态，以便在需要的时候，恢复备份备忘录源角色的状态。

后续规划

这一节，仅仅是备忘录模式的开始，后面还会陆续发布几个，短小精悍的，有所侧重的，备忘录模式实战案例，敬请期待。

极客架构师，专注架构师成长。

关注我，我将持续分享更多架构师的相关文章和视频，我们下期见。