Redis C语言操作封装

最新推荐文章于 2022-03-24 12:42:16 发布
最新推荐文章于 2022-03-24 12:42:16 发布
阅读量285 收藏
点赞数
文章标签： c/c++ 数据库
原文链接：http://www.cnblogs.com/binmaizhai/p/3749849.html
版权 
#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;
}

　　

转载于:https://www.cnblogs.com/binmaizhai/p/3749849.html

weixin_30341735
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言使用redis,C语言访问redis
weixin_33518565的博客
05-22 1293
redis采用源码或者二进制文件安装方式，启动服务，如下：ps aux | grep redisroot 4772 0.0 0.0 103184 856 pts/0 S+ 09:02 0:00 grep redisroot 20639 0.1 0.1 143908 7660 ? Ssl Aug08 37:57 /usr/local/r...
CRedis 详解
kobexzf的博客
11-21 3832
CRedis 详解 ClusterFactory 维护clusterName-RedisCluster ,定时刷新， RedisCluster 维护int-RedisGroup ，使用HashStrategy（一致性hash）来找到RedisGroup RedisGroup 维护多个master，slave RedisServer RedisServer封装了服务器配置IP，port， 使用Je...
c连接redis
sumengnan的博客
03-24 2421
1、需要使用hiredis库 下载地址：GitHub - redis/hiredis: Minimalistic C client for Redis >= 1.2 下载后需要执行cmake .和make命令编译，得到libhiredis.a和libhiredis.dylib 2、复制文件到项目或添加到主机/usr/local/include和lib目录下，再执行一个命令刷新一下头文件生效 需复制文件alloc.h、hiredis.h、read.h、sds.h及libhiredis.a
redis的优势和Redis与其他key-value存储有什么不同？
jianxzjxz的博客
04-11 1414
redis的优势性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI...
c/c++使用redis
MoriingRain的博客
04-15 3299
c/c++使用redishiredis1、安装hiredis2、接口介绍c程序操作Redis代码 hiredis hiredis是Redis官方推荐的基于C接口的客户端组件，它提供接口，供c语言调用以操作数据库。 1、安装hiredis 进入Redis的源码包的deps/hiredis make make install ldconfig #使动态库在系统中更新生效 2、接口介绍 #include <hiredis/hiredis.h> // 该函数用来连接redis数据库，参数为ip地址和端
redis操作封装示例
05-07
转自 https://git.oschina.net/jibaole.com/Redis/repository/archive/master
php操作redis封装的类
05-01
一个php操作redis封装的类，Redis 操作，支持 Master/Slave 的负载集群，服务器连接句柄，连接服务器,注意：这里使用长连接，提高效率，但不会自动关闭，得到 Redis 原始对象可以有更多的操作，条件形式设置缓存，...
Redis教程(十五)：C语言连接操作代码实例
09-10
主要介绍了Redis教程(十五)：C语言连接操作代码实例,本篇博客是该系列博客中的最后一篇,在这里将给出基于Redis客户端组件访问并操作Redis服务器的代码示例,需要的朋友可以参考下
java中redis锁的封装
05-04
内容：封装好的redis锁 使用场景： 1.并发情况下 2.对某个字段状态的处理 3.支付回调，重复收到回调数据 使用方法： Object result = redisLockTemplate.execute("REDIS:LOCK:" + id, 1, TimeUnit.SECONDS, new ...
Redis源码C语言
04-21
Redis 源码 路径 redis\src 下
redis实时数据库C语言操作程序示例
11-21
C语言编写的简单操作redis实时数据库的程序
redis发布订阅c接口_Redis发布订阅
weixin_28963585的博客
12-29 128
适用场景直播消息弹幕消息粉丝订阅消息推送知识点1、关键字：PUBLISH SUBSCRIBE PSUBSCRIBERedis采用PUBLISH命令发送消息，其返回值为接收到该消息的订阅者的数量。Redis采用SUBSCRIBE命令订阅某个频道，其返回值包括客户端订阅的频道，目前已订阅的频道数量，以及接收到的消息，其中subscribe表示已经成功订阅了某个频道。2、示例：redis 127.0.0...
c操作redis数据库
追求卓越
05-25 2827
原文地址: c语言操作redis数据库前言下面简单介绍使用c语言操作redis数据库.准备内容hiredis 这是redis官方推荐的基于C接口的客户端组件 在redis的源码包的deps/hiredis下就有源码,也可以另行下载hiredis 安装方法,进入deps/hiredis目录,执行命令make make install mkdir /usr/lib/hiredis \#下面两条影响运行...
Redis学习（九）---发布（publish）/ 订阅（subscribe）
赵成默
07-28 952
前言 redis它也有自己的消息发布和订阅功能，这是一个比较轻量级的功能，毕竟他不是专门做这个的。如果你只是需要一个基础的发布订阅功能个而且有redis，那么你就可以使用它，比较我们可以不需要再去配置RabbitMQ这些专门的消息中间件 命令 命令 描述 PSUBSCRIBE pattern [pattern …] 订阅一个或多个符合给定模式的频道 PUBSUB SUBcommand [argument [argument …]] 查看订阅与发布的系统状态 PUBLSH channe
hiredis包装redis数据库操作接口及测试（增删改查与连接）
poetteaes的博客
06-10 3675
前两篇文章（redis安装配置与测试、redis的数据类型）总计了redis的一些基本知识，这里要进行一下redis的实践，先介绍一个实际应用场景，对于客户频繁需要查询的信息，可以将其放在redis内存数据库中，相当于一个缓存，每次查的时候先去redis内存数据库中去查询，如果查询不到再去oracle数据库中查询，这样提高了效率。 本文，使用redis的C与语操作接口hiredis包装了redi...
web级mysql实战
04-01
本课程是基于web开发领域下的实战mysql课程。本课程会模拟一个项目需求，从一万数据到百万数据逐步讲解如何建立、优化和第三方库结合的过程。同时本课程的高潮在：1、mysql+memcached的结合实战2、mysql+redis的结合实战3、mysql+mycat(数据库中间件)在分库分表中的基本使用4、mysql+HaProxy的负载均衡配置5、实际案例中的一些表设计讲解。
c语言操作redis数据库
热门推荐
守望的博客-编程珠玑
10-07 1万+
原文地址: c语言操作redis数据库前言下面简单介绍使用c语言操作redis数据库.准备内容 hiredis 这是redis官方推荐的基于C接口的客户端组件 在redis的源码包的deps/hiredis下就有源码,也可以另行下载hiredis 安装方法,进入deps/hiredis目录,执行命令make make install mkdir /usr/lib/hiredis \#下面两条
Redis常用命令及C/C++调用Redis接口详解
qq_41854911的博客
12-02 1万+
文章目录一、Redis常用命令启动Redis服务端启动Redis客户端Redis常用命令详解键（Key）命令Hash 命令String 命令List 命令Set 命令Zset 命令二、C/C++调用接口连接和操作Redis数据库hiredis.h同步API连接redis数据库发送命令到redis处理redis应答清理连接资源发送多个命令参数访问Redis代码实例 一、Redis常用命令 一般Redis都是安装在linux上，分为server和client。 启动Redis服务端 在终端输入以下命令启动 Re
c语言链接检测代码大全,Redis教程(十五)：C语言连接操作代码实例
weixin_36328527的博客
05-18 139
在之前的博客中已经非常详细的介绍了Redis的各种操作命令、运行机制和服务器初始化参数配置。本篇博客是该系列博客中的最后一篇，在这里将给出基于Redis客户端组件访问并操作Redis服务器的代码示例。然而需要说明的是，由于Redis官方并未提供基于C接口的Windows平台客户端，因此下面的示例仅可运行于Linux/Unix平台。但是对于使用其它编程语言的开发者而言，如C#和Java，Redis则...
redis工具类封装
最新发布
10-16
好的，关于redis工具类封装，我可以给你提供一些思路和建议。 首先，你需要确定你的工具类需要实现哪些功能，比如连接redis、设置key-value、获取value等等。然后，你可以使用Jedis这个Java Redis客户端来实现这些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值