redis 学习-hiredis库使用（一）

redis 学习-hiredis库使用（一）

hiredis 是redis的客户端sdk，可以让程序操作redis。本文先讲建立连接，基本的get/set命令，读写二进制，获取多个结果来讲。假设读者已经了解redis命令了。
hiredis的代码也包含在redis代码中，redis\deps\hiredis目录下，接口很简单，几乎不用封装就可以用。

1 连接redis数据库

1.1 无超时时间，阻塞
redisContext *redisConnect(const char *ip, int port); 

1.1.1函数原型：
redisContext *redisConnect(const char *ip, int port);

1.1.2参数说明：
port：为redis数据监听的端口号，redis默认监听的端口号为6379
ip：为redis数据库的IP地址，可以是远程的，也可以是本地的127.0.0.1
1.1.3返回值
返回值是一个指向redisContext对象，可以不用了解这个对象的具体组成部分，只需要知道怎么使用就可以了。下面是其定义。
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;

1.1.4 使用例子
redisContext *c = redisConnect("127.0.0.1", 6379);
if (c == NULL || c->err) {
    if (c) {
        printf("Error: %s\n", c->errstr);
        // handle error
    } else {
        printf("Can't allocate redis context\n");
    }
}
这个redisContext不是一个线程安全的对象，也就是说，多个线程同时访问这一个对象可能会出现问题。

1.2 设置超时时间，阻塞
redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv);  
1.3 非阻塞，立刻返回，也就无所谓超时
redisContext *redisConnectNonBlock(const char *ip, int port);

1.4 发送命令请求

/**发送命令请求*/
void *redisCommand(redisContext *c, const char *format, ...);
void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
void redisAppendCommand(redisContext *c, const char *format, ...);
void redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);

1.5释放资源
/*释放资源*/
void freeReplyObject(void *reply);
void redisFree(redisContext *c);

2 执行命令

void *redisCommand(redisContext *c, const char *format, ...);
2.1 返回值
返回值是redisReply类型的指针：

/* This is the reply object returned by redisCommand() */
typedef struct redisReply {
    int type; /* REDIS_REPLY_* */
    PORT_LONGLONG 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;
2.2 返回值类型
type字段，包含以下几种类型：

#define REDIS_REPLY_STRING 1    //字符串
#define REDIS_REPLY_ARRAY 2     //数组，例如mget返回值
#define REDIS_REPLY_INTEGER 3   //数字类型
#define REDIS_REPLY_NIL 4       //空
#define REDIS_REPLY_STATUS 5    //状态，例如set成功返回的‘OK’
#define REDIS_REPLY_ERROR 6     //执行失败

REDIS_REPLY_STRING == 1:返回值是字符串,字符串储存在redis->str当中,字符串长度为redis->len。
REDIS_REPLY_ARRAY == 2：返回值是数组，数组大小存在redis->elements里面，数组值存储在redis->element[i]里面。数组里面存储的是指向redisReply的指针，数组里面的返回值可以通过redis->element[i]->str来访问，数组的结果里全是type==REDIS_REPLY_STRING的redisReply对象指针。
REDIS_REPLY_INTEGER == 3：返回值为整数 long long。
REDIS_REPLY_NIL==4：返回值为空表示执行结果为空。
REDIS_REPLY_STATUS ==5：返回命令执行的状态，比如set foo bar 返回的状态为OK，存储在str当中 reply->str == "OK"。
REDIS_REPLY_ERROR ==6 ：命令执行错误,错误信息存放在 reply->str当中。
返回结果示例：

set key value : 返回 string reply->str == "OK"。
hset key hkey value:返回 integer reply->integer == 1。
hdel key hkey:返回 integer reply->integer ==1。
sadd set member:返回 integer reply->integer ==1。
sismember setkey member:返回 integer reply->integer ==1。
smembers setkey:返回 array reply->element[i]->str为返回结果值。

3 redisCommandArgv函数

函数原型

void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
参数说明

argvlen这个数组存储了命令参数中，每一个参数的长度，包含命令本身，比如 set foo bar 则argvlen ={3,3,3},如果argvlen为空，那么这个函数内部会自动调用strlen函数对每个参数进行求长度。
argv 存放每个命令参数的指针，argv={"set","foo","bar"}
argc 存放命令参数的个数上面的例子中argc=3
c 为redisContext对象。
为每一个参数指定长度，可以是二进制安全的函数。函数会按着长度来决定字符串的终止，而不是'\0'.
char hkey[] = "123456";
char hset[] = "hset";
char key[] = "testkey";
char hvalue[] = "3210";
int argc = 4;
char *argv[] = {hset,key,hkey,hvalue};
size_t argvlen[] = {4,6,4,3};
redisCommandArgv(context,argc,argv,argvlen);
> hgetall testkey
会得到321并不会得到和hvalue一样的值"3210"，因为在hset命令中指定了长度，只会读取前面的三个字符。

4 redisAppendCommand*函数支持管道命令

函数原型：

void redisAppendCommand(redisContext *c, const char *format, ...);
void redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
int redisGetReply(redisContext *context,redisReply** reply);
参数说明：

redisAppendCommand函数和redisCommand函数参数一致，format可以指定特定参数的类型。
c 为redisContext对象
redisAppendCommandArgv函数和redisCommandArgv函数类似，参数含义也相同。
redisGetReply函数用来获得执行的结果的一条返回，并存储在reply所指的对象当中。成功返回REDIS_OK,否则返回REIDS_ERR。多条命令的一次性返回结果都存放在redisContext里面。
所不同的是，这个两个命令的结果。这两个函数是把多个命令存放在缓冲区内，然后一起发送给redis服务器，一次执行。可以通过redisGetReply函数从
redisContext中取出返回的结果。
使用例子：

redisReply *reply;
/*添加命令set */
redisAppendCommand(context,"SET foo bar");
/*添加命令get */
redisAppendCommand(context,"GET foo");
/*获取set命令结果*/
redisGetReply(context,&reply); // reply for SET
freeReplyObject(reply);
/*获取get命令结果*/
redisGetReply(context,&reply); // reply for GET
freeReplyObject(reply);
也可以使用这个功能来实现发布订阅功能。

reply = redisCommand(context,"SUBSCRIBE foo");
freeReplyObject(reply);
while(redisGetReply(context,&reply) == REDIS_OK) {
    // consume message
    freeReplyObject(reply);
}
所有的返回结果都需要释放资源调用freeReplyObject函数。这个函数会递归的释放数组中的资源，不需要手动释放数组资源。

5 释放资源

5.1函数原型
void freeReplyObject(void *reply);
void redisFree(redisContext *c);
5.2参数说明
freeReplyObject函数中reply 实际为指向redisReply结构体的指针，可能是redisCommand的返回值，后续可以看到以也能是管道命令执行结果的返回值。
redisFree函数中c实际为指向redisContext对象，这个函数会清理连接资源并释放连接。
如果使用c++来操作redis数据库，建议写一个类对这些C的接口进行封装，符合自己的逻辑。下面是一个可能使用方案。

class Redis
{
    public:
        redisContext* context;
        Redis(const char * ip="127.0.0.1",int port=6379){
            this->context = redisConnect(ip,port);
            if(this->context == NULL || context->err){
                if(context){
                    printf("Error: %s\n",context->errstr);
                    exit(-1);
                }else{
                    printf("can not allocate redis context\n");
                    exit(-1);
                }
            }
        }
        string hget(const char* key,const  char* hkey){
            const char* argv[3];
            size_t argvlen[3];
            argv[0] = "HGET";
            argvlen[0] = 4;
            argv[1] = key;
            argvlen[1] = strlen(key);
            argv[2] = hkey;
            argvlen[2] = strlen(hkey);
            redisReply* reply =(redisReply*) redisCommandArgv(this->context, 3, argv, argvlen);
            string value;
            if(reply->type != REDIS_REPLY_NIL){
                value = string(reply->str,reply->str + reply->len);
            }
            freeReplyObject(reply);
            return value;
        }
        int hset(const char* key, const char* hkey, const char* value){
            redisReply* reply =(redisReply*) redisCommand(this->context, "HSET %s %s %s",key,hkey, value);
            freeReplyObject(reply);
            return 1;
        }
        int hset(const char* key,const char* hkey,const char* hvalue, size_t hvaluelen){
            const char* argv[4];
            size_t argvlen[4];
            argv[0] = "HSET";
            argvlen[0] = 4;
            argv[1] = key;
            argvlen[1] = strlen(key);
            argv[2] = hkey;
            argvlen[2] = strlen(hkey);
            argv[3] = hvalue;
            argvlen[3] = hvaluelen;
            redisReply * reply =(redisReply*) redisCommandArgv(this->context, 4, argv, argvlen);
            freeReplyObject(reply);
            return 1;
        }
        /**delete key*/
        int del(const char* key){
            int res = 0;4
            redisReply* reply = (redisReply*)redisCommand(this->context, "DEL %s", key);
            if(reply->type == REDIS_REPLY_INTEGER){
                if(reply->integer == 1L)
                    res = 1;
            }
            freeReplyObject(reply);
            return res;
        }
        /*if Key ID exists*/
        int existsKey(const char* ID){
            redisReply * reply = (redisReply*)redisCommand(this->context,"exists %s",ID);
            int res = 0;
            if(reply->type == REDIS_REPLY_INTEGER){
                if(reply->integer == 1L)
                    res  = 1;
            }
            freeReplyObject(reply);
            return res;
        }
        virtual ~Redis(){
            redisFree(this->context);
        }
    protected:
    private:
};

6 基本命令，get，set

3.1 set
redisReply *r1 = (redisReply*)redisCommand(c, "set k v");
结果： type = 5

len = 2

str = OK
返回的类型5，是状态。str是OK，代表执行成功。

3.2 get
redisReply *r2 = (redisReply*)redisCommand(c, "get k");
结果： type = 1

len = 1

str = v
返回的类型是1，字符串类型，str是‘v’ ，刚才保存的。

7 存取二进制

char sz[] = { 0,1,2,3,0 };
redisReply *r3 = (redisReply*)redisCommand(c, "set kb %b",sz,sizeof(sz));
存二进制的时候，使用%b，后面需要对应两个参数，指针和长度。

redisReply *r4 = (redisReply*)redisCommand(c, "get kb");
读取二进制的时候，和普通是一样的，str字段是地址，len字段是长度。

8 存取多个值

存多个值
拼接字符串就好啦

redisReply *r5 = (redisReply*)redisCommand(c, "mset k1 v1 k2 v2");
取多个值
redisReply *r6 = (redisReply*)redisCommand(c, "mget k1 k2");
这里主要看返回值里的这两个字段，代表返回值个数和起始地址：

size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */
知道了以上知识，基本可以上手干活了，redis的接口还是很不错的，感觉都不用封装了。