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 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 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 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
Kod sumber laman web
Dapatkan kaedah pemegang tingkap
Perisian pangkalan data yang biasa digunakan
Apakah pangkalan data dalam memori?
Perbezaan antara api rehat dan api
Yang manakah mempunyai kelajuan bacaan yang lebih pantas, mongodb atau redis?
Cara menggunakan redis sebagai pelayan cache
Bagaimana redis menyelesaikan ketekalan data
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
