【redis源码分析】RDB持久化机制_unknown rdb encoding type 48-CSDN博客

rdb是redis保存内存数据到磁盘数据的其中一种方式(另一种是AOF)。Rdb的主要原理就是在某个时间点把内存中的所有数据的快照保存一份到磁盘上。在条件达到时通过fork一个子进程把内存中的数据写到一个临时文件中来实现保存数据快照。在所有数据写完后再把这个临时文件用原子函数rename(2)重命名为目标rdb文件。这种实现方式充分利用fork的copy on write。

　　另外一种是通过save命令主动触发保存数据快照，这种是阻塞式的，即不会通过生成子进程（就在当前进程完成）来进行数据集快照的保存。

　　相关配置

save <seconds> <changes>

　　经过多少秒且多少个key有改变就进行，可以配置多个，只要有一个满足就进行保存数据快照到磁盘

rdbcompression yes

　　保存数据到rdb文件时是否进行压缩，如果不想可以配置成’no’，默认是’yes’，因为压缩可以减少I/O，当然，压缩需要消耗一些cpu资源。

dbfilename dump.rdb

　　快照文件名

dir ./

　　快照文件所在的目录，同时也是AOF文件所在的目录

　　Rdb文件格式

　　[注：本节所说的类型，值在没有特别标明的情况下都是针对rdb文件来说的]

　　Rdb文件的整体格式

　　文件签名 | 版本号 | 类型 | 值 | 类型 | 值 | … | 类型 | 值

　　[注：竖线和空格是为了便于阅读而加入的，rdb文件中是没有竖线和空格分隔的]

文件签名是字符串：REDIS
版本号是字符串：0006
类型是指值的类型，redis值的类型有很多种，下边一一介绍
值是对应的类型下的值，不同类型的值格式不一样。这里的值包含了redis中的key与val。而不是单指redis中val。

　　REDIS_SELECTDB类型与REDIS_EOF类型

REDIS_SELECTDB类型：对应的值是redis db的编号，从0开始到比db数小1的数值。redis中可以配置db数，每个key只属于一个db。
存储redis db的编号时使用的是存储长度时使用的格式，为了尽量压缩rdb文件，存储长度使用的字节数是不一样的，会进行重新编码
REDIS_EOF类型：没有对应的值。rdb文件的结束符。

　　把这REDIS_SELECTDB类型和REDIS_EOF类型代入到上边的rdb文件的格式中，那么rdb文件的整体格式变成为：

　　文件签名 | 版本号 | REDIS_SELECTDB类型 | db编号 | 类型 | 值 | … | REDIS_SELECTD 类型 | db编号 | 类型 | 值 | … | REDIS_EOF类型

两个REDIS_SELECTDB类型之间的数据都是该db下边的key和value的数据

　　相关代码

　　Rdb.c

int rdbSave(char *filename) { 
    … 
      // 以 "temp-<pid>.rdb" 格式创建临时文件名
    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
        redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
            strerror(errno));
        return REDIS_ERR;
    }

    // 初始化 rio 文件
    rioInitWithFile(&rdb,fp);
    // 如果有需要的话，设置校验和计算函数
    if (server.rdb_checksum)
        rdb.update_cksum = rioGenericUpdateChecksum;
    // 以 "REDIS <VERSION>" 格式写入文件头，以及 RDB 的版本
    snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
    if (rdbWriteRaw(&rdb,magic,9) == -1) goto werr;


    // 遍历所有数据库，保存它们的数据
    for (j = 0; j < server.dbnum; j++) {
        // 指向数据库
        redisDb *db = server.db+j;
        // 指向数据库 key space
        dict *d = db->dict;
        // 数据库为空， pass ，处理下个数据库
        if (dictSize(d) == 0) continue;


        // 创建迭代器
        di = dictGetSafeIterator(d);
        if (!di) {
            fclose(fp);
            return REDIS_ERR;
        }


        /* Write the SELECT DB opcode */
        // 记录正在使用的数据库的号码
        if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(&rdb,j) == -1) goto werr;


        /* Iterate this DB writing every entry */
        // 将数据库中的所有节点保存到 RDB 文件
        while((de = dictNext(di)) != NULL) {
            // 取出键
            sds keystr = dictGetKey(de);
            // 取出值
            robj key, 
                 *o = dictGetVal(de);
            long long expire;
            
            initStaticStringObject(key,keystr);
            // 取出过期时间
            expire = getExpire(db,&key);
             //保存所有的键值对
            if (rdbSaveKeyValuePair(&rdb,&key,o,expire,now) == -1) goto werr;
        }
        dictReleaseIterator(di);
    }
    … 
}

　　Rdb中长度的存储

　　Redis为了尽量压缩rdb文件真是费尽心思，先来看看redis为了压缩使用的长度存储。长度主要用在字符串长度，链表长度，hash表的大小存储上。

　　Redis把长度的存储分为四种，最左边字节的从左到右的前两位用于区分长度的存储类型。

　　快照保存

　　我们接下来看看具体实现细节

　　不管是触发条件满足后通过fork子进程来保存快照还是通过save命令来触发，其实都是调用的同一个函数rdbSave()。

　　先来看看触发条件满足后通过fork子进程的实现保存快照的的实现

　　在每100ms调用一次的serverCron函数中会对快照保存的条件进行检查，如果满足了则进行快照保存

　　如果后端有写rdb的子进程或者写aof的子进程，则检查rdb子进程是否退出了，如果退出了则进行一些收尾处理，比如更新脏数据计数server.dirty和最近快照保存时间server.lastsave。

　　如果后端没有写rdb的子进程且没有写aof的子进程，则判断下是否有触发写rdb的条件满足了，如果有条件满足，则通过调用rdbSaveBackground函数进行快照保存。

　　跟着进rdbSaveBackground函数里边看看

<span style="color:#333333;">/*
 * 使用子进程保存数据库数据，不阻塞主进程
 */
int rdbSaveBackground(char *filename) {
    pid_t childpid;
    long long start;
     //已经在运行
    if (server.rdb_child_pid != -1) return REDIS_ERR;
    
    // 修改服务器状态
    server.dirty_before_bgsave = server.dirty;

    // 开始时间
    start = ustime();
    // 创建子进程
    if ((childpid = fork()) == 0) {
        int retval;

        /* Child */
        // 子进程不接收网络数据
        if (server.ipfd > 0) close(server.ipfd);
        if (server.sofd > 0) close(server.sofd);

        // 保存数据
       </span><strong><span style="color:#ff0000;"> retval = rdbSave(filename);</span></strong><span style="color:#333333;">
       // .......
        // 退出子进程
        exitFromChild((retval == REDIS_OK) ? 0 : 1);
    } else {
        /* Parent */
        // 记录最后一次 fork 的时间
        server.stat_fork_time = ustime()-start;

        // 创建子进程失败时进行错误报告
        if (childpid == -1) {..... }
        redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);

        // 记录保存开始的时间
        server.rdb_save_time_start = time(NULL);
        // 记录子进程的 id
        server.rdb_child_pid = childpid;
        // 在执行时关闭对数据库的 rehash
        // 避免 copy-on-write
        updateDictResizePolicy();
        return REDIS_OK;
    }
    return REDIS_OK; /* unreached */
}</span>

　 rdb的快照保存是通过函数rdbSave函数(rdb.c：394)来实现的。其实save命令也是通过调用这个函数来实现的。我们来简单看看

　　rdb.c

/* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
/*
 * 将数据库保存到磁盘上。成功返回 REDIS_OK ，失败返回 REDIS_ERR 。
 */
int rdbSave(char *filename) {
    dictIterator *di = NULL;
    dictEntry *de;
    char tmpfile[256];
    char magic[10];
    int j;
    long long now = mstime();
    FILE *fp;
    rio rdb;
    uint64_t cksum;

    // 以 "temp-<pid>.rdb" 格式创建临时文件名
    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
        redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
            strerror(errno));
        return REDIS_ERR;
    }

    // 初始化 rio 文件
    rioInitWithFile(&rdb,fp);
    // 如果有需要的话，设置校验和计算函数
    if (server.rdb_checksum)
        rdb.update_cksum = rioGenericUpdateChecksum;
    // 以 "REDIS <VERSION>" 格式写入文件头，以及 RDB 的版本
    snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
    if (rdbWriteRaw(&rdb,magic,9) == -1) goto werr;

    // 遍历所有数据库，保存它们的数据
    for (j = 0; j < server.dbnum; j++) {
        // 指向数据库
        redisDb *db = server.db+j;
        // 指向数据库 key space
        dict *d = db->dict;
        // 数据库为空， pass ，处理下个数据库
        if (dictSize(d) == 0) continue;

        // 创建迭代器
        di = dictGetSafeIterator(d);
        if (!di) {
            fclose(fp);
            return REDIS_ERR;
        }

        /* Write the SELECT DB opcode */
        // 记录正在使用的数据库的号码
        if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
        if (rdbSaveLen(&rdb,j) == -1) goto werr;

        /* Iterate this DB writing every entry */
        // 将数据库中的所有节点保存到 RDB 文件
        while((de = dictNext(di)) != NULL) {
            // 取出键
            sds keystr = dictGetKey(de);
            // 取出值
            robj key, 
                 *o = dictGetVal(de);
            long long expire;
            
            initStaticStringObject(key,keystr);
            // 取出过期时间
            expire = getExpire(db,&key);
            if (<span style="background-color: rgb(255, 0, 0);"><strong>rdbSaveKeyValuePair</strong></span>(&rdb,&key,o,expire,now) == -1) goto werr;
        }
        dictReleaseIterator(di);
    }
    di = NULL; /* So that we don't release it again on error. */

    /* EOF opcode */
    if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_EOF) == -1) goto werr;

    /* CRC64 checksum. It will be zero if checksum computation is disabled, the
     * loading code skips the check in this case. */
    cksum = rdb.cksum;
    memrev64ifbe(&cksum);
    rioWrite(&rdb,&cksum,8);

    /* Make sure data will not remain on the OS's output buffers */
    fflush(fp);
    fsync(fileno(fp));
    fclose(fp);

    /* Use RENAME to make sure the DB file is changed atomically only
     * if the generate DB file is ok. */
    // 将临时文件 tmpfile 改名为 filename 
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }

    redisLog(REDIS_NOTICE,"DB saved on disk");

    // 初始化数据库数据
    server.dirty = 0;
    server.lastsave = time(NULL);
    server.lastbgsave_status = REDIS_OK;

    return REDIS_OK;

werr:
    fclose(fp);
    unlink(tmpfile);
    redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    if (di) dictReleaseIterator(di);
    return REDIS_ERR;
}

　　创建并打开临时文件

　　写入文件签名“REDIS”和版本号

　　遍历所有db中的所有key

　　对每个key，先判断是否设置了expireTime, 如果设置了，则保存expireTime到rdb文件中。

rdbSaveKeyValuePair函数保存没个键值对，这个函数在上面介绍过了

　　不同类型有有不同的存储格式，详细见rdb文件格式

　　最后写入rdb文件的结束符

　　关闭文件并重命名临时文件名到正式文件名

　　更新脏数据计数server.dirty为0和最近写rdb文件的时间server.lastsave为当前时间，这个只是在通过save命令触发的情况下有用。因为如果是通过fork一个子进程来写rdb文件的，更新无效，因为更新的是子进程的数据。

　　如果是通过fork一个子进程来写rdb文件(即不是通过save命令触发的)，在写rdb文件的过程中，可能又有一些数据被更改了，那此时的脏数据计数server.dirty怎么更新呢? redis是怎样处理的呢?

　　我们来看看写rdb的子进程退出时的处理

　　Redis.c（serverCron（））

// 如果 BGSAVE 或者 BGREWRITEAOF 正在进行
    // 那么检查它们是否已经执行完毕
    if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
        int statloc;
        pid_t pid;

        if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
            int exitcode = WEXITSTATUS(statloc);
            int bysignal = 0;
            
            if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);

            if (pid == server.rdb_child_pid) {
                backgroundSaveDoneHandler(exitcode,bysignal);
            } else if (pid == server.aof_child_pid) {
                backgroundRewriteDoneHandler(exitcode,bysignal);
            } else {
                redisLog(REDIS_WARNING,
                    "Warning, detected child with unmatched pid: %ld",
                    (long)pid);
            }
            // 如果 BGSAVE 和 BGREWRITEAOF 都已经完成，那么重新开始 REHASH
            updateDictResizePolicy();
        }
    }

　如果捕捉到写rdb文件的子进程退出，则调用backgroundSaveDoneHandler进行处理

　　接着看看backgroundSaveDoneHandler函数

　　Rdb.c

<span style="color:#333333;">/* A background saving child (BGSAVE) terminated its work. Handle this. */
/*
 * 根据 BGSAVE 子进程的返回值，对服务器状态进行更新
 */
void backgroundSaveDoneHandler(int exitcode, int bysignal) {
    // 保存成功
    if (!bysignal && exitcode == 0) {
        redisLog(REDIS_NOTICE, "Background saving terminated with success");
       </span><strong><span style="color:#ff0000;"> server.dirty = server.dirty - server.dirty_before_bgsave;</span></strong><span style="color:#333333;">
        </span><strong><span style="color:#ff0000;">server.lastsave = time(NULL);</span></strong><span style="color:#333333;">
        server.lastbgsave_status = REDIS_OK;
    // 保存失败
    } else if (!bysignal && exitcode != 0) {
        redisLog(REDIS_WARNING, "Background saving error");
        server.lastbgsave_status = REDIS_ERR;
    // 子进程被终结
    } else {
        redisLog(REDIS_WARNING,
            "Background saving terminated by signal %d", bysignal);
        rdbRemoveTempFile(server.rdb_child_pid);
        server.lastbgsave_status = REDIS_ERR;
    }

    // 更新服务器状态
    server.rdb_child_pid = -1;
    server.rdb_save_time_last = time(NULL)-server.rdb_save_time_start;
    server.rdb_save_time_start = -1;

    /* Possibly there are slaves waiting for a BGSAVE in order to be served
     * (the first stage of SYNC is a bulk transfer of dump.rdb) */
    // 将 rdb 文件保存完毕的消息报告可能正在等待复制的附属节点
    updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);
}</span>

　　更新脏数据计数server.dirty和最近写rdb文件的时间server.lastsave为当前时间

注意这里AOF的处理方式的不同，对于AOF，他是将快照期间的数据同时写入了一个buf和AOF日志文件，当rewrite结束后，将buf中的数据追加到AOF中就可以保证数据的完整，但是在RDB中，没有必要这样做，因为RDB本来就不需要保证数据的完全完整，所以只需要更新脏数据，将脏数据设置为这期间被修改的数量就可以了。

　　快照导入

　　当redis因为停电或者某些原因挂掉了，此时重启redis时，我们就需要从rdb文件中读取快照文件，把保存到rdb文件中的数据重新导入到内存中。

　　先来看看启动时对快照导入的处理

　　Redis.c

<span style="color:#333333;">// 从 RDB 文件或 AOF 文件中载入数据到内存
void loadDataFromDisk(void) {
    long long start = ustime();

    // 如果开启了 AOF 功能，那么优先使用 AOF 文件来还原数据
    if (server.aof_state == REDIS_AOF_ON) {
        if (</span><strong><span style="color:#ff0000;">loadAppendOnlyFile</span></strong><span style="color:#333333;">(server.aof_filename) == REDIS_OK)
            redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        // 在没有开启 AOF 功能时，才使用 RDB 来还原
        if (</span><strong><span style="color:#ff0000;">rdbLoad</span></strong><span style="color:#333333;">(server.rdb_filename) == REDIS_OK) {
            redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
            redisLog(REDIS_WARNING,"Fatal error loading the DB. Exiting.");
            exit(1);
        }
    }
}</span>

　　如果保存了AOF文件，则使用AOF文件来恢复数据，AOF的具体内容见AOF

　　如果没有AOF，则使用rdb文件恢复数据，调用rdbLoad函数

　　接着看看rdbLoad函数

　　Rdb.c

<span style="color:#333333;">/*
 * 读取 rdb 文件，并将其中的对象保存到内存中
 */
int rdbLoad(char *filename) {
    uint32_t dbid;
    int type, rdbver;
    redisDb *db = server.db+0;
    char buf[1024];
    long long expiretime, now = mstime();
    long loops = 0;
    FILE *fp;
    rio rdb;

    // 打开文件
    fp = fopen(filename,"r");
    if (!fp) {
        errno = ENOENT;
        return REDIS_ERR;
    }

    // 初始化 rdb 文件
    rioInitWithFile(&rdb,fp);
    if (server.rdb_checksum)
        rdb.update_cksum = rioGenericUpdateChecksum;

    // 检查 rdb 文件头（“REDIS”字符串，以及版本号）
    if (rioRead(&rdb,buf,9) == 0) goto eoferr;
    buf[9] = '\0';
    if (memcmp(buf,"REDIS",5) != 0) {   // "REDIS"
        fclose(fp);
        redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
        errno = EINVAL;
        return REDIS_ERR;
    }
    rdbver = atoi(buf+5);   // 版本号
    if (rdbver < 1 || rdbver > REDIS_RDB_VERSION) {
        fclose(fp);
        redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver);
        errno = EINVAL;
        return REDIS_ERR;
    }

    startLoading(fp);
    while(1) {
        robj *key, *val;
        expiretime = -1;

        /* Serve the clients from time to time */
        // 间隔性服务客户端
        if (!(loops++ % 1000)) {
            // 刷新载入进程信息
            loadingProgress(rioTell(&rdb));
            // 处理事件
            aeProcessEvents(server.el, AE_FILE_EVENTS|AE_DONT_WAIT);
        }

        /* Read type. */
        // 读入类型标识符
        if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;

        // 接下来的值是一个过期时间
        if (type == REDIS_RDB_OPCODE_EXPIRETIME) {
            // 读取毫秒计数的过期时间
            if ((expiretime = rdbLoadTime(&rdb)) == -1) goto eoferr;
            /* We read the time so we need to read the object type again. */
            // 读取下一个值（一个字符串 key ）的类型标识符
            if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
            /* the EXPIRETIME opcode specifies time in seconds, so convert
             * into milliesconds. */
             // 将毫秒转换为秒
            expiretime *= 1000;
        } else if (type == REDIS_RDB_OPCODE_EXPIRETIME_MS) {
            /* Milliseconds precision expire times introduced with RDB
             * version 3. */
            // 读取毫秒计数的过期时间
            if ((expiretime = rdbLoadMillisecondTime(&rdb)) == -1) goto eoferr;
            /* We read the time so we need to read the object type again. */
            // 读取下一个值（一个字符串 key ）的类型标识符
            if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
        }
    
        // 到达 EOF ，跳出
        if (type == REDIS_RDB_OPCODE_EOF)
            break;

        /* Handle SELECT DB opcode as a special case */
        // 数据库号码标识符
        if (type == REDIS_RDB_OPCODE_SELECTDB) {
            // 读取数据库号
            if ((dbid = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR)
                goto eoferr;
            // 检查数据库号是否合法
            if (dbid >= (unsigned)server.dbnum) {
                redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);
                exit(1);
            }
            db = server.db+dbid;
            continue;
        }

        /* Read key */
        // 读入 key
        if ((key = </span><strong><span style="color:#ff0000;">rdbLoadStringObject(&rdb)</span></strong><span style="color:#333333;">) == NULL) goto eoferr;

        /* Read value */
        // 读入 value
        if ((val = </span><strong><span style="color:#ff0000;">rdbLoadObject(type,&rdb)</span></strong><span style="color:#333333;">) == NULL) goto eoferr;

        /* Check if the key already expired. This function is used when loading
         * an RDB file from disk, either at startup, or when an RDB was
         * received from the master. In the latter case, the master is
         * responsible for key expiry. If we would expire keys here, the
         * snapshot taken by the master may not be reflected on the slave. */
        // 如果 key 已经过期，那么释放 key 和 value
        if (server.masterhost == NULL && expiretime != -1 && expiretime < now) {
            decrRefCount(key);
            decrRefCount(val);
            continue;
        }

        /* Add the new object in the hash table */
        // 将对象添加到数据库
        </span><strong><span style="color:#ff0000;">dbAdd(db,key,val);</span></strong><span style="color:#333333;">

        /* Set the expire time if needed */
        // 如果有过期时间，设置过期时间
        if (expiretime != -1) setExpire(db,key,expiretime);

        decrRefCount(key);
    }

    /* Verify the checksum if RDB version is >= 5 */
    // 检查校验和
    if (rdbver >= 5 && server.rdb_checksum) {
        uint64_t cksum, expected = rdb.cksum;

        if (rioRead(&rdb,&cksum,8) == 0) goto eoferr;
        memrev64ifbe(&cksum);
        if (cksum == 0) {
            redisLog(REDIS_WARNING,"RDB file was saved with checksum disabled: no check performed.");
        } else if (cksum != expected) {
            redisLog(REDIS_WARNING,"Wrong RDB checksum. Aborting now.");
            exit(1);
        }
    }

    fclose(fp);
    stopLoading();
    return REDIS_OK;

eoferr: /* unexpected end of file is handled here with a fatal exit */
    redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now.");
    exit(1);
    return REDIS_ERR; /* Just to avoid warning */
}</span>

　　打开rdb文件

　　读取rdb文件的签名和版本号

　　开始进入类型 | 值 | 类型 | 值的循环读取，可参考rdb文件格式

　　作者还做了导入的进度条，是有人反馈说rdb文件很大时导入时要很久，但又不知道进度，所以作者就加了导入的进度条，改善用户体验

　　读取类型

　　如果类型是过期时间类型REDIS_EXPIRETIME，则读取过期时间

　　如果类型是文件结束类型REDIS_EOF，则跳出类型 | 值 | 类型 | 值的循环读取

　　如果类型是选择db类型REDIS_SELECTDB，则读取db索引并把当前db转成该db，然后继续类型 | 值 | 类型 | 值的循环读取。

　　如果不是以上类型，则表明该类型是数据类型，读取作为key的字符串，即读取字符串类型的值，然后接着读取作为value的字符串。不同类型的编码不一样，根据写入时得规则解释读取到的值即可

　　读取到key和value后，判断下该key是否过期，如果过期则丢弃，不再导入，然后继续类型 | 值 | 类型 | 值的循环读取。

　　如果读取成功，则导入到内存，如果有过期时间则设置过期时间

　　总结

　　落地存储是数据设计的一大重点也是难点。原理很简单，定义某种协议，然后按照某种协议写入读出。Redis为了节省空间和读写时的I/O操作，做了很多很细致的工作来压缩数据。另外redis的丰富的数据类型也加大了落地的实现难度。作者也曾经在他的博客说过，redis的丰富的数据类型导致了很多经典的优化办法无法在redis上实现。

参考：

http://www.searchdatabase.com.cn/showcontent_62814.htm