學習總結一下官方釋出的C版本客戶端 hiredis，瞭解hiredis 客戶端大致實現細節。在理解程式碼之間需要了解通訊協議的特點，我上一篇轉載的文章已經有過介紹，大家可以去看一下。

hiredis 提供了同步、非同步訪問，非同步 API 需要與一些事件庫協同工作，主要看一下同步API的實現。

hiredis 與服務端通訊的API比較簡單，主要有這幾個步驟：

• 建立連線
• 傳送命令
• 等待結果並處理
• 釋放連線

一、相關資料結構

redisContext 儲存連線建立後的上下文。 err 儲存錯誤碼，如果為0表示沒錯，如果非0那麼錯誤說明儲存在 errstr 中；fd是連線建立後的套接字；flags

/* Context for a connection to Redis */
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 */

    enum redisConnectionType connection_type;
    struct timeval *timeout;

    struct {
        char *host;
        char *source_addr;
        int
 
 port;
    } tcp;

    struct {
        char *path;
    } unix_sock;

} redisContext;

/* This is the reply object returned by redisCommand() */
typedef struct redisReply {
    int type; /* REDIS_REPLY_* */
    long long integer; /* The integer when type is REDIS_REPLY_INTEGER */
    size_t len; /* Length of string */
    char *str; /* Used for both REDIS_REPLY_ERROR and REDIS_REPLY_STRING */
    size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
    struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */
} redisReply;

redisReply 這個結構是儲存傳送命令後得到的返回結果，type 表示伺服器返回結果的型別，比如 REDIS_REPLY_STRING，表示返回一個 string，此時內容就儲存在 str 這個成員中，其他成員類似。有下面這幾種型別：

#define REDIS_REPLY_STRING 1
#define REDIS_REPLY_ARRAY 2
#define REDIS_REPLY_INTEGER 3
#define REDIS_REPLY_NIL 4
#define REDIS_REPLY_STATUS 5
#define REDIS_REPLY_ERROR 6

（二）相關 api

建立連線

redisContext *redisConnect(const char *ip, int port);
redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv);
redisContext *redisConnectNonBlock(const char *ip, int port);
redisContext *redisConnectBindNonBlock(const char *ip, int port,
                                       const char *source_addr);
redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
                                                const char *source_addr);
redisContext *redisConnectUnix(const char *path);
redisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv);
redisContext *redisConnectUnixNonBlock(const char *path);
redisContext *redisConnectFd(int fd);

這些 api 都是建立連線的，可以根據需求或者條件選擇合適的。連線建立成功返回 redisContext，將連線資訊放到這個結構中，通過 err 成員來判斷是否建立成功。

傳送命令並等待結果

redisCommand 和 redisAppendCommand 系列函式用來向伺服器傳送命令。

redisCommand -> redisvCommand -> redisvAppendCommand -> __redisAppendCommand

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

這個函式組裝傳送的命令到redisContext 的 obuf 中，obuf 可以動態擴容，所以不用擔心溢位；接下來在函式 redisCommand 中呼叫 __redisBlockForReply，繼而呼叫 redisGetReply 這個函式來獲取返回結果。

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

這個函式分下面幾步實現：
- 首先檢視 redisReader 結構中的 buf 成員是否有資料，有的話則解析出 reply 並返回，否則進入下面；
- 把 obuf 緩衝區的資料全部寫入 c->fd，寫完後釋放 obuf；
- 接下來阻塞讀取伺服器返回的結果並將其放入redisContext -> redisReader -> buf 緩衝區中，進入下一步；
- 呼叫 redisGetReplyFromReader 解析 buf 中的資料，並返回reply；獲取到的 redisReply 物件需要呼叫 freeReplyObject 顯式釋放，否則會洩漏。

redisAppendCommand 這個函式將傳送的命令格式化放入 redisContext 的 obuf 中，可以一次傳送多條命令，然後接收一批結果，結果按照發送命令的順序儲存，這裡利用了 pipeline 特性，可以減少網路傳輸的次數，提高IO吞吐量。

釋放連線

使用完一個連線後需要呼叫 redisFree 函式來釋放這個連線，主要是關閉套接字，釋放申請的緩衝區。

void redisFree(redisContext *c) {
    if (c == NULL)
        return;
    if (c->fd > 0)
        close(c->fd);
    sdsfree(c->obuf);
    redisReaderFree(c->reader);
    free(c->tcp.host);
    free(c->tcp.source_addr);
    free(c->unix_sock.path);
    free(c->timeout);
    free(c);
}

一個例子

下面給出一個例子，對這幾個API最基本的使用，測試的時候需要先安裝 redis-server 並啟動，預設埠為 6379，同時需要安裝 hiredis 庫，sudo yum install hiredis-devel，或者原始碼安裝。

/*************************************************************************
    > File Name: redis-cli.c
    > Author: Tanswer_
    > Mail: [email protected]
    > Created Time: Thu Jun 28 15:49:43 2018
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <hiredis/hiredis.h>

int main()
{

    redisContext* c = redisConnect((char*)"127.0.0.1", 6379);
    if(c->err){
        redisFree(c);
        return 0;
    }
    printf("connect redis-server success.\n");

    const char* command = "set good luck";
    redisReply* r = (redisReply*)redisCommand(c, command);
    if(r == NULL){
        redisFree(c);
        return 0;
    }

    if(!(r->type == REDIS_REPLY_STATUS && strcasecmp(r->str, "OK") == 0)){
        printf("Failed to execute command[%s].\n", command);
        freeReplyObject(r);
        redisFree(c);
        return 0;
    }

    freeReplyObject(r);
    printf("Succeed to execute command[%s].\n", command);

    const char* command1 = "strlen good";
    r = (redisReply*)redisCommand(c, command1);
    if(r->type != REDIS_REPLY_INTEGER){
        printf("Failed to execute command[%s].\n", command1);
        freeReplyObject(r);
        redisFree(c);
        return 0;
    }

    int length = r -> integer;
    freeReplyObject(r);
    printf("The length of 'good' is %d.\n", length);
    printf("Succeed to execute command[%s].\n", command1);

    const char* command2 = "get good";
    r = (redisReply*)redisCommand(c, command2);
    if(r -> type != REDIS_REPLY_STRING){
        printf("Failed to execute command[%s].\n", command2);
        freeReplyObject(r);
        redisFree(c);
        return 0;
    }

    printf("The value of 'goo' is %s.\n", r->str);
    freeReplyObject(r);
    printf("Succeed to execute command[%s].\n", command2);

    redisFree(c);

    return 0;
}