Redis C语言操作封装

#ifndef BOYAA_FOURLANDLORD_REDISCLASS_H_20130217
#define BOYAA_FOURLANDLORD_REDISCLASS_H_20130217

#include "hiredis.h"
#include <string>
#include <vector>
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<string> & 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<string> & 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<string> & 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 <string>
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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<string> & ret)
{
	m_Reply = reinterpret_cast<redisReply*>(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[i];
			ret.push_back(r->str);
		}
		freeReply();
		return true;
	}
	return false;
}

int CRedisClass::ZSize(const string& key)
{
	m_Reply = static_cast<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<string> & ret)
{
	m_Reply = reinterpret_cast<redisReply*>(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[i];
			ret.push_back(r->str);
		}
		freeReply();
		return true;
	}
	return false;
}

bool CRedisClass::LPush(const string & key, const string & menber)
{
	m_Reply = static_cast<redisReply*>(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<redisReply*>(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<redisReply*>(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<redisReply*>(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<string> & 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<redisReply*>(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<redisReply*>(redisCommand(m_Redis, "LLEN %s", key.c_str()));

	bool result = false;
	if(m_Reply != NULL)
	{
		ret = m_Reply->integer;
		freeReply();
	}
	return ret;
}