c++ hiredis封装

最新推荐文章于 2024-08-18 10:13:12 发布
最新推荐文章于 2024-08-18 10:13:12 发布
阅读量1w 收藏 2
点赞数 1
文章标签： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hualucky/article/details/40114457
版权
/*
 * ----------------------------------------------------------------------------
 * Copyright (c) 2013-2014, xSky <guozhw at gmail dot com>
 * All rights reserved.
 * Distributed under GPL license.
 * ----------------------------------------------------------------------------
 */


#ifndef _XREDIS_CLIENT_H_
#define _XREDIS_CLIENT_H_
#include "hiredis.h"


#include <stdint.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "util.h"




using namespace std;


#define MAX_ERR_STR_LEN 128


typedef std::string             KEY;
typedef std::string             VALUE;
typedef std::vector<KEY>        KEYS;
typedef std::vector<VALUE>      VALUES;
typedef std::vector<string>     VDATA;


typedef std::set<string>        SETDATA;










typedef struct _REDIS_NODE_
{
    unsigned int dbindex;
    const char  *host;
    unsigned int port;
    const char  *passwd;
    unsigned int poolsize;
    unsigned int timeout;
}RedisNode;




class xRedisClient;




typedef struct _DATA_ITEM_
 {
    int    type;
    string str;
}DataItem;


typedef std::vector<DataItem>       ReplyData;
typedef ReplyData                   ArrayReply;
typedef std::map<string, double>    ZSETDATA;






typedef enum _BIT_OP_
{
    AND = 0,
    OR  = 1,
    XOR = 2,
    NOT = 3
}BITOP;


typedef enum _LIST_MODEL_
 {
    BEFORE = 0,
    AFTER  = 1
}LMODEL;






#define PING_REDIS_SEC       5


class xRedisClient
{
public:
    xRedisClient(string host, const unsigned int  port, string pass, const unsigned int  timeout )
    {
       mHost     = host;
       mPort     = port;
       mPass     = pass;
       mTimeout  = timeout;
       mLastTime = 0;
    }
    
    ~xRedisClient()
    {
      if(mCtx)
      {
        redisFree(mCtx);
      }


      if(mStrerr)
      {
        delete(mStrerr);
      }
      
    }


public:


    //              connection
    /* ECHO        */  
    /* PING        */  
    /* QUIT        */  
    /* SELECT      */  
    //                 Commands operating on string values
    /* DECR        */  bool decr(const string& key, int& result);
    /* DECRBY      */  bool decrby(const string& key, const int by, int& result);
    /* GET         */  bool get(const string& key,  string& value);
    /* GETBIT      */  bool getbit(const string& key,  const int& offset, int& bit);
    /* GETRANGE    */  bool getrange(const string& key,  const int start, const int end, string& out);
    /* GETSET      */  bool getset(const string& key,  const string& newValue, string& oldValue);
    /* INCR        */  bool incr(const string& key, int& result);
    /* INCRBY      */  bool incrby(const string& key, const int by, int& result);
    /* INCRBYFLOAT */  
    /* MGET        */  bool mget(const KEYS &  keys, ReplyData& vDdata);
    /* MSET        */  bool mset(const VDATA& data);
    /* MSETNX      */  
    /* SET         */  bool set(const string& key,  const string& value);
    /* SETBIT      */  bool setbit(const string& key,  const int offset, const int64_t newbitValue, int64_t oldbitValue);
    /* SETEX       */  bool setex(const string& key,  const int seconds, const string& value);
    /* SETNX       */  bool setnx(const string& key,  const string& value);
    /* SETRANGE    */  bool setrange(const string& key,  const int offset, const string& value, int& length);
    /* STRLEN      */ // bool strlen(const string& key, int& length);
    /* DEL          */  bool del(const string& key);
                bool del(const KEYS &  vkey, int64_t& count);
    /* DUMP         */
    /* EXISTS       */  bool exists( const string& key);
    /* RANDOMKEY    */  bool randomkey(  KEY& key);
    /* HDEL         */  bool hdel(const string& key, const string& filed, int64_t& num);
                        bool hdel(const string& key, const KEYS& vfiled, int64_t& num);
    /* HEXISTS      */  bool hexist(const string& key, const string& filed);
    /* HGET         */  bool hget(const string& key, const string& filed, string& value);
    /* HGETALL      */  bool hgetall(const string& key, ArrayReply& array);
    /* HKEYS        */  bool hkeys(const string& key, KEYS& keys);
    /* HLEN         */  bool hlen(const string& key, int64_t& count);
    /* HMGET        */  bool hmget(const string& key, const KEYS& filed, ArrayReply& array);
    /* HMSET        */  bool hmset(const string& key, const VDATA& vData);
    /* HSCAN        */                                     
    /* HSET         */  bool hset(const string& key, const string& filed, const string& value, int64_t& retval);
    /* HSETNX       */  bool hsetnx(const string& key, const string& filed, const string& value);
    /* HVALS        */  bool hvals(const string& key, VALUES& values);


    /* LLEN         */  bool llen(const string& key, int64_t& len);
    /* LPOP         */  bool lpop(const string& key, string& value);
    /* LPUSH        */  bool lpush(const string& key, const VALUES& vValue, int64_t& length);
    /* LPUSHX       */  bool lpushx(const string& key, const string& value, int64_t& length);
    /* LRANGE       */  bool lrange(const string& key, const int64_t start, const int64_t end, ArrayReply& array);
    /* LTRIM        */  bool ltrim(const string& key,  const int start, const int end);
    /* RPOP         */  bool rpop(const string& key, string& value);
    /* RPOPLPUSH    */  bool rpoplpush(const string& key_src, const string& key_dest, string& value);
    /* RPUSH        */  bool rpush(const string& key, const VALUES& vValue, int64_t& length);
    /* RPUSHX       */  bool rpushx(const string& key, const string& value, int64_t& length);
    /* SADD         */  bool sadd(const KEY& key, const VALUES& vValue, int64_t& count);
    /* SMOVE        */  bool smove(const KEY& srckey, const KEY& deskey,  const VALUE& member);
    /* SPOP         */  bool spop(const KEY& key, VALUE& member);
    /* SRANDMEMBER  */  bool srandmember(const KEY& key, VALUES& vmember, int num=0);
    /* ZADD             */ bool zadd(const KEY& deskey,   const VALUES& vValues, int64_t& count);
private:
    void addparam(VDATA& vDes, const VDATA& vSrc) 
    {
        for (VDATA::const_iterator iter=vSrc.begin(); iter!=vSrc.end();++iter) 
        {
            vDes.push_back(*iter);
        }
    }


    bool command_bool(const char* cmd, ...);
    bool command_status(const char* cmd, ...);
    bool command_integer(int64_t &intval,   const char* cmd, ...);
    bool command_string(string &data,      const char* cmd, ...);
    bool command_list(VALUES &vValue,    const char* cmd, ...);
    bool command_array(ArrayReply& array, const char* cmd, ...);
    bool commandargv_bool(const VDATA& vData);
    bool commandargv_status(const VDATA& vData);
    bool commandargv_array(const VDATA& vDataIn, ArrayReply& array);
    bool commandargv_array(const VDATA& vDataIn, VALUES& array);
    bool commandargv_integer(const VDATA& vDataIn, int64_t& retval);




public:
    char *GetErrInfo()
    {
     return this->mStrerr;
    }
    
    bool SetErrInfo(const char *info)
    {
        if (NULL==info) 
        {
            return false;
        }


        if (NULL == this->mStrerr)
        {
            this->mStrerr = new char[MAX_ERR_STR_LEN];
        }


        if (NULL!=this->mStrerr) 
        {
            memset(this->mStrerr,0, MAX_ERR_STR_LEN);
            strncpy(this->mStrerr, info, MAX_ERR_STR_LEN);
            return true;
        }
        return false;
    }






    bool CheckReply(const redisReply *reply)
    {
        if(NULL==reply) 
        {
            return false;
        }


        switch(reply->type)
        {
        case REDIS_REPLY_STRING:
        {
        return true;
        }
        case REDIS_REPLY_ARRAY:
        {
        return (strcasecmp(reply->str,"OK") == 0)?true:false;
        }
        case REDIS_REPLY_INTEGER:
        {
        return true;
        }
        case REDIS_REPLY_NIL:
        {
        return false;
        }
        case REDIS_REPLY_STATUS:
        {
        return (strcasecmp(reply->str,"OK") == 0)?true:false;
        }
        case REDIS_REPLY_ERROR:
        {
        return false;
        }
        default:
        {
        return false;
        }
        }


        return false;
    }




   
   
   void FreeReply(const redisReply *reply)
   {
       if (NULL!=reply) 
       {
           freeReplyObject((void*)reply);
       } 


   }


   
    bool RedisConnect() 
    {
     
      bool bRet = false;
      struct timeval timeoutVal;
      timeoutVal.tv_sec  = mTimeout;
      timeoutVal.tv_usec = 0;


      mCtx = redisConnectWithTimeout(mHost.c_str(), mPort, timeoutVal);
      if (NULL == mCtx || mCtx->err) 
      {
          if (NULL!=mCtx) 
          {
              redisFree(mCtx);
          } else
          {


          }
      } else
      {
          if (0 == mPass.size()) 
          {
              bRet = true;
          } else 
          {
              redisReply *reply = static_cast<redisReply *>(redisCommand(mCtx,"AUTH %s", mPass.c_str()));
              if((NULL==reply)||(strcasecmp(reply->str,"OK") != 0)) 
              {
                  bRet = false;
              }
              freeReplyObject(reply);
          }
      }


      return bRet;
    }




    bool Ping() const
    {
        redisReply *reply = static_cast<redisReply *>(redisCommand(mCtx,"PING"));
        bool bRet = (NULL!=reply);
        freeReplyObject(reply);
        return bRet;
    }




   
   //计算频率
    bool checkRedisNetwork()
    {
       time_t tick = time(NULL);
       if(tick >= mLastTime + PING_REDIS_SEC)
       {    
           if(Ping() == false)
           {
               DEBUG_LOG("检测redis断开");
               this->RedisConnect();
           }
           mLastTime = tick;
       }
    }


    redisContext  *getCtx() const     
    {
        return mCtx;
    }
     redisContext *mCtx;
private:
    char        *mStrerr;
    string  mHost;         // redis host
    unsigned int  mPort;          // redis sever port
    string mPass;         // redis server password
    unsigned int  mTimeout;       // connect timeout second
    time_t mLastTime;      //
};




#endif



/*
 * ----------------------------------------------------------------------------
 * Copyright (c) 2013-2014, xSky <guozhw at gmail dot com>
 * All rights reserved.
 * Distributed under GPL license.
 * ----------------------------------------------------------------------------
 */






#include "redis_client.h"
#include <sstream>


#include <stdlib.h>






bool xRedisClient::command_bool( const char *cmd, ...)
{
    bool bRet = false;




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(mCtx, cmd, args));
    va_end(args);


    if (CheckReply(reply))
{
        bRet = (reply->integer==1)?true:false;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}




bool xRedisClient::command_status( const char* cmd, ...) 
{
    bool bRet = false;


    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(mCtx, cmd, args));
    va_end(args);


    if (CheckReply(reply)) 
{
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);
    return bRet;
}


bool xRedisClient::command_integer( int64_t &retval, const char* cmd, ...) 
{
    bool bRet = false;


if(this->mCtx == NULL)
{
return bRet;
}




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(this->mCtx, cmd, args));
    va_end(args);

    if (CheckReply(reply)) 
{
        retval = reply->integer;
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_string( string &data, const char* cmd, ...) 
{
    bool bRet = false;


if(this->mCtx == NULL)
{
return bRet;
}




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        data = reply->str;
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_list( VALUES &vValue, const char* cmd, ...) 
{
    bool bRet = false;
    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        for (unsigned int i =0; i<reply->elements; i++) 
{
            vValue.push_back(reply->element[i]->str);
        }
        bRet  = true;
    } else 
    {
         SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_array(  ArrayReply& array,  const char* cmd, ...){


bool bRet = false;


    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast<redisReply *>(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        for (unsigned int i =0; i<reply->elements; i++) 
{
            DataItem item;
            item.type = reply->element[i]->type;
            item.str  = reply->element[i]->str;
            array.push_back(item);
        }
        bRet  = true;
    } else 
   {


        SetErrInfo(reply->str);
    }


    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_bool( const VDATA& vData) {
    bool bRet = false;


    vector<const char *> argv( vData.size() );
    vector<size_t> argvlen( vData.size() );
    unsigned int j = 0;
    for ( vector<string>::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }


    redisReply *reply = static_cast<redisReply *>(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply)) 
{
        bRet = (reply->integer==1)?true:false;
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_status( const VDATA& vData)
{
    bool bRet = false;
    vector<const char *> argv( vData.size() );
    vector<size_t> argvlen( vData.size() );
    unsigned int j = 0;
    for ( vector<string>::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast<redisReply *>(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        bRet = true;
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_array( const VDATA& vDataIn, ArrayReply& array)
{
    bool bRet = false;
    vector<const char*> argv( vDataIn.size() );
    vector<size_t> argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector<string>::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast<redisReply *>(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        for (unsigned int i =0; i<reply->elements; i++) 
{
            DataItem item;
            item.type = reply->element[i]->type;
            item.str  = reply->element[i]->str;
            array.push_back(item);
        }
        bRet  = true;
    } else 
    {


        SetErrInfo(reply->str);
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_array( const VDATA& vDataIn, VALUES& array)
{
    bool bRet = false;
    vector<const char*> argv( vDataIn.size() );
    vector<size_t> argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector<string>::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast<redisReply *>(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        for (unsigned int i =0; i<reply->elements; i++) 
{
            array.push_back(reply->element[i]->str);
        }
        bRet  = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);
   
    return bRet;
}


bool xRedisClient::commandargv_integer( const VDATA& vDataIn, int64_t& retval)
{
    bool bRet = false;




    vector<const char*> argv( vDataIn.size() );
    vector<size_t> argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector<string>::const_iterator iter = vDataIn.begin(); iter != vDataIn.end(); ++iter, ++j ) 
{
        argv[j] = iter->c_str(), argvlen[j] = iter->size();
    }


    redisReply *reply = static_cast<redisReply *>(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply)) 
{
        retval = reply->integer;
        bRet  = true;
    } else 
    {


        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}








bool xRedisClient::incr( const string& key, int& result) 
{
return command_integer((int64_t&)result, "INCR %s", key.c_str());
}




bool xRedisClient::set( const string& key, const  string& value) 
{
VDATA vCmdData;
vCmdData.push_back("SET");
vCmdData.push_back(key);
vCmdData.push_back(value);
return commandargv_status( vCmdData);
}




bool  xRedisClient::del(const string& key)
{
    return command_bool( "DEL %s", key.c_str());
}




bool xRedisClient::hdel(const string& key, const string& filed, int64_t& count) 
{
    return command_integer( count, "HDEL %s %s %s", key.c_str(), filed.c_str());
}


bool xRedisClient::hdel(const string& key, const KEYS& vfiled, int64_t& count) 
{
    VDATA vCmdData;
    vCmdData.push_back("HDEL");
    vCmdData.push_back(key);
    addparam(vCmdData, vfiled);
    return commandargv_integer(vCmdData, count);
}


bool xRedisClient::hexist(const string& key, const string& filed)
{
    return command_bool("HEXIST %s %s %s", key.c_str(), filed.c_str());
}


bool xRedisClient::hget(const string& key, const string& filed, string& value) 
{
    return command_string(value, "HGET %s %s %s", key.c_str(), filed.c_str());
}


bool  xRedisClient::hgetall(const string& key, ArrayReply& array)
{
    return command_array( array, "HGETALL %s", key.c_str());
}






bool xRedisClient::hkeys(const string& key, KEYS& keys)
{
    return command_list(keys, "HKEYS %s", key.c_str());
}


bool xRedisClient::hlen(const string& key, int64_t& count)
{
    return command_integer(count, "HLEN %s", key.c_str());
}




bool xRedisClient::hmget(const string& key, const KEYS& filed, ArrayReply& array)
{
    VDATA vCmdData;
    vCmdData.push_back("HMGET");
    vCmdData.push_back(key);
    addparam(vCmdData, filed);
    return commandargv_array(vCmdData, array);
}






bool xRedisClient::hmset(const string& key, const VDATA& vData)
{
    VDATA vCmdData;
    vCmdData.push_back("HMGET");
    vCmdData.push_back(key);
    addparam(vCmdData, vData);
    return commandargv_bool(vCmdData);
}


bool xRedisClient::hset(const string& key, const string& filed, const string& value, int64_t& retval)
{
    return command_integer( retval, "HSET %s %s %s", key.c_str(), filed.c_str(), value.c_str());
}






bool xRedisClient::hvals(const string& key, VALUES& values) 
{
    return command_list( values, "HVALS %s", key.c_str());
}


bool xRedisClient::exists(const string& key) 
{
    return command_bool( "EXISTS %s", key.c_str());
}




bool xRedisClient::randomkey( KEY& key)
{
    return command_string( key, "RANDOMKEY");
}








bool xRedisClient::llen(const string& key, int64_t& retval)
{
    return command_integer(retval, "LLEN %s", key.c_str());
}


bool xRedisClient::lpop(const string& key, string& value)
{
    return command_string(value, "LPOP %s", key.c_str());
}


bool xRedisClient::lpush(const string& key, const VALUES& vValue, int64_t& length)
{
    VDATA vCmdData;
    vCmdData.push_back("lpush");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer(vCmdData, length);
}


bool xRedisClient::lrange( const string& key, const int64_t start, const int64_t end, ArrayReply& array)
{
    return command_array(array, "LRANGE %s", key.c_str(), start, end);
}






bool xRedisClient::ltrim(const string& key, const int start, const int end)
{
    return command_status( "ltrim %s %d %d", key.c_str(), start, end);
}


bool xRedisClient::rpop(const string& key, string& value)
{
    return command_string(value, "LPOP %s", key.c_str());
}


bool xRedisClient::rpoplpush(const string& key_src, const string& key_dest, string& value)
{
    return command_string(value, "RPOPLPUSH %s %s", key_src.c_str(), key_dest.c_str());
}


bool xRedisClient::rpush(const string& key, const VALUES& vValue, int64_t& length)
{
    VDATA vCmdData;
    vCmdData.push_back("rpush");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer( vCmdData, length);
}


bool xRedisClient::rpushx( const string& key, const string& value, int64_t& length)
{
    return command_integer(length, "RPUSHX %s %s", key.c_str(), value.c_str());
}


//sets
bool xRedisClient::sadd( const string& key, const VALUES& vValue, int64_t& count)
{
    VDATA vCmdData;
    vCmdData.push_back("SADD");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer(vCmdData, count);
}




bool xRedisClient::smove(const KEY& srckey, const KEY& deskey,  const VALUE& member)
{
    return command_bool( "SMOVE %s", srckey.c_str(), deskey.c_str(), member.c_str());
}


bool xRedisClient::spop(const KEY& key, VALUE& member)
{
    return command_string(member, "SPOP %s", key.c_str());
}


bool xRedisClient::srandmember(const KEY& key, VALUES& members, int count)
{
    if (0==count) 
{
        return command_list( members, "SRANDMEMBER %s", key.c_str());
    }
    return command_list( members, "SRANDMEMBER %s %d", key.c_str(), count);
}




bool xRedisClient::zadd( const KEY& key,   const VALUES& vValues, int64_t& count)
{
    VDATA vCmdData;
    vCmdData.push_back("ZADD");
    vCmdData.push_back(key);
    addparam(vCmdData, vValues);
    return commandargv_integer( vCmdData, count);
}


 
 bool xRedisClient::setbit(const string& key,  const  int offset, const int64_t newbitValue, int64_t oldbitValue) 
 {
return command_integer(oldbitValue, "SETBIT %s %d %lld", key.c_str(), offset, newbitValue);
 }
 
 bool xRedisClient::get(const string& key,  string& value) 
 {
return command_string(value, "GET %s", key.c_str());
 }




 
 bool xRedisClient::getbit( const string& key, const int& offset, int& bit )
 {
return command_integer((int64_t&)bit, "GETBIT %s %d", key.c_str(), offset);
 }
 
 bool xRedisClient::getrange(const string& key,  const  int start, const int end, string& out) 
 {
return command_string(out, "GETRANGE %s %d %d", key.c_str(), start, end);
 }
 
 bool xRedisClient::getset(const string& key,  const string& newValue, string& oldValue)
 {
return command_string(oldValue, "GETSET %s %s", key.c_str(), newValue.c_str());
 }
 




 bool xRedisClient::setrange(const string& key,  const int offset, const string& value, int& length) 
 {
return command_integer((int64_t&)length, "setrange %s %d %s", key. c_str(), offset, value.c_str());
 }




 


 bool xRedisClient::incrby(const string& key, const int by, int& result)
 {
return command_integer((int64_t&)result, "INCR %s %d", key.c_str(), by);
 }






 
bool xRedisClient::decr( const string& key, int& result)
{
 return command_integer((int64_t&)result,"decr %s", key.c_str());
}
 
 bool xRedisClient::decrby( const string& key, const int by, int& result)
 {
return command_integer((int64_t&)result, "decrby %s %d", key.c_str(), by);
 }





















۞边城浪子
关注
redis c++ 库封装之路（二）了解hiredis
随风飘扬的尘土
10-21 368
针对不同的语言有不同的操作redis的库。 Hiredis就是一个C库函数，提供了基本的操作函数。 是库就有接口，本着8/2 原则，很多东西重要的往往是其中的20%。 用到的主要的接口就4个，这四个基本实现80%的需求。 ```c redisContext *redisConnect(const char *ip, int port); void *redisCommand(redisContext *c, const char *format, ...); void freeReplyObject(vo
hiredis的c++封装， 线程安全
11-07
hiredis的c++封装， 线程安全， 提供对键值对、队列、散列、集合结构的读写
【redis】c/c++操作redis（对于hiredis的封装）
weixin_34179762的博客
03-02 989
前言 最近一直在学习redis，通过c/cpp来执行redis命令，使用的是hiredis客户端来实现的。 先简单贴一下代码 头文件 #include <vector> #include <string> #include <hiredis/hiredis.h> typedef enum en_redisResultType { redis_reply_...
xRedis 项目使用教程
最新发布
gitblog_00354的博客
08-18 377
xRedis 项目使用教程 xredisRedis C++ client, support the data slice storage, support redis cluster, thread-safe,multi-platform,connection pool, read/write separation.项目地址:https://gitcode.com/gh_mirrors/xre/...
基于 hiredis c++调用redis 封装
06-24
c++ 调用 redis 封装
对hiredis二次封装以及c++的json源码
03-24
里面包括redis源码，hiredis源码，以及二次封装的源码，以及json源码
c++ hiredis 封装线程安全
08-07
封装hiredis使其线程安全，需要考虑到在多线程环境下，访问Redis服务器可能产生的竞态条件和线程安全问题。 首先，可以通过使用互斥锁（mutex）来实现对hiredis的封装。在每个对Redis的操作函数（如连接、执行命令...
封装hiredis
追求卓越
05-22 657
　　在菜鸟教程自学了redis，总想着像Mysql一样，在C/C++中进行对接。于是查询了一些资料，最后找到了hiredis。然而直接用它的话，难免有点不方便。于是，对其进行封装。　　hiredis直接去git上克隆，地址：https://github.com/redis/hiredis。　　下载好之后，由于其自带Makefile，只要make一下就编译出静态库与动态库了，接着把头文件和静/动态库...
基于hiredis封装的redis哨兵模式的C++库（跨平台支持）
05-11
这个是我自己用C++写的基于hiredis封装的redis哨兵模式的库，支持windows/linux 跨平台编译, windows下是静态库，linux编译出来是动态库so 该库功能包含了redis哨兵模式的服务启动，关闭，几乎涵盖了所有常用的...
redis交叉编译以及redis.conf配置说明--hiredis的c++封装以及测试
12-11
包含redis的源码，交叉编译，redis.conf的配置说明，以及hiredis的c++封装，直接使用，可专注于业务层面代码的实现，验证平台am57xx，linux-4.14.79，详细说明见的交叉编译移植以及hiredis的c++封装测试例程>>
HiRedis库封装
XYY_CN的博客
02-26 1055
context中比较常用的是 err错误码、errstr错误信息、connect_timeout、 command_timeout两个超时时间。对于连接池往往存在Get, Put两个操作，为了避免用户忘记Put, 在获取一个连接时，对shared_ptr的析构进行指明，解决了这一问题。,第一个参数是创建的context,后面的参数则是redis命令，返回的是redisReply指针。redisContext是非线程安全的，多数情况下需要我们自己封装一个连接池，对连接进行复用。
基于libev的hiredis多线程实现
fangfanglovezhou的博客
04-08 1298
在博文https://blog.csdn.net/fangfanglovezhou/article/details/104984849 中，我们介绍了基于libev的异步接口的调用方法，再次给出代码： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal...
使用 hiredis 客户端库封装一个简单的 Redis 类
小杰312的博客
04-18 996
redisConnect返回值都是靠redisContext连接上下文来接收的 eg: m_publish_context, m_subscribe_context，之后就通过操作redisContext对象来完成与Redis服务器的交互过程。然后，它会等待所有命令执行完成，并将执行结果存储在相应的回复对象中，以便程序后续处理。函数用于将输出缓冲区中的 Redis 命令发送到 Redis 服务器，并等待服务器的响应。它会阻塞当前线程，直到所有待发送的命令都已经发送完成，并且等待所有命令的执行结果返回。
C++ 使用 hiredis 封装redis 的数据获取接口
weixin_33958585的博客
08-16 566
整合自互联网 一、hiredis 类库的安装 tar -zxvf hiredis-v0.13.3.tar.gz make make install mkdir /usr/lib/hiredis cp libhiredis.so /usr/lib/ //将动态连接库libhiredis.so至/usr/lib/ mkdir /usr/include/hiredis cp hiredis.h /u...
C++通过hiredis连接到redis
taw19960426的博客
03-09 1821
在Linux下通过C++代码调用hiredis的接口，实现连接
封装hiredis——C++与redis对接（一）（string的SET与GET操作）
weixin_30597269的博客
12-15 270
　　在菜鸟教程自学了redis，总想着像Mysql一样，在C/C++中进行对接。于是查询了一些资料，最后找到了hiredis。然而直接用它的话，难免有点不方便。于是，对其进行封装。 　　hiredis直接去git上克隆，地址：https://github.com/redis/hiredis。 　　下载好之后，由于其自带Makefile，只要make一下就编译出静态库与动态库了，接着把头文件和静...
hiredis-win32二次封装
02-24
个人封装的好用的hiredis-win32的二次封装，让你用C++简单操作redis，带自动重连， 关联blog ，http://blog.csdn.net/lightspear/article/details/54858713
redis(源码1):封装hiredis库，提供直观的C++函数操作
wentianyao的专栏
01-21 5510
最近抽时间把hiredis给封装了一下，便于编程,不用每次都查命令 redis命令查询地址:http://doc.redisfans.com/index.html 源码部分稍后会上传到资源包位置。 /* * redis_interface.h * Author: ws * Data: 2015-12-24 *  */ #ifndef REDIS_I
C扩展Hiredis调用Redis并整合到MySQL插件中
txl13109187932的博客
12-24 1083
一、使用C/C++为Mysql开发扩展函数 二、使用C/C++扩展Hiredis和Redis交互 三、整合（用sql操作redis） #可能遇到的问题
hiredis源码分析与简单封装
qianbo042311的博客
06-26 1424
hiredis Hiredis是一个开源C库函数,提供了基本的操作redis 函数， 如数据库连接、发送命令、释放资源等等 1、hiredis net hiredis 本身就是做了跨平台的代码，c语言打造可以执行在多种平台上，看看他的net块做了些什么 #include "fmacros.h" #include <sys/types.h> #ifdef _WIN32 #ifndef FD_SETSIZE #define FD_SETSIZE 16000 #endif #else #includ
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值