安装和启动Redis服务...略!很粗糙的版本,待改进...
Redis Client C++示例代码...略!
/**
* Time: 14-3-10
* File: RedisCache.h
* Author: wbhuang
* Description: none
*/
#ifndef __REDIS_CACHE_H__
#define __REDIS_CACHE_H__
#include <string>
#include <boost/date_time.hpp>
#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<redis::client> 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<string> mGet(vector<string> *keys);
vector<string> mSet(vector<string> *keys, vector<string> *values);
vector<string> mGetAndSet(vector<RedisMediator*> *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<redis::client>( new redis::client(host) );
}
RedisCache::RedisCache(string host, string port):host(host), port(port)
{
client = shared_ptr<redis::client>( 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<string> RedisCache::mGet(vector<string> *keys)
{
redis::client::string_vector vals;
client->mget(*keys, vals);
return vals;
}
vector<string> RedisCache::mSet(vector<string> *keys, vector<string> *values)
{
for (int i = 0; i < keys->size(); i++)
{
client->set((*keys)[i], (*values)[i]);
}
return *values;
}
vector<string> RedisCache::mGetAndSet(vector<RedisMediator*> *redisMediators)
{
string key, value;
vector<string> values;
for (int i = 0; i < redisMediators->size(); i++)
{
key = (*redisMediators)[i]->getKey();
value = get(key);
if (value.empty())
{
value = (*redisMediators)[i]->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 <iostream>
int main()
{
RedisCache* cache = new RedisCache();
cache->set("foo", "wbhuang");
string value = cache->get("foo");
cout<<"after set foo:"<<value<<endl;
cache->del("foo");
value = cache->get("foo");
cout<<"after del foo:"<<cache->get("foo")<<endl;
vector<string> vecKey, vecValue;
vecKey.push_back("foo1");
vecValue.push_back("val1");
vecKey.push_back("foo2");
vecValue.push_back("val2");
cache->mSet(&vecKey, &vecValue);
cout<<"after mset foo2:"<<cache->get("foo2")<<endl;
vector<string> vecRet = cache->mGet(&vecKey);
cout<<"after mget foo1:"<<vecRet[0]<<endl;
string hKey = "hfoo";
string hField = "hfield";
cache->hashSet(hKey, hField, "wbhuang");
cout<<"after hset len:"<<cache->hashLen(hKey)<<endl;
string hValue = cache->hashGet(hKey, hField);
cache->hashDel(hKey, hField);
//cache->del(hKey);
cout<<"after hdel len:"<<cache->hashLen(hKey)
<<",value"<<cache->hashGet(hKey, hField)<<endl;
string sKey = "sKey";
string sValue = "sValue";
cache->sAdd(sKey, sValue);
cout<<"after sAdd value:"<<cache->sPop(sKey)<<endl;
cache->sDel(sKey);
cout<<"after sDel value:"<<cache->sPop(sKey)<<endl;
string rKey = "rfoo";
string rValue = "rValue", lValue = "lValue";
cache->rPush(rKey, rValue);
cout<<"test rPush end"<<endl;
cache->lPush(rKey, lValue);
cout<<"test lPush end"<<endl;
string rRet;
rRet = cache->lIndex(rKey, 1);
cout<<"test lIndex end rRet:"<<rRet<<endl;
int llen = cache->lLen(rKey);
cout<<"test lLen end len:"<<llen<<endl;
cout<<"test lIndex end 1:"<<rRet<<endl;
rRet = cache->lPop(rKey);
cout<<"after lPop ret:"<<rRet<<endl;
cache->lSet(rKey, 0, "wbh");
rRet = cache->rPop(rKey);
cout<<"after lset rPop ret:"<<rRet<<endl;
rRet = cache->rPop(rKey);
cout<<"empty stack len:"<<cache->lLen(rKey)<<",ret:"<<cache->rPop(rKey)<<endl;
cout<<"empty statck 0:"<<cache->lIndex(rKey, 0)<<endl;
cache->flushDb();
delete cache;
return 0;
}