禅与计算机
sharkchili
2024-10-15
目录

聊聊redis字典指令操作

# 写在文章开头

哈希是笔者日常使用redis中比较常用的一个对象类型，因近期笔者尝试用go语言复刻redis，遂以此文记录一下笔者对于源码的学习思路，希望对你有所帮助

同时，也非常欢迎感兴趣的读者关注笔者的开源项目:

mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 详解redis中哈希操作指令的实现

# 添加单字段到字典(hset指令)

字典底层实现的编码有两种，默认情况下是压缩列表也就是ziplist，一旦字符串长度超过阈值就会转为hashTable，而本文对于字典指令的操作都是基于hashTable，我们先来说说字典的第一个操作，也就是hset 指令例如我们希望创建的名为user的哈希，这个哈希中包含一个name为xiaoming的键值对，对应的操作示例就是：

hset user name xiaoming
1

redis在执行该操作时，逻辑步骤为：

  1. 到redisDb中查看key为user的是否存在，如果存在则判断该对象类型是否是哈希集，如果不是则响应操作异常给用户，当然如果不存在则初始化创建一个编码格式为key为user的压缩列表的哈希对象添加到redisDb中。
  2. 反之后续查看是否需要进行编码转换(哈希底层由压缩列表或者哈希表实现)，完成编码转换之后，就按照当前的编码对象进行键值对插入。
  3. 完成插入操作，返回给用户1告知当前字典中单个键值对插入成功。

这里笔者以编码格式为哈希表的哈希对象插入key为user的name键值对存储图例，读者可自行参阅：

同时笔者也给出这段hset指令的实现函数hsetCommand，大体逻辑与上述基本一致读者可参考注释了解一下基本流程：

void hsetCommand(redisClient *c) {
    int update;
    robj *o;
    //查看字典是否存在，如果不存在则创建
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    //判断键值对是否超出阈值，如果超出则将压缩列表转为字典
    hashTypeTryConversion(o,c->argv,2,3);
    //如果字典底层用哈希表实现，则对键值对进行类型转换为整数(可能从常量池中获取)节省内存空间
    hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
    //将键值对存储到内存中，如果是更新返回1，插入返回0
    update = hashTypeSet(o,c->argv[2],c->argv[3]);
    //如果插入成功返回1，反之返回0
    addReply(c, update ? shared.czero : shared.cone);
   //......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

了解了整体过程我们再来看看hashTypeLookupWriteOrCreate的实现，该方法会检查当前redis内存数据库中是否存在传入值为key的哈希对象，如果不存在则调用createHashObject创建一个编码类型为压缩列表的哈希对象。 反之若存在这个字典则判断类型是否对哈希类型如果不是则返回用户类型异常：

robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key) {
    //查看key是否存在
    robj *o = lookupKeyWrite(c->db,key);
    if (o == NULL) {
        //如果不存在则创建一个压缩列表，然后存到redis数据库中
        o = createHashObject();
        dbAdd(c->db,key,o);
    } else {//如果存在则判断是否为字典类型，如果不是则直接抛异常
        if (o->type != REDIS_HASH) {
            addReply(c,shared.wrongtypeerr);
            return NULL;
        }
    }
    return o;
}

robj *createHashObject(void) {
    //创建一个压缩列表作为最初版本的哈希对象
    unsigned char *zl = ziplistNew();
    robj *o = createObject(REDIS_HASH, zl);
    //设置编码格式为压缩列表
    o->encoding = REDIS_ENCODING_ZIPLIST;
    return o;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

然后就是编码转换的内部实现，可以看到hashTypeTryConversion内部会遍历传入的参数即键值对，一旦发现任何一个参数长度超过hash_max_ziplist_value(默认为64)则直接转为REDIS_ENCODING_HT即哈希表：

void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
    int i;

    if (o->encoding != REDIS_ENCODING_ZIPLIST) return;
    //如果某个键值对超出压缩列表阈值后则将压缩列表转为哈希表
    for (i = start; i <= end; i++) {
        if (sdsEncodedObject(argv[i]) &&
            sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
        {
            hashTypeConvert(o, REDIS_ENCODING_HT);
            break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

下一个核心操作就是插入键值对hashTypeSet，我们以编码为哈希表为例，可以看到哈希表本质上就是通过调用dictReplace完成键值对插入，而dictReplace逻辑为调用dictAdd尝试插入，如果失败则说明这个键值对已经存在，则调用dictFind找到该哈希表指针，然后覆盖这个键值对的值：

int hashTypeSet(robj *o, robj *field, robj *value) {
    int update = 0;

    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
       //......
    } else if (o->encoding == REDIS_ENCODING_HT) {
        if (dictReplace(o->ptr, field, value)) {//哈希表插入操作，插入成功返回1，更新成功返回0
            incrRefCount(field);
        } else { //如果dictReplace返回0说明执行更新操作，则将标识改为update=1
            update = 1;
        }
        incrRefCount(value);
    } else {
        redisPanic("Unknown hash encoding");
    }
    return update;
}



int dictReplace(dict *d, void *key, void *val)
{
    dictEntry *entry, auxentry;

    
    //查看键值对是否插入成功，如果成功返回1
    if (dictAdd(d, key, val) == DICT_OK)
        return 1;
   
    //查看键值对并将其覆盖掉，然后返回0
    entry = dictFind(d, key);
  	//......
    auxentry = *entry;
    //拿到指针更新键值对
    dictSetVal(d, entry, val);
    dictFreeVal(d, &auxentry);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

当我们需要针对单个哈希对象进行多键值对插入时，可以通过hmset 实现：

hmset user name xiaoming age 20 address china
1

对应的逻辑实现hmsetCommand和上述hset指令的函数差不多，唯一区别就是在进行插入时需要遍历每一对键值对完成操作：

对应的我们给出代码示例，即位于t_hash.c的hmsetCommand函数，它首先会对参数数量进行校验，我们以hmset user name xiaoming age 20 address china为例，除去指令和key以外，键值对都是两两配对的，这意味着我们传入指令的参数必须是双数，所以hmsetCommand进行校验时会判断参数是否为双数如果不是则抛出异常。 后续的操作就如我们上文所说的查字典，遍历传入的键值对存入redis内存数据库中：

void hmsetCommand(redisClient *c) {
    int i;
    robj *o;
    //查看是否参数是否正常 len(指令+key+键值对）不能够被2整除
    if ((c->argc % 2) == 1) {
        addReplyError(c,"wrong number of arguments for HMSET");
        return;
    }
    //查看字典是否存在，若不存在则创建
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    //检查是否需要进行类型转换
    hashTypeTryConversion(o,c->argv,2,c->argc-1);
    //针对每个键值对进行编码转换和设置
    for (i = 2; i < c->argc; i += 2) {
        hashTypeTryObjectEncoding(o,&c->argv[i], &c->argv[i+1]);
        hashTypeSet(o,c->argv[i],c->argv[i+1]);
    }
    //返回成功ok标识
    addReply(c, shared.ok);
  	//......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 不存在时添加字典单字段(hsetnx指令)

hsetnx指令用于当对应key的哈希对象某个字段不存在时，才将用户存入的哈希对象存入redis内存数据库中，例如我们希望user这个key对应的哈希对象的name不存在时，才添加一个user的字典，就可以使用hsetnx ：

hsetnx user name xiaoming
1

该指令流程同样是先查看用户传入哈希对象是否存在，如果不存在则会创建一个哈希对象，若存在则会进行类型校验，如果不是字典就响应错误给客户端。 完成上述基本流程之后，该指令会检查这个字典中是否存在用户要添加的字段，如果不存在则返回0，反之将字典添加之后返回1告知用户添加成功：

对应的我们给出hsetnx指令的实现，即位于t_hash.c下的hsetnxCommand函数的实现，整体流程如上所说：

  1. 判空，若字典不存在则创建。
  2. 字典存在则进行类型校验。
  3. 查库字典中对应的字典是否存在，如果不存在则添加返回1，如果存在则不执行任何操作并返回0。
void hsetnxCommand(redisClient *c) {
    robj *o;
    //查看字典是否存在，如果不存在默认初始化一个压缩列表作为字典的底层实现
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    hashTypeTryConversion(o,c->argv,2,3);
    //查看键值对是否存在，若存在则返回给用户0
    if (hashTypeExists(o, c->argv[2])) {
        addReply(c, shared.czero);
    } else {
        //针对键值对进行编码转换
        hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
        //设置键值对
        hashTypeSet(o,c->argv[2],c->argv[3]);
        //返回1
        addReply(c, shared.cone);
     	//......
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 查询字典单字段(hget)

如果我们希望查询字典某个字典的值，就可以通过hget指令获取，例如我们希望获取user字典中name字段的值：

hget user name
1

hget指令收到用户请求后会按照如下步骤执行：

  1. 到redis内存数据库redisdb中获取对应的字典，如果字典不存在则返回空。
  2. 校验类型是否是字典，如果不是则告知用户查询指令与数据类型不匹配。
  3. 基于查询到的字典对象获取对应的字段的value返回给用户，与之对应我们给出这段示例的源码，逻辑与上述步骤一致，读者可自行阅读了解一下大体流程：
void hgetCommand(redisClient *c) {
    robj *o;
    //查看是否存在和类型校验
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,o,REDIS_HASH)) return;
    //查询字典对应的字段并返回给用户
    addHashFieldToReply(c, o, c->argv[2]);
}
1
2
3
4
5
6
7
8

先来说说lookupKeyReadOrReply函数，该函数主要是用户查询redis内存数据库中是否存在对应的字典，可以看到其内部用到了lookupKeyRead也就是读查询同理上文中的set也有对应的写查询lookupKeyWrite。

这里补充说明一下函数这样设计的原因，我们都知道redis是用于存储热点数据，通过在lookupKeyRead上进行统计查询未命中数有助于我们后续对redis热点数据存储上的优化工作：

所以在hget第一步通过lookupKeyReadOrReply发现存在字典对象后，就会将字典对象的指针返回：

robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply) {
    //调用lookupKeyRead进行字典读查询，若存在则返回这个字典对象
    robj *o = lookupKeyRead(c->db, key);
    if (!o) addReply(c,reply);
    return o;
}

robj *lookupKeyRead(redisDb *db, robj *key) {
    robj *val;
    //查看该数据是否有时效性，如果有则检查是否到期并将其删除
    expireIfNeeded(db,key);
    val = lookupKey(db,key);
    //如果为空则增加未命中数
    if (val == NULL)
        server.stat_keyspace_misses++;
    else
        server.stat_keyspace_hits++;
    return val;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

完成上述操作和类型检查之后，就来到获取字段值，如下所示该函数会先检查传入的字典是否为空，若为空则空响应后返回。若不为空则到字典冲查询这个字段值并存到value指针中交由addReply函数响应给客户端：

static void addHashFieldToReply(redisClient *c, robj *o, robj *field) {
    int ret;

    if (o == NULL) {
        addReply(c, shared.nullbulk);
        return;
    }

    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
       //......

    } else if (o->encoding == REDIS_ENCODING_HT) {
        robj *value;
        //查询结果是否存在，若存在返回value反之返回空响应
        ret = hashTypeGetFromHashTable(o, field, &value);
        if (ret < 0) {//ret小于0说明没有查询到，返回空响应
            addReply(c, shared.nullbulk);
        } else {//若存在则返回value
            addReplyBulk(c, value);
        }

    } else {
        redisPanic("Unknown hash encoding");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 查询多字段值(hmget)

同理hmget支持查询多个字段，例如我们要查询user的name、age、address字段，对应的指令为：

hmget user name age address
1

其函数实现hmgetCommand和hgetCommand差不多，唯一区别就是查询时是从索引2开始逐个遍历字段名要内存数据库中查询：

void hmgetCommand(redisClient *c) {
    robj *o;
    int i;


    //查看key是否存在
    o = lookupKeyRead(c->db, c->argv[1]);
    //如果类型不匹配则直接报错
    if (o != NULL && o->type != REDIS_HASH) {
        addReply(c, shared.wrongtypeerr);
        return;
    }
    //基于参数输出key的数量
    addReplyMultiBulkLen(c, c->argc-2);
    //便利key的valu并输出
    for (i = 2; i < c->argc; i++) {
        addHashFieldToReply(c, o, c->argv[i]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 查询字典所有键值对(hgetall指令)

如果我们希望获取字典所有字段的键值对，那么我们就可以使用hetall指令，还是以user为例，对应的指令使用方式为：

hgetall user
1

hgetall逻辑比较简单，通过key限定为到字典，然后遍历字典的每一个键值对返回，这里我们也直接给出源码，可以看到hgetall指令对应的函数为hgetallCommand，可以看到它直接复用了genericHgetallCommand方法，传入REDIS_HASH_KEY|REDIS_HASH_VALUE即查询当前字典的所有键值对：

void hgetallCommand(redisClient *c) {
    //传入REDIS_HASH_KEY|REDIS_HASH_VALUE告知键值对都需要
    genericHgetallCommand(c,REDIS_HASH_KEY|REDIS_HASH_VALUE);
}
1
2
3
4

当然如果我们希望查询key，那么对应的查询参数为REDIS_HASH_KEY，仅仅查value则是REDIS_HASH_KEY以此做到函数复用：

# 删除字典某个字段(hdel指令)

最后就是字典删除操作，如果我们想删除user的name字段，则可以直接键入指令hdel user name aaaaa即可。 基于hdel删除时redis服务端首先会根据传入的key定位到字典，然后遍历参数中的每一个字段将其删除，以我们的删除指令hdel user name aaaa为例，因为user对象并没有aaaa这个字段，所以进行删除操作时只能删除name字段，最终响应用户成功码时也就返回1，这也就说明hdel操作返回的是实际上删除到的字段数：

对应的我们给出hdel源码实现，大体流程如上所说，当这个字典对象所有字段都被删除之后，redis服务端就会将这个字典对象删除：

void hdelCommand(redisClient *c) {
    robj *o;
    int j, deleted = 0, keyremoved = 0;
    //字典查询和类型校验
    if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,REDIS_HASH)) return;
    //遍历键值对的key值
    for (j = 2; j < c->argc; j++) {
        //调用hashTypeDelete删除指定字典下的键值对
        if (hashTypeDelete(o,c->argv[j])) {
            deleted++;
            //如果字典长度为0则删除当前字典
            if (hashTypeLength(o) == 0) {
                dbDelete(c->db,c->argv[1]);
                keyremoved = 1;
                break;
            }
        }
    }
  	//......
    //返回实际上删除的字段数
    addReplyLongLong(c,deleted);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 小结

自此我们将字典操作所有的指令都从源码的角度分析完成，希望对你有帮助。

我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

Redis 常用操作命令，非常详细！ :https://cloud.tencent.com/developer/article/1367408 (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
聊聊redis中的字典设计与实现
高效索引的秘密：redis跳表设计与实现

← 高效索引的秘密：redis跳表设计与实现→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×