C++ 实现 redis 发布订阅 --- 使用 hiredis 同步API（三）

hiRedis基础教程 - 简书

本文只总结常规会用到的hiRedis使用方法，一般顺序为先用 redisConnect 连接数据库，然后用 redisCommand 执行命令，执行完后用 freeReplyObject 来释放redisReply对象，最后用 redisFree 来释放整个连接。

hiredis直接去git上克隆，地址：https://github.com/redis/hiredis，然后make && make install

连接

函数原型

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

使用示例

//连接redis，若出错redisContext.err会设置为1，redisContext.errstr会包含描述错误信息
redisContext *redis_handle = redisConnect("192.163.122.1", 8889);
if (redis_handle == NULL || redis_handle->err) {
    if (redis_handle) {
        printf("Error:%s\n", redis_handle->errstr);
    } else {
        printf("can't allocate redis context\n");
    }
    return -1;
}
//do your work
redisFree(redis_handle);

执行Redis命令

函数原型

typedef struct redisReply {
    int type; /* REDIS_REPLY_* */
    long long integer; /* The integer when type is REDIS_REPLY_INTEGER */
    int 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;

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

redisReply结构的type定义如下

• REDIS_REPLY_STATUS：
  表示返回了一个状态。状态字符串可以使用reply->str来访问。该字符串的长度可以使用reply->len来访问。例如set成功，会返回状态，str为"OK"
• REDIS_REPLY_ERROR：
  表示执行错误。错误字符串可以使用reply->str来访问
• REDIS_REPLY_INTEGER：
  表示返回一个整数。整数值可以使用long long类型的reply-> integer字段来访问
• REDIS_REPLY_NIL：
  表示返回空数据
• REDIS_REPLY_STRING：
  表示返回一个字符串。可以使用reply-> str来访问。该字符串的长度可以使用reply->len来访问。
• REDIS_REPLY_ARRAY：
  表示返回一个数组。例如mget，元素数量存储在reply->elements元素中。每个元素也是一个redisReply对象，可以通过reply-> element [index]进行访问。

使用示例

//set
string set_ = "set China Beijing";
redisReply *reply = (redisReply *)redisCommand(redis_handle, set_.c_str());
if (reply!=NULL && reply->type==REDIS_REPLY_STATUS) {
    printf("%s\n", reply->str);
}
freeReplyObject(reply);

//mset
string mset_ = "set China Beijing Japan Tokyo";
redisReply *reply = (redisReply *)redisCommand(redis_handle, mset_.c_str());
if (reply!=NULL && reply->type==REDIS_REPLY_STATUS) {
    printf("%s\n", reply->str);
}
freeReplyObject(reply);

//get
string get_ = "get China";
redisReply *reply = (redisReply *)redisCommand(redis_handle, get_.c_str());
if (reply!=NULL && reply->type==REDIS_REPLY_STRING) {
    printf("%s\n", reply->str);
}
freeReplyObject(reply);  //使用reply以后必须要进行释放

//mget
string mget_ = "mget China Japan";
redisReply *reply = (redisReply *)redisCommand(redis_handle, mget_.c_str());
if (reply!=NULL && reply->type==REDIS_REPLY_ARRAY) {
    for (int i=0; i<reply->elements; ++i) {
        printf("%s\n", reply->element[i]->str);
    }
}
freeReplyObject(reply);

 当命令执行发生错误时，reply为NULL，redis_handle中的err字段将被设置。一旦错误返回，redis_handle不能被重用，你应该建立一个新的连接。

redisReply *reply = (redisReply *)redisCommand(redis_handle, mget_str.c_str());
if (reply == NULL) {
    printf("Error:%s\n", redis_handle->errstr);
    redisReconnect(redis_handle);
}

进阶

由于hiRedis是非线程安全的，即一个redis_handle不能同时被多个线程使用，因此通过连接池解决并发访问redis的问题

#include <string>
#include <mutex>
#include "hiredis.h"

class redis_pool {

        public:
                redis_pool() {
                }

                ~redis_pool() {
                        for (int i=0; i<conn_num; ++i) {
                                if (conn_pool[i] != NULL) {
                                        redisFree(conn_pool[i]);
                                        conn_pool[i] = NULL;
                                }

                        }
                        delete [] conn_pool;

                        if (conn_flag != NULL) {
                                delete [] conn_flag;
                                conn_flag = NULL;
                        }
                }

                int init(std::string ip_, int port_, int conn_num_) {
                        ip = ip_;
                        port = port_;
                        conn_num = conn_num_;


                        conn_pool = new redisContext * [conn_num];
                        if (conn_pool == NULL) {
                                return 1;
                        }

                        conn_flag = new int[conn_num];
                        if (conn_flag == NULL) {
                                return 2;
                        }

                        for (int i=0; i<conn_num; ++i) {
                                conn_pool[i] = redisConnect(ip.c_str(), port);
                                if (conn_pool[i]==NULL || conn_pool[i]->err) {
                                        return 3;
                                }

                                conn_flag[i] = 0;
                        }

                        empty_num = conn_num;
                        current_conn = 0;

                        return 0;
                }

                redisContext *get_conn(int &id) {
                        if (empty_num == 0) {
                                return NULL;
                        }

                        mtx.lock();

                        while (conn_flag[current_conn] != 0) {current_conn = (current_conn+1) % conn_num;}

                        conn_flag[current_conn] = 1;
                        --empty_num;
                        id = current_conn;
                        current_conn = (current_conn+1) % conn_num;

                        mtx.unlock();

                        return conn_pool[id];
                }

                void put_conn(int id) {
                        if (id<conn_num && id>=0) {
                                mtx.lock();

                                conn_flag[id] = 0;
                                ++empty_num;

                                mtx.unlock();
                        }

                        return;
                }

        private:
                std::string ip;
                int port;
                int conn_num;

                redisContext **conn_pool;
                int *conn_flag;
                int empty_num;
                int current_conn;

                std::mutex mtx;

};

备注

• redis对于空闲连接，会在一定时间内关闭，当hiRedis的连接被关闭时，通过redisCommand返回的reply为NULL，需要调用redisReconnect重连
• 调用redisEnableKeepAlive并未达到保持连接的效果
• 当key不存在时，redisCommand并不会返回失败，只是str成员会为NULL

参考

• Hiredis 基本使用
• hiredis的使用