Linux下Redis C++操作的封装

sofh7777

　　安装和启动Redis服务...略！很粗糙的版本，待改进...
　　Redis Client C++示例代码...略！



/**
* Time: 14-3-10
* File: RedisCache.h
* Author: wbhuang
* Description: none
*/
#ifndef __REDIS_CACHE_H__
#define __REDIS_CACHE_H__
#include
#include
#include "redisclient.h"
using namespace std;
using namespace boost;
class RedisMediator {
public:
static const int DEFAULT_EXPIRE_TIME = 0;
virtual string getKey() = 0;
virtual string getValue() = 0;
int getTime() { return 0; }
bool getIsSetDefaultValue() { return false; }
string getDefaultValue() { return "none"; }
};
class RedisCache {
private:
string host, port;
bool clusterMode;
shared_ptr client;
public:
RedisCache();
virtual ~RedisCache();
RedisCache(string host, string port);
string set(string key, string value);
string get(string key);
string del(string key);
string getAndSet(RedisMediator *redisMediator);
bool   exists(string key);
vector mGet(vector *keys);
vector mSet(vector *keys, vector *values);
vector mGetAndSet(vector *redisMediators);
string hashSet(string key, string field, string value);
string hashGet(string key, string field);
string hashDel(string key, string field);
string hashGetAndSet(string key, RedisMediator *redisMediator);
bool hashExists(string key, string field);
int hashLen(string key);
string sAdd(string key, string value);
string sPop(string key);
string sDel(string key);
string rPush(string key, string value);
string lPush(string key, string value);
int lLen(string key);
string lIndex(string key, int index);
string lSet(string key, int index, string value);
string lPop(string key);
string rPop(string key);
void flushAll();
void flushDb();
protected:
};
#endif /*__REDIS_CACHE_H__*/

　　



/**
* Time: 14-3-1
* File: RedisCache.cpp
* Author: wbhuang
* Description: none
*/
#include "RedisCache.h"
#define VALUE_NULL "**nonexistent-key**"
RedisCache::RedisCache()
{
char *charHost= getenv("REDIS_HOST");
if(charHost) {
host = string(charHost);
} else {
host = string("localhost");
}
client = shared_ptr( new redis::client(host) );
}
RedisCache::RedisCache(string host, string port):host(host), port(port)
{
client = shared_ptr( new redis::client(this->host) );
}
RedisCache::~RedisCache()
{
}
string RedisCache::set(string key, string value)
{
if (key.empty())
return "";
client->set(key, value);
return value;
}
string RedisCache::get(string key)
{
string value;
if (key.empty())
return "";
if (exists(key))
value = client->get(key);
return value;
}
string RedisCache::del(string key)
{
string value;
value = get(key);
client->del(key);
return value;
}
string RedisCache::getAndSet(RedisMediator *redisMediator)
{
if (NULL == redisMediator)
return "";
string key, value;
key = redisMediator->getKey();
value = get(key);
if (value.empty())
{
value = redisMediator->getValue();
set(key, value);
int time = redisMediator->getTime();
if (0 != time)
client->expire(key, time);
}
return value;
}
bool RedisCache::exists(string key)
{
return client->exists(key);
}
vector RedisCache::mGet(vector *keys)
{
redis::client::string_vector vals;
client->mget(*keys, vals);
return vals;
}
vector RedisCache::mSet(vector *keys, vector *values)
{
for (int i = 0; i < keys->size(); i++)
{
client->set((*keys), (*values));
}
return *values;
}
vector RedisCache::mGetAndSet(vector *redisMediators)
{
string key, value;
vector values;
for (int i = 0; i < redisMediators->size(); i++)
{
key = (*redisMediators)->getKey();
value = get(key);
if (value.empty())
{
value = (*redisMediators)->getKey();
set(key, value);
}
values.push_back(value);
}
return values;
}
string RedisCache::hashSet(string key, string field, string value)
{
if(key.empty() || field.empty())
return "";
client->hset(key, field, value);
return value;
}
string RedisCache::hashGet(string key, string field)
{
if (key.empty() || field.empty())
return "";
string value;
if (hashExists(key, field))
value = client->hget(key, field);
return value;
}
string RedisCache::hashDel(string key, string field)
{
string value;
value = hashGet(key, field);
client->hdel(key, field);
return value;
}
string RedisCache::hashGetAndSet(string key, RedisMediator *redisMediator)
{
if (key.empty() || NULL == redisMediator)
return "";
string field, value;
field = redisMediator->getKey();
value = hashGet(key, field);
if (value.empty())
{
value = redisMediator->getValue();
hashSet(key, field, value);
}
return value;
}
bool RedisCache::hashExists(string key, string field)
{
return client->hexists(key, field);
}
int RedisCache::hashLen(string key)
{
return client->hlen(key);
}
string RedisCache::sAdd(string key, string value)
{
if (key.empty() || value.empty())
return "";
client->sadd(key, value);
return value;
}
string RedisCache::sPop(string key)
{
string value;
value = client->spop(key);
if (VALUE_NULL == value)
value = "";
return value;
}
string RedisCache::sDel(string key)
{
if (key.empty())
return "";
return sPop(key);
}
string RedisCache::rPush(string key, string value)
{
if (key.empty())
return "";
client->rpush(key, value);
return value;
}
string RedisCache::lPush(string key, string value)
{
if (key.empty())
return "";
client->lpush(key, value);
return value;
}
int RedisCache::lLen(string key)
{
if (key.empty())
return 0;
return client->llen(key);
}
string RedisCache::lIndex(string key, int index)
{
if (key.empty() || index < 0 || index >= lLen(key))
return "";
string value = client->lindex(key, index);
if (VALUE_NULL == value)
value ="";
return value;
}
string RedisCache::lSet(string key, int index, string value)
{
if (key.empty() || index < 0 || index >= lLen(key))
return "";
client->lset(key, index, value);
return value;
}
string RedisCache::lPop(string key)
{
if (key.empty())
return "";
string value = client->lpop(key);
if (VALUE_NULL == value)
value = "";
return value;
}
string RedisCache::rPop(string key)
{
if (key.empty())
return "";
string value = client->rpop(key);
if (VALUE_NULL == value)
value = "";
return value;
}
void RedisCache::flushAll()
{
client->flushall();
}
void RedisCache::flushDb()
{
client->flushdb();
}

　　



#include "RedisCache.h"
#include  
int main()
{
RedisCache* cache = new RedisCache();
cache->set("foo", "wbhuang");
string value = cache->get("foo");
cout