点击下载
本文文档

当前位置：首页 - 科技 - 知识百科 - 正文

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

来源：动视网责编：小采时间：2020-11-09 16:29:08

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx:Redis的sentinel模式使用了Hiredis代码，Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand，使用方法类于printf。因此只要熟悉redis命令，就可以很容易的使用该函数将redis命令字符串，转换成统一请求协议

推荐度：

点击下载本文 文档为doc格式

导读Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx:Redis的sentinel模式使用了Hiredis代码，Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand，使用方法类于printf。因此只要熟悉redis命令，就可以很容易的使用该函数将redis命令字符串，转换成统一请求协议

Redis的sentinel模式使用了Hiredis代码，Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand，使用方法类于printf。因此只要熟悉redis命令，就可以很容易的使用该函数将redis命令字符串，转换成统一请求协议式之

Redis的sentinel模式使用了Hiredis代码，Hiredis是redis数据库一个轻量级的C语言客户端库。它实现的向Redis发送命令的API函数redisCommand，使用方法类似于printf。因此只要熟悉redis命令，就可以很容易的使用该函数将redis命令字符串，转换成统一请求协议格式之后，发送给Redis服务器。

Hiredis库包含三类API：同步操作API、异步操作API和回复解析API。本文主要介绍同步操作API和回复解析API，下一篇介绍异步操作API。

一：同步操作API

所谓的同步操作，就是以阻塞的方式向Redis服务器建链，发送命令，接收命令回复。使用同步操作API，主要涉及以下三个API函数：

redisContext *redisConnect(const char *ip, int port);
void *redisCommand(redisContext *c, const char *format, ...);
void freeReplyObject(void *reply);

1：TCP建链

redisConnect函数创建一个上下文结构redisContext，并向Redis服务器发起TCP建链。该函数是同步建链API，因此该函数返回后，要么TCP已经建链成功了，要么建链期间发生了错误，可以通过检查redisContext结构的err和errstr属性得到错误类型和错误类型。

redisConnect的代码较简单，如下：

redisContext *redisConnect(const char *ip, int port) {
 redisContext *c;

 c = redisContextInit();
 if (c == NULL)
 return NULL;

 c->flags |= REDIS_BLOCK;
 redisContextConnectTcp(c,ip,port,NULL);
 return c;
}

redisContext上下文结构用于保存所有与Redis服务器连接的状态。比如socket描述符，输出缓存，回复解析器等。该结构的定义如下：

typedef struct redisContext {
 int err; /* Error flags, 0 when there is no error */
 char errstr[128]; /* String representation of error when applicable */
 int fd;
 int flags;
 char *obuf; /* Write buffer */
 redisReader *reader; /* Protocol reader */
} redisContext;

属性err为非0时，表示与Redis服务器的连接发生了错误，属性errstr就包含一个描述该错误的字符串。因此，每次与Redis进行交互之后，就需要检查该属性判断是否发生了错误，一旦有错误发生，则立即终止与Redis的链接。

属性fd就是与Redis服务器链接的socket描述符；flags表示客户端标志位，表示客户端当前的状态；

obuf就是输出缓存，当用户调用redisCommand向Redis发送命令时，命令字符串首先就是追加到该输出缓存中；

reader是一个回复解析器，后续在“回复解析API”中会详细介绍。

2：发送命令，接收回复

用户可以调用redisCommand函数向Redis服务器发送命令，该函数返回Redis的回复信息。该函数的原型如下：

void *redisCommand(redisContext *c, const char *format, ...)

该函数类似于printf，支持不定参数，使用起来很方便，比如：

 reply = redisCommand(context, "SET foo bar");

redisCommand函数返回NULL表示发生了错误，可以通过检查redisContext结构中的err得到错误类型；如果执行成功，则返回值是一个指向redisReply结构的指针，其中包含了Redis的回复信息。

可以在格式字符串中使用”%s”，表示在命令中插入一个字符串，此时使用strlen判断字符串的长度：

 reply = redisCommand(context, "SET foo %s", value);

如果需要在命令中传递二进制安全的字符串，可以使用”%b”，此时需要一个size_t类型的参数表示该字符串的长度：

 reply = redisCommand(context, "SET foo %b", value, (size_t) valuelen);

redisCommand主要是通过redisvCommand实现的，而redisvCommand主要是通过redisvAppendCommand和__redisBlockForReply两个函数实现。它们的代码如下：

void *redisvCommand(redisContext *c, const char *format, va_list ap) {
 if (redisvAppendCommand(c,format,ap) != REDIS_OK)
 return NULL;
 return __redisBlockForReply(c);
}

void *redisCommand(redisContext *c, const char *format, ...) {
 va_list ap;
 void *reply = NULL;
 va_start(ap,format);
 reply = redisvCommand(c,format,ap);
 va_end(ap);
 return reply;
}

redisvAppendCommand函数作用是解析用户的输入，并将用户输入的命令字符串转换成Redis统一请求协议的格式，存储到上下文结构redisContext中的输出缓存obuf中，它的代码如下：

int redisvAppendCommand(redisContext *c, const char *format, va_list ap) {
 char *cmd;
 int len;

 len = redisvFormatCommand(&cmd,format,ap);
 if (len == -1) {
 __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
 return REDIS_ERR;
 }

 if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {
 free(cmd);
 return REDIS_ERR;
 }

 free(cmd);
 return REDIS_OK;
}

int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) {
 sds newbuf;

 newbuf = sdscatlen(c->obuf,cmd,len);
 if (newbuf == NULL) {
 __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
 return REDIS_ERR;
 }

 c->obuf = newbuf;
 return REDIS_OK;
}

redisvAppendCommand首先调用redisvFormatCommand函数，用于解析用户输入的命令字符串，并将字符串转换成协议格式之后，保存在cmd中。然后调用__redisAppendCommand函数，将cmd追加到输出缓存c->obuf中。代码较简单，不在赘述。

在redisvCommand函数中，调用redisvAppendCommand之后，接下来就是调用__redisBlockForReply函数，将输出缓存中的内容发送给Redis服务器，并读取Redis的回复，并解析之。

__redisBlockForReply函数主要是通过redisGetReply实现的，它们的代码如下：

static void *__redisBlockForReply(redisContext *c) {
 void *reply;

 if (c->flags & REDIS_BLOCK) {
 if (redisGetReply(c,&reply) != REDIS_OK)
 return NULL;
 return reply;
 }
 return NULL;
}
int redisGetReply(redisContext *c, void **reply) {
 int wdone = 0;
 void *aux = NULL;

 /* Try to read pending replies */
 if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
 return REDIS_ERR;

 /* For the blocking context, flush output buffer and read reply */
 if (aux == NULL && c->flags & REDIS_BLOCK) {
 /* Write until done */
 do {
 if (redisBufferWrite(c,&wdone) == REDIS_ERR)
 return REDIS_ERR;
 } while (!wdone);

 /* Read until there is a reply */
 do {
 if (redisBufferRead(c) == REDIS_ERR)
 return REDIS_ERR;
 if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
 return REDIS_ERR;
 } while (aux == NULL);
 }

 /* Set reply object */
 if (reply != NULL) *reply = aux;
 return REDIS_OK;
}

在redisGetReply中，首先是循环调用redisBufferWrite，将输出缓存c->obuf中的所有内容发送给Redis。然后循环调用redisBufferRead，读取Redis的回复，并调用函数redisGetReplyFromReader对回复信息进行解析。

redisBufferRead函数的代码如下：

int redisBufferRead(redisContext *c) {
 char buf[1024*16];
 int nread;

 /* Return early when the context has seen an error. */
 if (c->err)
 return REDIS_ERR;

 nread = read(c->fd,buf,sizeof(buf));
 if (nread == -1) {
 if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
 /* Try again later */
 } else {
 __redisSetError(c,REDIS_ERR_IO,NULL);
 return REDIS_ERR;
 }
 } else if (nread == 0) {
 __redisSetError(c,REDIS_ERR_EOF,"Server closed the connection");
 return REDIS_ERR;
 } else {
 if (redisReaderFeed(c->reader,buf,nread) != REDIS_OK) {
 __redisSetError(c,c->reader->err,c->reader->errstr);
 return REDIS_ERR;
 }
 }
 return REDIS_OK;
}

该函数主要是从socket中读取数据到buf中，然后通过函数redisReaderFeed，将buf内容追加到解析器的输入缓存中。redisReaderFeed函数属于回复解析API函数。

二：回复解析API

回复解析API的函数主要有下面几个：

 redisReader *redisReaderCreate(void);
 void redisReaderFree(redisReader *reader);
 int redisReaderFeed(redisReader *reader, const char *buf, size_t len);
 int redisReaderGetReply(redisReader *reader, void **reply);

1：输入缓存

解析器结构redisReader，是回复解析API最主要的数据结构。它的部分定义如下：

/* State for the protocol parser */
typedef struct redisReader {
 int err; /* Error flags, 0 when there is no error */
 char errstr[128]; /* String representation of error when applicable */

 char *buf; /* Read buffer */
 size_t pos; /* Buffer cursor */
 size_t len; /* Buffer length */
 size_t maxbuf; /* Max length of unused buffer */
 ...
} redisReader;

其中的err和errstr属性与redisContext结构中的err和errstr属性作用一样，都是用于保存错误类型和错误信息的；

buf属性就是输入缓存，redisReaderFeed函数将读取到的Redis回复信息都存储到该缓存中，该缓存根据回复信息可以动态扩容。len表示当前缓存的容量；pos表示缓存当前的读取索引，每次读取输入缓存时，都是从reader->buf + reader->pos处开始读取，读取数据之后，会增加pos的值；

maxbuf属性表示输入缓存所允许的最大闲置空间。为了节省内存空间，当buf为空，并且当前buf的闲置空间大于reader->maxbuf时，就会释放r->buf，重新为其申请空间。该属性的默认值为16K。如果置为0，表示无此。

redisReaderFeed就是将从socket读取的Redis回复信息，追加到输入缓存的函数。其代码如下：

int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
 sds newbuf;

 /* Return early when this reader is in an erroneous state. */
 if (r->err)
 return REDIS_ERR;

 /* Copy the provided buffer. */
 if (buf != NULL && len >= 1) {
 /* Destroy internal buffer when it is empty and is quite large. */
 if (r->len == 0 && r->maxbuf != 0 && sdsavail(r->buf) > r->maxbuf) {
 sdsfree(r->buf);
 r->buf = sdsempty();
 r->pos = 0;

 /* r->buf should not be NULL since we just free'd a larger one. */
 assert(r->buf != NULL);
 }

 newbuf = sdscatlen(r->buf,buf,len);
 if (newbuf == NULL) {
 __redisReaderSetErrorOOM(r);
 return REDIS_ERR;
 }

 r->buf = newbuf;
 r->len = sdslen(r->buf);
 }

 return REDIS_OK;
}

2：解析

在redisGetReply函数中，将Redis的回复信息追加到解析器输入缓存之后，接下来就会调用函数redisGetReplyFromReader对解析器的输入缓存中的消息进行解析，解析的内容以redisReply结构进行组织。

如果回复信息是嵌套的话，则形成一颗以redisReply结构为节点的多叉树；如果回复信息只是基本信息的话，则该树仅仅包含一个根节点。redisCommand函数就是返回一个指向redisReply结构树根节点的指针。redisReply结构树的宽度没有，但是深度的最大值为7，也就是仅允许最多7层嵌套。

首先看一下redisReply结构的定义如下：

/* This is the reply object returned by redisCommand() */
typedef struct redisReply {
 int type; 
 long long integer; 
 int len; 
 char *str; 
 size_t elements; 
 struct redisReply **element; 
} redisReply;

该结构中的type成员表示Redis回复信息的类型，可以有下面几种类型：

REDIS_REPLY_STATUS：状态回复，状态信息以'+'开头。str属性保存Redis回复的状态信息字符串，该字符串的长度保存在len属性中。

REDIS_REPLY_ERROR：错误回复，错误信息以'-'开头。str属性保存Redis回复的错误信息字符串，该字符串的长度保存在len属性中。

REDIS_REPLY_INTEGER：整数回复，整数信息以':'开头。integer 属性保存Redis回复的整数值。

REDIS_REPLY_STRING：单行字符串回复，这种信息以'$'开头。str属性保存Redis回复的字符串信息，该字符串的长度保存在len属性中。

REDIS_REPLY_NIL：Redis回复”nil”。

以上的类型可以称为基本类型。

REDIS_REPLY_ARRAY：数组回复，也就是嵌套回复，数组信息以'*'开头，后接数组元素个数。数组中的元素可以是以上所有基本类型，也可以是REDIS_REPLY_ARRAY类型，也就是数组嵌套数组。

数组元素的个数保存在elements属性中，数组元素也以redisReply结构表示，指向数组元素的指针保存在element指针数组中，也就是说，指针数组element中保存了所有孩子节点的指针。

经过回复解析API函数redisReaderGetReply的解析之后，最终形成的redisReply结构树，非叶子节点只能是REDIS_REPLY_ARRAY类型，叶子节点的类型只能是基本类型。

处理数组信息的代码较复杂，以一个例子说明。假设Redis的回复信息是："*3\r\n*3\r\n:11\r\n:12\r\n:13\r\n*3\r\n:21\r\n:22\r\n:23\r\n:31\r\n"。

分析该字符串，第一个字符为”*”，表明这是一条数组回复，后面的3表示数组元素的个数，因此，最终形成的树，根节点有3个孩子节点。

接下来就是根节点各个孩子节点的信息。第一个孩子节点首字符还是”*”，说明该孩子节点又是一个数组信息，它也有3个孩子。接下来就是3个孩子信息，也就是3个整数：11，12和13。

接下来是根节点第二个孩子节点的信息。首字符还是”*”，说明该孩子节点也是一个数组，它也有3个孩子，分别是整数：21，22和23。

接下来是根节点最后一个孩子的信息，首字符是”:”，说明该孩子节点是一个整数，整数值为31。

根据以上的分析，最终形成的树如下图：

上图中，非叶子节点都是REDIS_REPLY_ARRAY类型的redisReply结构，叶子节点是REDIS_REPLY_INTEGER类型的redisReply结构。

回复解析API函数redisReaderGetReply的作用，就是解析回复信息，最终形成一颗这样的redisReply结构树。

在回复解析API的代码中，使用redisReadTask任务结构解析回复信息，构建每个redisReply结构节点，填充到树中合适的位置。

redisReadTask结构包含解析器结构redisReader中，redisReader结构剩下的定义如下：

typedef struct redisReader {
 ...
 redisReadTask rstack[9];
 int ridx; /* Index of current read task */
 void *reply; /* Temporary reply pointer */

 redisReplyObjectFunctions *fn;
 void *privdata;
} redisReader;

在redisReader结构中，redisReadTask结构数组rstack大小为9。rstack[0]用于处理redisReply结构树中的根节点；rstack[1]表示处理redisReply结构树中的第一层子节点，以此类推。

ridx属性表示当前正在处理第几层子节点；fn属性是一个redisReplyObjectFunctions结构体，该结构中包含了用于生成各种类型redisReply结构的函数；

reply属性指向redisReply结构树中的根节点

构建每个redisReply结构节点的redisReadTask结构定义如下：

typedef struct redisReadTask {
 int type;
 int elements; /* number of elements in multibulk container */
 int idx; /* index in parent (array) object */
 void *obj; /* holds user-generated value for a read task */
 struct redisReadTask *parent; /* parent task */
 void *privdata; /* user-settable arbitrary field */
} redisReadTask;

type表示该redisReadTask结构当前处理的信息类型，与其当前构建的redisReply结构节点中的type一致；

elements表示当前构建的REDIS_REPLY_ARRAY类型的redisReply结构节点中，包含的子节点数目。也就是redisReply结构节点中，数组element中的元素个数；idx表示当前构建的redisReply结构节点，在其父节点element数组中的索引；obj就是指向当前正在构建的REDIS_REPLY_ARRAY 类型的redisReply结构节点，parent表示正在处理当前节点的父节点的redisReadTask结构。

回复解析API函数redisReaderGetReply的代码如下：

int redisReaderGetReply(redisReader *r, void **reply) {
 /* Default target pointer to NULL. */
 if (reply != NULL)
 *reply = NULL;

 /* Return early when this reader is in an erroneous state. */
 if (r->err)
 return REDIS_ERR;

 /* When the buffer is empty, there will never be a reply. */
 if (r->len == 0)
 return REDIS_OK;

 /* Set first item to process when the stack is empty. */
 if (r->ridx == -1) {
 r->rstack[0].type = -1;
 r->rstack[0].elements = -1;
 r->rstack[0].idx = -1;
 r->rstack[0].obj = NULL;
 r->rstack[0].parent = NULL;
 r->rstack[0].privdata = r->privdata;
 r->ridx = 0;
 }

 /* Process items in reply. */
 while (r->ridx >= 0)
 if (processItem(r) != REDIS_OK)
 break;

 /* Return ASAP when an error occurred. */
 if (r->err)
 return REDIS_ERR;

 /* Discard part of the buffer when we've consumed at least 1k, to avoid
 * doing unnecessary calls to memmove() in sds.c. */
 if (r->pos >= 1024) {
 sdsrange(r->buf,r->pos,-1);
 r->pos = 0;
 r->len = sdslen(r->buf);
 }

 /* Emit a reply when there is one. */
 if (r->ridx == -1) {
 if (reply != NULL)
 *reply = r->reply;
 r->reply = NULL;
 }
 return REDIS_OK;
}

首先，将r->ridx置为0，然后初始化r->rstack[0]，表示接下来开始构建根节点。

接下来的语句，就是循环调用processItem函数，直到r->ridx再次等于-1。循环调用processItem函数的过程，就是以深度优先的顺序构建redisReply结构树的过程。

processItem函数的代码如下：

static int processItem(redisReader *r) {
 redisReadTask *cur = &(r->rstack[r->ridx]);
 char *p;

 /* check if we need to read type */
 if (cur->type < 0) {
 if ((p = readBytes(r,1)) != NULL) {
 switch (p[0]) {
 case '-':
 cur->type = REDIS_REPLY_ERROR;
 break;
 case '+':
 cur->type = REDIS_REPLY_STATUS;
 break;
 case ':':
 cur->type = REDIS_REPLY_INTEGER;
 break;
 case '$':
 cur->type = REDIS_REPLY_STRING;
 break;
 case '*':
 cur->type = REDIS_REPLY_ARRAY;
 break;
 default:
 __redisReaderSetErrorProtocolByte(r,*p);
 return REDIS_ERR;
 }
 } else {
 /* could not consume 1 byte */
 return REDIS_ERR;
 }
 }

 /* process typed item */
 switch(cur->type) {
 case REDIS_REPLY_ERROR:
 case REDIS_REPLY_STATUS:
 case REDIS_REPLY_INTEGER:
 return processLineItem(r);
 case REDIS_REPLY_STRING:
 return processBulkItem(r);
 case REDIS_REPLY_ARRAY:
 return processMultiBulkItem(r);
 default:
 assert(NULL);
 return REDIS_ERR; /* Avoid warning. */
 }
}

首先得到构建当前节点的redisReadTask结构cur，然后从输入缓存中读取首个字符，以判断接下来的回复信息的类型，赋值到cur->type中。

得到类型信息之后，就调用不同的函数处理不同的类型。首先看一下处理数组类型的函数processMultiBulkItem的实现：

static int processMultiBulkItem(redisReader *r) {
 redisReadTask *cur = &(r->rstack[r->ridx]);
 void *obj;
 char *p;
 long elements;
 int root = 0;

 /* Set error for nested multi bulks with depth > 7 */
 if (r->ridx == 8) {
 __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
 "No support for nested multi bulk replies with depth > 7");
 return REDIS_ERR;
 }

 if ((p = readLine(r,NULL)) != NULL) {
 elements = readLongLong(p);
 root = (r->ridx == 0);

 if (elements == -1) {
 if (r->fn && r->fn->createNil)
 obj = r->fn->createNil(cur);
 else
 obj = (void*)REDIS_REPLY_NIL;

 if (obj == NULL) {
 __redisReaderSetErrorOOM(r);
 return REDIS_ERR;
 }

 moveToNextTask(r);
 } else {
 if (r->fn && r->fn->createArray)
 obj = r->fn->createArray(cur,elements);
 else
 obj = (void*)REDIS_REPLY_ARRAY;

 if (obj == NULL) {
 __redisReaderSetErrorOOM(r);
 return REDIS_ERR;
 }

 /* Modify task stack when there are more than 0 elements. */
 if (elements > 0) {
 cur->elements = elements;
 cur->obj = obj;
 r->ridx++;
 r->rstack[r->ridx].type = -1;
 r->rstack[r->ridx].elements = -1;
 r->rstack[r->ridx].idx = 0;
 r->rstack[r->ridx].obj = NULL;
 r->rstack[r->ridx].parent = cur;
 r->rstack[r->ridx].privdata = r->privdata;
 } else {
 moveToNextTask(r);
 }
 }

 /* Set reply if this is the root object. */
 if (root) r->reply = obj;
 return REDIS_OK;
 }

 return REDIS_ERR;
}

首先得到构建当前节点的redisReadTask结构cur，然后调用readLine函数，从输入缓存中读取一行信息（”\r\n”之前的内容），并解析出当前节点中包含的元素个数elements。

如果elements不是-1，说明正确解析到了数组元素个数，接下来调用r->fn->createArray创建一个数组类型的redisReply结构节点。然后将创建的redisReply结构信息记录到cur中：将元素个数记录到cur->elements中，将创建的redisReply记录到cur->obj中：

cur->elements = elements;
cur->obj = obj;

数组类型的redisReply结构节点创建完成后，接下来就是开始构建其各个子节点。首先就是将r->ridx加1，并初始化r->rstack[r->ridx]结构，注意这里置r->rstack[r->ridx].idx为0.表示接下来首先构建第一个子节点。

下面是创建数组类型redisReply结构的函数createArrayObject的代码：

static void *createArrayObject(const redisReadTask *task, int elements) {
 redisReply *r, *parent;

 r = createReplyObject(REDIS_REPLY_ARRAY);
 if (r == NULL)
 return NULL;

 if (elements > 0) {
 r->element = calloc(elements,sizeof(redisReply*));
 if (r->element == NULL) {
 freeReplyObject(r);
 return NULL;
 }
 }

 r->elements = elements;

 if (task->parent) {
 parent = task->parent->obj;
 assert(parent->type == REDIS_REPLY_ARRAY);
 parent->element[task->idx] = r;
 }
 return r;
}

该函数中，重点是要理解下面的代码：

 if (task->parent) {
 parent = task->parent->obj;
 assert(parent->type == REDIS_REPLY_ARRAY);
 parent->element[task->idx] = r;
 }

这段代码的作用，就是将指向新创建的redisReply结构节点的指针r，存放到其父节点的element数组中，存放索引就是task->idx。

如果task->parent不为NULL，说明当前新建的redisReply结构节点具有父节点，根据当前task得到该父节点redisReply结构parent。然后将当前节点放到存储到父节点的element数组中的task-idx索引处。

接下来是moveToNextTask函数的实现，该函数的主要作用，实际上是变更属性r->ridx和cur->idx。说白了，就是为下一个要创建的节点，找到合适的位置。代码如下：

static void moveToNextTask(redisReader *r) {
 redisReadTask *cur, *prv;
 while (r->ridx >= 0) {
 /* Return a.s.a.p. when the stack is now empty. */
 if (r->ridx == 0) {
 r->ridx--;
 return;
 }

 cur = &(r->rstack[r->ridx]);
 prv = &(r->rstack[r->ridx-1]);
 assert(prv->type == REDIS_REPLY_ARRAY);
 if (cur->idx == prv->elements-1) {
 r->ridx--;
 } else {
 /* Reset the type because the next item can be anything */
 assert(cur->idx < prv->elements);
 cur->type = -1;
 cur->elements = -1;
 cur->idx++;
 return;
 }
 }
}

在while循环中，首先得到处理当前节点的redisReadTask结构cur，然后是正处理该节点父节点的redisReadTask结构prv。

cur->idx记录了当前处理的节点，其在父节点中的element数组中的索引，也就是当前节点是父节点的第几个孩子。

prv->elements表示当前节点的父节点，共有几个孩子。

因此，如果cur->idx小于prv->elements的话，则接下来，cur结构要开始构建当前节点的下一个兄弟节点了，因此将cur->idx加1。

如果cur->idx等于prv->elements的话，说明当前节点，已经是其父节点最后一个孩子节点了。接下来，就开始构建当前节点的叔叔结点了（父节点的兄弟节点），因此r->ridx--，表示回溯。上移一层，将父结点变成当前节点，然后接着判断新的cur点在其父节点中是否是最后一个孩子，若是，则接着回溯，否则开始构建其兄弟节点。

如果当前节点已经是根节点了（r->ridx == 0），因为根节点没有兄弟节点，因此将r->ridx置为-1后，直接返回。

构建好一颗redisReply结构树之后，如果需要释放它，可以通过API函数freeReplyObject实现，代码如下：

void freeReplyObject(void *reply) {
 redisReply *r = reply;
 size_t j;

 switch(r->type) {
 case REDIS_REPLY_INTEGER:
 break; /* Nothing to free */
 case REDIS_REPLY_ARRAY:
 if (r->element != NULL) {
 for (j = 0; j < r->elements; j++)
 if (r->element[j] != NULL)
 freeReplyObject(r->element[j]);
 free(r->element);
 }
 break;
 case REDIS_REPLY_ERROR:
 case REDIS_REPLY_STATUS:
 case REDIS_REPLY_STRING:
 if (r->str != NULL)
 free(r->str);
 break;
 }
 free(r);
}

标准的深度优先顺序进行释放。不再赘述。

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

推荐度：

点击下载本文 文档为doc格式

标签：同步接口 API

热门焦点

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

Redis源码解析：18Hiredis同步API和回复解析API代码解析.docx

最新推荐

猜你喜欢

热门推荐