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

         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