禅与计算机
sharkchili
2024-08-29
目录

硬核详解redis客户端指令与服务端传输协议RESP

# 写在文章开头

redis为了保证传输高效和二进制安全(文本中的\r\n等不会被当做换行)，客户端与服务端进行指令传输的时候使用的都是RESP协议，而本文将直接从源码的角度分析redis如何基于解析协议并执行过程，希望对你有帮助。

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

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

# 详解客户端指令请求与服务端解析过程

# 简述RESP协议

在正式进入源码分析之前，我们先对协议进行基本的介绍，按照RESP协议规范，协议对应字符串可分为:

  1. 简单字符串(Simple Strings)
  2. 操作错误字符串(Errors)
  3. 块字符串(Bulk Strings)
  4. 数组(Arrays)
  5. 整数(Integers)

先来说说简单字符串，我们通过redis客户端操作成功后，都会返回相应字符串，例如我们输入ping，返回pong，实际上这个字符串是+PONG\r\n只不过前后的符号被redis客户端抹掉了，这就是我们所说的简单字符串。

同理简单字符串还包括我们进行指令操作后回复成功的字符串OK，它也是一个简单字符串，一旦我们指令操作成功后，redis服务端也会基于+字符串\r\n这种格式生成OK字符串给我们：

与简单字符串相反的还有一个错误提示，当我们键入指令格式或者操作错误时就会收到类似于ERR unknown command 'xxx'的提示，这就是错题提示，其格式与简单字符串差不多，只不过符号位"-"，后面接错误提示字符串，然后拼接上换行符：

块字符串是redis实现二进制安全的核心，它记录的是每一个字符串的长度和字符串内容，以我们键入的ping指令为例，当我们通过客户端键入指令ping时，实际上传输的ping指令完整字符串为*1\r\n$4\r\nping\r\n，这里我们先忽略*1\r\n，这部分是数组的表示，笔者会在后续中表示。 块字符串是RESP保证二进制安全的核心设计所在，我们以ping为例，可以看到ping长度为4，所以$后面数字就是4，然后用\r\n表示换行，然后拼接字符串ping再用\r\n表示当前行结束：

有了块字符串的基础，接下来我们就可以介绍redis的核心指令概念——数组，这就是构成redis指令的数据结构，实际上我们提交给redis客户端的指令都是由数组构成，每一个用于表示数组字符串的开头都会用*+数字表示数组长度，然后后续接无数个字符串，格式就如上文所说这里就不多赘述。 我们还是以ping指令为例，基于按照数组规范，对应数组组装步骤为：

  1. 因为只有一个ping字符串，用*1表示数组长度为1。
  2. 拼接\r\n表示换行，开始拼接各种块字符串。
  3. 拼接ping的块字符串即$4\r\nping\r\n表示一个长度为4的字符串ping。

最终我们生成的数组如下所示：

同理我们以设置字符串键值对指令为例SET KEY VALUE，对应RESP协议，我们应该按照如下思路完成组装：

  1. 因为存在三个字符串分别是set key value，所以对应的数组长度为3，所以第一行字符串为*3。
  2. 按照字符串规范，set的格式为$3\r\nset\r\n。
  3. key和value同理。

最终生成的字符串如下所示：

# 基于源码RESP解析PING指令及处理过程

自此我们将基本的RESP格式都分析完成了，接下来笔者将直接通过源码解读方式来带读者解析RESP协议生成的指令字符串是如何完成解析，我们还是以PING为例，当我们键入ping指令后实际得到的字符串为*1$4\r\nping\r\n，redis服务器会先判断当前字符串头部是否为*符号开头，如果是则说明当前字符串是个数组，设置解析标志为多行标志REDIS_REQ_MULTIBULK。

然后获取*后面的值，数值为1，说明这个数组长度为1，记录该长度，循环读取1次，按照$获取长度、换行、基于$长度的规则拿到ping指令，然后再调用ping执行处理函数，服务端从共享池中拿到+PONG\r\n响应给客户端：

对应我们给出RESP字符解析函数的入口：

void processInputBuffer(redisClient *c) {
    /* Keep processing while there is something in the input buffer */
    while(sdslen(c->querybuf)) {
    	
       if (!c->reqtype) {
            if (c->querybuf[0] == '*') {//包含*号代表这是个多行的数组，设置reqtype为REDIS_REQ_MULTIBULK
                c->reqtype = REDIS_REQ_MULTIBULK;
            } else {
                c->reqtype = REDIS_REQ_INLINE;
            }
        }

        if (c->reqtype == REDIS_REQ_INLINE) {
           //......
        } else if (c->reqtype == REDIS_REQ_MULTIBULK) {//如果是多行则调用processMultibulkBuffer解析生成指令
            if (processMultibulkBuffer(c) != REDIS_OK) break;
        } else {
            redisPanic("Unknown request type");
        }

      
        if (c->argc == 0) {
           //......
        } else {
          //基于上述结果执行指令
            if (processCommand(c) == REDIS_OK)
                resetClient(c);
        }
    }
}
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

步入processMultibulkBuffer即可看到笔者所说的核心流程，即解析数组的长度，然后基于数组的长度去解析每一个$后对应的字符串存到数组argv中：

int processMultibulkBuffer(redisClient *c) {
    char *newline = NULL;
    int pos = 0, ok;
    long long ll;

    if (c->multibulklen == 0) {
     	//获取* 数组长度 \r\n这个字符串的\r的指针
        newline = strchr(c->querybuf,'\r');
       //......

     
       	//querybuf+1即得到*后面的数字，然后截取\r指针 - 数值指针获得变量长度，然后将长度值存入ll指针中
        ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);/
 		
 		//......
		//基于\r指针往后走两个到达&指针位置
        pos = (newline-c->querybuf)+2;
       //......
        //将multibulklen设置为数组长度值
        c->multibulklen = ll;

      //......
    }

  	//基于数组长度开始遍历
    while(c->multibulklen) {
       
        if (c->bulklen == -1) {
        	//获取多行字符串$后面的字符串\r的指针
            newline = strchr(c->querybuf+pos,'\r');
           //......
           
          
			//获取$后的长度存入ll中
            ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);//$位置+1得到字符串长度
           //......
			//基于$后面的\r的指针 - $符的指针= "$num\r" 的长度，基于这个值pos+2值得pos偏移量移动到$长度对应的字符串上
            pos += newline-(c->querybuf+pos)+2;//$后的\r减去$位置得到长度位置数据然后+2得到字符串位置
            //将字符串长度赋值给ll
            c->bulklen = ll;
        }

        /* Read bulk argument */
        if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {
    	  //......
        } else {
            //......
            if (pos == 0 &&
                c->bulklen >= REDIS_MBULK_BIG_ARG &&
                (signed) sdslen(c->querybuf) == c->bulklen+2)
            {
              //......
            } else {
            	//argv数组存入解析到的字符串
                c->argv[c->argc++] =
                    createStringObject(c->querybuf+pos,c->bulklen);
                pos += c->bulklen+2;//+2 即越过\r\n移动到下一个$的位置
            }
            //重置bulklen并扣减multibulklen
            c->bulklen = -1;
            c->multibulklen--;
        }
    }

  //......
}
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

基于上一步数组得到的ping字符串我们直接定位到了ping指令，其内部会直接从可复用的字符串共享池shared中拿到pong的简单字符串返回：

shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
void pingCommand(redisClient *c) {
   //......

    if (c->flags & REDIS_PUBSUB) {
     //......
    } else {
        if (c->argc == 1)
        	//从共享池中拿到pong响应给客户端
            addReply(c,shared.pong);
        else
           //......
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 继续深入了解SET指令解析与操作

有了上述的流程解析基础，对应SET指令的分析就轻松许多，对应的完整字符串为*3\r\n$3\r\nset\r\n$3\r\nkey\r\n$5\r\nvalue\r\n，还是按照上述源码所说首先解析到*后面的长度为3，由此数组长度为3，于是将reqType设置为REDIS_REQ_MULTIBULK，然后步入processMultibulkBuffer进行字符串解析，对此我们在贴出上文所说的代码，读者可以再次回顾一下：

void processInputBuffer(redisClient *c) {
    /* Keep processing while there is something in the input buffer */
    while(sdslen(c->querybuf)) {
    	
       if (!c->reqtype) {
            if (c->querybuf[0] == '*') {//包含*号代表这是个多行的数组，设置reqtype为REDIS_REQ_MULTIBULK
                c->reqtype = REDIS_REQ_MULTIBULK;
            } else {
               //......
            }
        }

        if (c->reqtype == REDIS_REQ_INLINE) {
           //......
        } else if (c->reqtype == REDIS_REQ_MULTIBULK) {//如果是多行则调用processMultibulkBuffer解析生成指令
            if (processMultibulkBuffer(c) != REDIS_OK) break;
        } else {
             //......
        }

      
        if (c->argc == 0) {
           //......
        } else {
          //基于上述结果执行指令
            if (processCommand(c) == REDIS_OK)
                resetClient(c);
        }
    }
}
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

然后就是步入processMultibulkBuffer解析到*后面为3，循环3次，依次解析出set、key、value存入argv中，对应我们基于逻辑给出注释代码：

int processMultibulkBuffer(redisClient *c) {
    char *newline = NULL;
    int pos = 0, ok;
    long long ll;

    if (c->multibulklen == 0) {
     	//获取*3\r\n这个字符串的\r的指针
        newline = strchr(c->querybuf,'\r');
       //......

     
       	//querybuf+1即得到*后面的数字，然后截取\r指针 - 数值指针获得变量长度，然后将长度值存入ll指针中
        ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);/
 		
 		//......
		//基于\r指针往后走两个到达&指针位置
        pos = (newline-c->querybuf)+2;
       //......
        //将multibulklen设置为数组长度值
        c->multibulklen = ll;

      //......
    }

  	//基于数组长度开始遍历
    while(c->multibulklen) {
       
        if (c->bulklen == -1) {
        	//获取多行字符串$3\r\n的\r指针位置
            newline = strchr(c->querybuf+pos,'\r');
           //......
           
          
			//获取$后的长度3存入ll中
            ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);//$位置+1得到字符串长度
           //......
			//基于$3\r\n的\r的指针 - $符的指针= "$3\r" 的长度，基于这个值pos+2即跨过\n来到set的s的position
            pos += newline-(c->querybuf+pos)+2;//$后的\r减去$位置得到长度位置数据然后+2得到字符串位置
            //将字符串长度3赋值给ll
            c->bulklen = ll;
        }

        
        if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {
    	  //......
        } else {
            //......
            if (pos == 0 &&
                c->bulklen >= REDIS_MBULK_BIG_ARG &&
                (signed) sdslen(c->querybuf) == c->bulklen+2)
            {
              //......
            } else {
            	//argv数组存入解析到的字符串
                c->argv[c->argc++] =
                    createStringObject(c->querybuf+pos,c->bulklen);
                pos += c->bulklen+2;//+2 即越过\r\n移动到下一个$的位置
            }
            //重置bulklen并扣减multibulklen
            c->bulklen = -1;
            c->multibulklen--;
        }
    }

  //......
}
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

最终argv数组就会得到包含操作指令set、键名称为key，值为value的数组：

# 更多关于redis的RESP传输协议

redis为了节约宝贵的内存资源，针对全局可复用的响应结果全部交由shared统一管理，所以从shared中这个结构体中

void createSharedObjects(void) {
    int j;
	//换行符
    shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
    //操作成功
    shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
    //操作错误
    shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
    //......
    shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
    shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
    //空块字符串，查询key不存在时使用
    shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
     //......
     //pong响应
    shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
    
    shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
    shared.emptyscan = createObject(REDIS_STRING,sdsnew("*2\r\n$1\r\n0\r\n*0\r\n"));
    //常见的错误响应 -错误原因\r\n
    shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
        "-WRONGTYPE Operation against a key holding the wrong kind of value\r\n"));
    shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
        "-ERR no such key\r\n"));
    shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
        "-ERR syntax error\r\n"));
    shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
        "-ERR source and destination objects are the same\r\n"));
    shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
        "-ERR index out of range\r\n"));
        //......
}
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

# 小结

同理的get对应的指令为*2\r\n$3\r\nget\r\n$3\r\nkey\r\n，相信读者对此也有自己的解析思路了，感兴趣可以基于上述代码走读调试一下。自此我们就将redis的RESP协议解析完成，希望对你有帮助。

我是 sharkchili ，CSDN Java 领域博客专家，开源项目—JavaGuide contributor，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。 因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

《redis设计与实现》

Redis协议(RESP )详解:https://blog.csdn.net/wangshuai6707/article/details/132742584#:~:text=RESP 是一个简单 (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
×
×