Linux-CentsOS8.1 Redis C++类 封装（前半部分内容为转载，后半段为原创）

Redis安装步骤：

1.redis server安装

wget http://redis.googlecode.com/files/redis-2.4.6.tar.gz #下载文件
tar xzf redis-2.4.6.tar.gz
cd redis-2.4.6
make
cp src/redis-server src/redis-cli /usr/bin/ #方便在终端在任何地方直接运行
cp redis.conf /etc/
ufw allow 6379 #ubuntu下开启端口


修改/etc/redis.conf,让server以守护进程在后台执行。
daemonize yes


2.启动redis服务
redis-server /etc/redis.conf


3.检测redis服务是否正常启动

ps -ef | grep redis

 

Hiredis客户端下载地址：https://github.com/antirez/hiredis/zipball/master


Hiredis安装步骤：
tar zxvf antirez-hiredis-v0.10.1-0-g3cc6a7f.zip
cd antirez-hiredis-3cc6a7f
make


mkdir /usr/lib/hiredis
cp libhiredis.so /usr/lib/hiredis #将动态连接库libhiredis.so至/usr/lib/hiredis
mkdir /usr/include/hiredis
cp hiredis.h /usr/include/hiredis




1.连接hiredis服务器
#include <stdio.h>
#include <hiredis/hiredis.h>


redisContext *conn = redisConnect("127.0.0.1", 6379); //redis server默认端口
if(conn->err){
printf("connection error: %s", conn->str);
}


2.发送命令至服务器
redisReply *reply = redisCommand(conn, "set key value");


3.关闭Reply对象
freeReplyObject(reply);


4.关闭连接
redisFree(conn);


具体一些其他的API可以看文件的README.md

 

#######################################################################

 

Redis 的 C++开发包 使用例子

 

刚接触C++ 不久 ，就要用到这个redis ，在各种好人的帮助下终于摸索出了个样本，贴上来给像我这样的新手使用。

1.首先安装完毕redis

2.安装boost 库

3.开发包下载地址：

 redis-cplusplus-client（https://github.com/mrpi/redis-cplusplus-client）

4.上代码

/**
 * 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;
}

以上内容转载自：

https://blog.csdn.net/educast/article/details/37695917

https://blog.csdn.net/weixin_30530939/article/details/96833717

==============================================

==============================================

以下为本人测试过程中发现的问题及注意点：

1、我的环境：CentsOS 8.1，redis 5.0.7 x64     hiredis 0.14.0；

2、编译上面提到的RedisCache.cpp时，可能会报错，提示shared_ptr 的引用有歧义，需要在报错的代码行增加boost::，即：把shared_ptr<redis::client>修改为boost::share_ptr<redis::client>；

3、redisclient.h是基于boost的，需要进行安装，分别执行以下三个命令即可：

    yum install boost

   yum install boost-devel

    yum install boost-doc

4、上面的类默认连接的是6379端口，如果需要根据配置文件把参数传入，如下：

RedisCache::RedisCache(string host, int port)
{
    client = boost::shared_ptr<redis::client>( new redis::client(host) );
}

修改为：

RedisCache::RedisCache(string host, int port, int dbindex)//:host(host), port(port) 
{
    client = boost::shared_ptr<redis::client>( new redis::client(host, port, dbindex) );
}

5、如果有其它报错，请把cplusplus-redis-client/anet.c进行编译，g++ -c anet.c -o anet.o；

6、编译主程序时，需要加上如下内容：

g++ test1.o include/MyRedis.o include/redis-cplusplus-client-master/anet.o -o test1 -lhiredis  -lpthread -lboost_thread