用Java实现Redis的RDB机制，一个专为系统数据安全而来的设计模式

本文链接：https://blog.csdn.net/weixin_49307478/article/details/126851125

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

在这里，我将给大家谈谈，行为型设计模式中的备忘录模式（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）。它的宗旨就是，备忘录管理者角色，在保证备忘录数据安全性的前提下，通过备忘录角色，备份备忘录源角色的当前状态，以便在需要的时候，恢复备份备忘录源角色的状态。