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

冷不防 2024-05-06 21:33 4阅读 0赞

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

在这里，我将给大家谈谈，行为型设计模式中的备忘录模式（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面向经常被问到的问题之一。

![790c0d7a54f24777a0811bc9a84e512f.png][]

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

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

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

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

先上类图。

UML类图

![d724928d0c7d43f6a154b6cc4ea77460.png][]

**接口及类：**

备忘录角色（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属性里面的数据。

备忘录源角色——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);
        }
    }

运行结果

![e6ae321358344d6e959a44b2beacbbba.png][]

**总结**

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

[790c0d7a54f24777a0811bc9a84e512f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/b13fb2d01e754f95bc5e4bbc002bfcee.png
[d724928d0c7d43f6a154b6cc4ea77460.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/47f66728502b4064a1b9585c7bac11ae.png
[e6ae321358344d6e959a44b2beacbbba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/5399f7f49ed74a66a479f0b79cd07a60.png