Redis C语言操作封装

顺德公农庄

#ifndef BOYAA_FOURLANDLORD_REDISCLASS_H_20130217
#define BOYAA_FOURLANDLORD_REDISCLASS_H_20130217
#include "hiredis.h"
#include
#include
using namespace std;
typedef struct RedisConf
{
char pszServer[32];
int  nPort;
RedisConf()
{
memset(this, 0, sizeof(RedisConf));
}
}TRedisConf;
class CRedisClass
{
public:
CRedisClass(string& host, int& port, unsigned short second = 5);
~CRedisClass();
int ConnectRedis(const char* host, const unsigned short& port, const unsigned short second = 5);
int ConnectRedis();
int SetValue(const string &key, const string &value);
string &GetValue(const string &key, string &value);
bool DelValue(string &key);
bool ExiKey( string &key);
int Enqueue(const string &queue, const string &value);
string &Dequeue(const string &queue, string &value);
int Push(const string &stack, const string &value);
string &Pop(const string &stack, string &value);
bool IsActived();
bool Expire(const string& key, unsigned int sec);
bool ZRange(string& key, int start, int end, vector & ret);
int ZSize(const string& key);
int ZAdd(const string& key, const int value, const string& menber);
bool ZRemRangeByRank(const string& key, int min, int max);
string ZScore(const string& key, const string& member, string& score);
int ZRank(const string& key, const string& member);
int ZRevRank(const string& key, const string& member);
bool SetByte(const string & key, char * buf, int len);
int GetByte(const string & key, char * buf, int len);
bool SAdd(const string & key, const string & menber);
bool SRem(const string & key, const string & menber);
bool SMembers(const string & key, vector & ret);
bool LPush(const string & key, const string & menber);
bool RPush(const string & key, const string & menber);
bool LPop(const string & key, string & value);
bool RPop(const string & key, string & value);
bool RRange(const string & key, vector & ret);
bool LRem(const string & key, const string & menber);
int LLen(const string & key);
private:
TRedisConf m_RedisConf;            //redis配置
redisContext *m_Redis;
redisReply *m_Reply;
struct timeval timeout;
string redisHost;
unsigned short redisPort;
void freeReply();
bool ping();
CRedisClass(const CRedisClass& /*rhs*/){}
};
#endif

　　



#include "RedisClass.h"
#include
using namespace std;
CRedisClass::CRedisClass(string& host, int& port,unsigned short second/* = 5*/)
{
m_Reply = NULL;
redisHost = host;
redisPort = port;
timeout.tv_sec = second;
timeout.tv_usec = 0;
m_Redis = redisConnectWithTimeout(redisHost.c_str(), redisPort, timeout);
}
CRedisClass::~CRedisClass()
{
if(m_Reply)
{
freeReply();
}
if(m_Redis)
{
redisFree(m_Redis);
}
}
int CRedisClass::ConnectRedis(const char* host, const unsigned short& port, const unsigned short second/* = 5*/)
{
if (m_Redis)
{
redisFree(m_Redis);
}
struct timeval tv = {second, 0};
m_Redis = redisConnectWithTimeout(host, port, tv);
return m_Redis ? 0 : 1;
}
int CRedisClass::ConnectRedis()
{
if (m_Redis)
{
redisFree(m_Redis);
}
m_Redis = redisConnectWithTimeout(redisHost.c_str(), redisPort, timeout);
return m_Redis ? 0 : 1;
}
int CRedisClass::SetValue(const string& key, const string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "SET %s %s", key.c_str(), value.c_str()));
int result = 1;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 1;
}
freeReply();
return result;
}
string& CRedisClass::GetValue(const string& key, string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "GET %s", key.c_str()));
if(m_Reply != NULL && NULL != m_Reply->str)
{
value = m_Reply->str;
}
freeReply();
return value;
}
int CRedisClass::Enqueue(const string& queue, const string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "rpush %s %s", queue.c_str(), value.c_str()));
int result = 1;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 1;
}
freeReply();
return result;
}
string& CRedisClass::Dequeue(const string& queue, string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "lpop %s", queue.c_str()));
if (m_Reply)
{
if (m_Reply->type == 1)
{
value = m_Reply->str;
}
freeReply();
}
return value;  
}
int CRedisClass::Push(const string& stack, const string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "rpush %s %s", stack.c_str(), value.c_str()));
int result = 1;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 1;
}
freeReply();
return result;
}
string& CRedisClass::Pop(const string& stack, string& value)
{
m_Reply = static_cast(redisCommand(m_Redis, "rpop %s", stack.c_str()));
if(m_Reply != NULL)
{
value = m_Reply->str;
}
freeReply();
return value;
}
bool CRedisClass::DelValue(string& key)
{
m_Reply = reinterpret_cast(redisCommand(m_Redis, "DEL %s ", key.c_str()));
if(m_Reply != NULL)
{
freeReply();
return true;
}
return false;
}
bool CRedisClass::ExiKey(string& key)
{
int rec = 0;
m_Reply = reinterpret_cast(redisCommand(m_Redis, "EXISTS %s", key.c_str()));
if(m_Reply != NULL)
{
rec = m_Reply->integer;
freeReply();
return rec==1 ? true : false;
}
return false;
}
bool CRedisClass::IsActived()
{
return ping();
}
void CRedisClass::freeReply()
{
if(m_Reply)
{
freeReplyObject(m_Reply);
m_Reply = NULL;
}
}
bool CRedisClass::ping()
{
if (!m_Redis)
{
return false;
}
m_Reply = static_cast(redisCommand(m_Redis, "ping"));
bool IsActviced = false;
if (m_Reply != NULL)
{
IsActviced = strcmp("PONG", m_Reply->str) == 0 ? true : false;
freeReply();
}
return IsActviced;
}
bool CRedisClass::ZRange(string& key, int start, int end, vector & ret)
{
m_Reply = reinterpret_cast(redisCommand(m_Redis, "ZREVRANGE %s %d %d",
key.c_str(), start, end));
if(m_Reply != NULL)
{
for (int i = 0; i < m_Reply->elements; i++)
{
redisReply *r = m_Reply->element;
ret.push_back(r->str);
}
freeReply();
return true;
}
return false;
}
int CRedisClass::ZSize(const string& key)
{
m_Reply = static_cast(redisCommand(m_Redis, "ZCARD %s", key.c_str()));
int result = 0;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 0;
freeReply();
}
return result;
}
int CRedisClass::ZAdd(const string& key, const int value, const string& menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "ZADD %s %d %s", key.c_str(), value, menber.c_str()));
int result = 1;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 1;
freeReply();
}
return result;
}
bool CRedisClass::ZRemRangeByRank(const string& key, int min, int max)
{
m_Reply = static_cast(redisCommand(m_Redis, "ZREMRANGEBYRANK %s %d %d", key.c_str(), min, max));
int result = 1;
if(m_Reply != NULL)
{
result = m_Reply ? m_Reply->integer : 1;
freeReply();
}
return result;
}
string CRedisClass::ZScore(const string& key, const string& member, string& score)
{
m_Reply = static_cast(redisCommand(m_Redis, "ZSCORE %s %s", key.c_str(), member.c_str()));
if(m_Reply != NULL)
{
if (NULL != m_Reply->str)
{
score = m_Reply->str;
}
freeReply();
}
return score;
}
int CRedisClass::ZRank(const string& key, const string& member)
{
int ret = 1000000;
m_Reply = static_cast(redisCommand(m_Redis, "ZREVRANK %s %s", key.c_str(), member.c_str()));
if(m_Reply != NULL && 3 == m_Reply->type)
{
ret = m_Reply->integer;
freeReply();
}
return ret;
}
int CRedisClass::ZRevRank(const string& key, const string& member)
{
int ret = 1000000;
m_Reply = static_cast(redisCommand(m_Redis, "ZREVRANK %s %s", key.c_str(), member.c_str()));
if(m_Reply != NULL && 3 == m_Reply->type)
{
ret = m_Reply->integer;
freeReply();
}
return ret;
}
bool CRedisClass::Expire(const string& key, unsigned int sec)
{
m_Reply = static_cast(redisCommand(m_Redis, "EXPIRE %s %d", key.c_str(), sec));
bool result = false;
if(m_Reply != NULL)
{
result = true;
freeReply();
}
return result;
}
bool CRedisClass::SetByte(const string & key, char * buf, int len)
{
m_Reply = static_cast(redisCommand(m_Redis, "SET %b %b", key.c_str(), key.length(), buf, len));
int result = false;
if(m_Reply != NULL)
{
result = true;
freeReply();
}
return result;
}
int CRedisClass::GetByte(const string & key, char * buf, int len)
{
if (NULL != buf)
{
m_Reply = static_cast(redisCommand(m_Redis, "GET %s", key.c_str()));
if (NULL != m_Reply && len >= m_Reply->len)
{
memcpy(buf, m_Reply->str, m_Reply->len);
int iRet = m_Reply->len;
freeReply();
return iRet;
}
}
return 0;
}
bool CRedisClass::SAdd(const string & key, const string & menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "SADD %s %s", key.c_str(), menber.c_str()));
bool result = false;
if(m_Reply != NULL)
{
if (1 == m_Reply->integer)
{
result = true;
}
freeReply();
}
return result;
}
bool CRedisClass::SRem(const string & key, const string & menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "SREM %s %s", key.c_str(), menber.c_str()));
bool result = false;
if(m_Reply != NULL)
{
if (1 == m_Reply->integer)
{
result = true;
}
freeReply();
}
return result;
}
bool CRedisClass::SMembers(const string & key, vector & ret)
{
m_Reply = reinterpret_cast(redisCommand(m_Redis, "SMEMBERS %s", key.c_str()));
if(m_Reply != NULL)
{
for (int i = 0; i < m_Reply->elements; i++)
{
redisReply *r = m_Reply->element;
ret.push_back(r->str);
}
freeReply();
return true;
}
return false;
}
bool CRedisClass::LPush(const string & key, const string & menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "LPUSH %s %s", key.c_str(), menber.c_str()));
bool result = false;
if(m_Reply != NULL)
{
if (0 < m_Reply->integer)
{
result = true;
}
freeReply();
}
return result;
}
bool CRedisClass::RPush(const string & key, const string & menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "RPUSH %s %s", key.c_str(), menber.c_str()));
bool result = false;
if(m_Reply != NULL)
{
if (0 < m_Reply->integer)
{
result = true;
}
freeReply();
}
return result;
}
bool CRedisClass::LPop(const string & key, string & value)
{
value = "";
m_Reply = static_cast(redisCommand(m_Redis, "LPOP %s", key.c_str()));
if(m_Reply != NULL && NULL != m_Reply->str)
{
value = m_Reply->str;
}
freeReply();
if (value.empty())
{
return false;
}
return true;
}
bool CRedisClass::RPop(const string & key, string & value)
{
value = "";
m_Reply = static_cast(redisCommand(m_Redis, "RPOP %s", key.c_str()));
if(m_Reply != NULL && NULL != m_Reply->str)
{
value = m_Reply->str;
}
freeReply();
if (value.empty())
{
return false;
}
return true;
}
bool CRedisClass::RRange(const string & key, vector & ret)
{
string value;
while (RPop(key, value))
{
ret.push_back(value);
}
return true;
}
bool CRedisClass::LRem(const string & key, const string & menber)
{
m_Reply = static_cast(redisCommand(m_Redis, "LREM %s %s", key.c_str(), menber.c_str()));
bool result = false;
if(m_Reply != NULL)
{
if (1 == m_Reply->integer)
{
result = true;
}
freeReply();
}
return result;
}
int CRedisClass::LLen(const string & key)
{
int ret = 0;
m_Reply = static_cast(redisCommand(m_Redis, "LLEN %s", key.c_str()));
bool result = false;
if(m_Reply != NULL)
{
ret = m_Reply->integer;
freeReply();
}
return ret;
}