当前位置:Gxlcms > mysql > Redis源码解析:18Hiredis同步API和回复解析API代码解析.docx

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

时间:2021-07-01 10:21:17 帮助过:24人阅读

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);
}

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

以上就是回复解析API的主要工作流程。构建redisReply结构树和redisReadTask结构的作用比较晦涩,但是却是一个很好的构建多叉树的例子。学习代码时,脑子中跟着代码逐步建立这颗树就好理解了。

参考:

http://blog.csdn.net/it_small_farmer/article/details/41726293

人气教程排行