redis C++ API

最新推荐文章于 2024-05-13 00:10:32 发布
最新推荐文章于 2024-05-13 00:10:32 发布
阅读量5.3k 收藏 7
点赞数 5
分类专栏： c/c++ 文章标签： c++ redis hiredis 二进制 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frodo_sens/article/details/25298303
版权

= =琢磨了一下 hiredis 感觉很赞。

用C++封装了一下。

/**
 *	缓存工具
 *	Created on : 2014-05-08
 *		Author : frodo
 */

#ifndef FSCACHEDB_H_
#define FSCACHEDB_H_


#include <stdio.h> /* for size_t */
#include <stdarg.h> /* for va_list */


class FSCacheData{
public:
	virtual bool isNil(int index=0) = 0;
	virtual int getInt(int index=0) = 0;
	virtual float getFloat(int index=0) = 0;
	virtual const char* getString(int index=0) = 0;
	virtual bool getBool(int index=0) = 0;
	virtual char* getBinary(int index=0) = 0;
	virtual size_t getLength(int index=0) = 0;
	virtual size_t getArrayLength() = 0;
	virtual bool isArray() = 0;

};

class FSCacheConfig{

};

class FSCacheDB{
public:
	FSCacheDB();
public:

	/**
	 * 设置一个字符串到key
	 * @key		:  key
	 * @value	:  value
	 * @return ： 是否成功
	 */
	virtual bool setString(const char* key, const char* value, unsigned int expire=0) = 0;

	/**
	 * 设置一个二进制数据到key
	 * @key		:  key
	 * @value	:  value
	 * @return ： 是否成功
	 */
	virtual bool setBinary(const char* key, unsigned char* data, size_t len) = 0;

	/**
	 * 设置一个字符串到hash
	 * @hash_name : hahs名字
	 * @key		  : hash_key
	 * @value	  : value
	 * @return ： 是否成功
	 */
	virtual bool setHashString(const char* hash_name, const char* key, const char* value) = 0;

	/**
	 * 设置一个二进制数据到hash
	 * @hash_name : hash名字
	 * @key		  : hash_key
	 * @value	  : value
	 * @len		  : len
	 * @return ： 是否成功
	 */
	virtual bool setHashBinary(const char* hash_name, const char* key, unsigned char* data, size_t len) = 0;


	/**
	 * 添加一个字符串到列表尾
	 * @list_name : 列表名字
	 * @value	  : 数据
	 * @return    : 返回数组长度
	 */
	virtual int  pushStringToList(const char* list_name, const char* value) = 0;


	/**
	 * 插入一个二进制数据到列表
	 * @list_name : 列表名字
	 * @value	  : 数据
	 * @return    : 返回数组长度
	 */
	virtual bool  setBinaryToList(const char* list_name, int index, char* data, size_t len) = 0;


	/**
	 * 插入一个字符串到列表
	 * @list_name : 列表名字
	 * @value	  : 数据
	 * @return    : 返回数组长度
	 */
	virtual bool  setStringToList(const char* list_name, int index, const char* value) = 0;


	/**
	 * 添加一个二进制数据到列表尾
	 * @list_name : 列表名字
	 * @value	  : 数据
	 * @return    : 返回数组长度
	 */
	virtual int  pushBinaryToList(const char* list_name, char* binary, size_t len) = 0;

	/**
	 * 添加一个数据到有序集合中
	 * @set_name : 集合名字
	 * @score	 : 排序值
	 * @value	 : 该排序对应的数据
	 */
	virtual void addSortedSet(const char* set_name, int score, const char* value)=0;

	/**
	 * 根据对应的数据得到一个排名
	 * @set_name : 集合名字
	 * @value	 : 获取该数据的排名
	 * @return ： 返回排名
	 */
	virtual int  getSortByString(const char* set_name, const char* value)=0;

public:
	/**
	 * 根据key得到一个value
	 * @key 	: key_name
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool getDataFromKey(const char* key, FSCacheData* outdata) = 0;
	/**
	 * 获取hash内的value
	 * @hash_name : hash_name
	 * @key		  : key
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool getDataFromHash(const char* hash_name, const char* key, FSCacheData* outdata) = 0;

	/**
	 * 从有序集合中得到数据
	 * @set_name : set_name
	 * @starr	  : start
	 * @end		  : end
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool  getDataFromSoctedSet(const char* set_name, size_t start, size_t end, FSCacheData* outdata) = 0;
	/**
	 * 从列表中获取数据
	 * @list_name : list_name
	 * @starr	  : start
	 * @end		  : end
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool getDataFromList(const char* list_name, size_t start, size_t end, FSCacheData* outdata) = 0;

	/**
	 * 从列表长度
	 * @list_name : list_name
	 * @return ： 长度
	 */
	virtual int getListLen(const char* list_name) = 0;

	/**
	 * 弹出list的头部并且返回
	 * @list_name : list_name
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool shiftDataFromList(const char* list_name, FSCacheData* outdata) = 0;

	/**
	 * 移除list的尾部并且返回
	 * @list_name : list_name
	 * @outdata : 输出数据
	 * @return ： 是否成功
	 */
	virtual bool popDataFromList(const char* list_name, FSCacheData* outdata) = 0;

public:
	/**
	 * 获取一个自增的值
	 * @key	： 自增key
	 * @return ： 返回自增后的数值
	 */
	virtual int incrKey(const char* key) = 0;


	/**
	 * 删除一个key
	 * @key		:  key
	 * @value	:  value
	 * @return ： 是否成功
	 */
	virtual bool delKey(const char* key) = 0;

public:
	/**
	 * 选择DB
	 * @index		:  index	0~16
	 */
	virtual bool selectDB(int index) = 0;
	/**
	 * 获取当前使用中的DB
	 * @return	： 返回使用中的DB
	 */
	virtual int getDBNumber() = 0;

public:
	/**
	 * 初始化链接
	 */
	virtual bool connect(FSCacheConfig* conf)=0;

	/**
	 * 关闭链接
	 */
	virtual bool close()=0;

	static FSCacheDB* sharedCacheDB();
};

#endif /* FSCACHEDB_H_ */




#include "FSCacheDB.h"

static FSCacheDB* s_sharedCache = NULL;
FSCacheDB::FSCacheDB(){
	s_sharedCache = this;
}




FSCacheDB* FSCacheDB::sharedCacheDB(){
	return s_sharedCache;
}


/*
 * FSRedis.h
 *
 *  Created on: 2014-5-8
 *      Author: frodo
 */

#ifndef FSREDIS_H_
#define FSREDIS_H_

#include "FSCacheDB.h"
#include <hiredis/hiredis.h>


class FSRedis;
class FSRedisData : public FSCacheData
{

private:
	redisReply* m_pReply;
	friend class FSRedis;

	void initReply(redisReply*);

private:
	bool checkType(int index);
public:

	FSRedisData();
	~FSRedisData();

private:
	redisReply* getReply(int index=0);

public:

	virtual bool isNil(int index=0) ;
	virtual int getInt(int index=0) ;
	virtual float getFloat(int index=0) ;
	virtual const char* getString(int index=0) ;
	virtual bool getBool(int index=0) ;
	virtual char* getBinary(int index=0) ;
	virtual size_t getLength(int index=0);
	virtual bool isArray();
	virtual size_t getArrayLength();
};

class FSRedisConfig : public FSCacheConfig{

public:
	const char* host;
	int port;
	int db_index;
    struct timeval timeout;
};

class FSRedis : public FSCacheDB{
public:
	FSRedis();
	virtual ~FSRedis();

private:
	int m_iSelectedDB;
	redisContext* m_pContext;

public:
	virtual bool setString(const char* key, const char* value, unsigned int expire=0) ;
	virtual bool setBinary(const char* key, unsigned char* data, size_t len) ;
	virtual bool setHashString(const char* hash_name, const char* key, const char* value) ;
	virtual bool setHashBinary(const char* hash_name, const char* key, unsigned char* data, size_t len) ;
	virtual int  pushStringToList(const char* list_name, const char* value);
	virtual int  pushBinaryToList(const char* list_name, char* binary, size_t len);
	virtual bool setBinaryToList(const char* list_name, int index, char* data, size_t len) ;
	virtual bool setStringToList(const char* list_name, int index, const char* value) ;
	virtual void addSortedSet(const char* set_name, int score, const char* value);
	virtual int  getSortByString(const char* set_name, const char* value);
public:
	virtual int  getListLen(const char* list_name) ;
	virtual bool getDataFromList(const char* list_name, size_t start, size_t end, FSCacheData* outdata);
	virtual bool getDataFromSoctedSet(const char* set_name, size_t start, size_t end, FSCacheData* outdata);
	virtual bool getDataFromKey(const char* key, FSCacheData* outdata) ;
	virtual bool getDataFromHash(const char* hash_name, const char* key, FSCacheData* outdata) ;
	virtual bool shiftDataFromList(const char* list_name, FSCacheData* outdata) ;
	virtual bool popDataFromList(const char* list_name, FSCacheData* outdata) ;
public:
	virtual int incrKey(const char* key) ;
	virtual bool delKey(const char* key) ;
public:
	virtual bool selectDB(int index);
	virtual int getDBNumber();
public:
	bool connect(FSCacheConfig* conf);
	bool close();
public:	// redis
	bool checkReplay(redisReply*);
	bool executeCommand(const char* command, ...);
	bool executeCommand(const char* command, va_list ap);
};

#endif /* FSREDIS_H_ */



/*
 * FSRedis.cpp
 *
 *  Created on: 2014-5-8
 *      Author: frodo
 */

#include "FSRedis.h"

#include <stdlib.h>
#include <string.h>

#define _CHECK_CONNECT if(!m_pContext) return false;

FSRedisData::FSRedisData():m_pReply(NULL){
}

FSRedisData::~FSRedisData(){
	if(m_pReply){
		freeReplyObject(m_pReply);
	}
}

redisReply* FSRedisData::getReply(int index){
	if(m_pReply->type == REDIS_REPLY_ARRAY){
		return m_pReply->element[index];
	}else{
		return m_pReply;
	}
}
void FSRedisData::initReply(redisReply* reply){
	if(m_pReply){
		freeReplyObject(m_pReply);
		m_pReply = NULL;
	}
	m_pReply = reply;
}
bool FSRedisData::checkType(int index){
	return !isNil(index) &&
			(getReply(index)->type == REDIS_REPLY_STRING ||
					getReply(index)->type == REDIS_REPLY_INTEGER ||
					getReply(index)->type == REDIS_REPLY_STATUS);
}
bool FSRedisData::isArray(){
	return m_pReply->type == REDIS_REPLY_ARRAY;
}
bool FSRedisData::isNil(int index){
	return !m_pReply || m_pReply->type == REDIS_REPLY_NIL || m_pReply->type == REDIS_REPLY_ERROR;
}
int  FSRedisData::getInt(int index) {
	if(!checkType(index)){
		return 0;
	}
	return atoi(getString());
}
float  FSRedisData::getFloat(int index) {
	if(!checkType(index)){
		return 0;
	}
	return atof(getString());
}
const char*  FSRedisData::getString(int index) {
	if(!checkType(index)){
		return 0;
	}
	return getReply(index)->str;
}
bool  FSRedisData::getBool(int index) {
	if(!checkType(index)){
		return 0;
	}
	return strcasecmp("true", getReply(index)->str) == 0;
}
char*  FSRedisData::getBinary(int index) {
	return getReply(index)->str;
}
size_t  FSRedisData::getLength(int index){
	return getReply(index)->len;
}

size_t FSRedisData::getArrayLength(){
	if(m_pReply){
		return m_pReply->elements;
	}
	return 1;
}


FSRedis::FSRedis() {


}

FSRedis::~FSRedis() {
	this->close();
}

bool FSRedis::connect(FSCacheConfig* conf){

	FSRedisConfig* config = (FSRedisConfig*)conf;

	m_pContext = redisConnectWithTimeout(config->host, config->port, config->timeout);

	if(!m_pContext || m_pContext->err){
		printf("init redis is erro code[%d], msg[%s]\n", m_pContext->err, m_pContext->errstr);
		goto fail;
	}

	if(!selectDB(config->db_index)){
		goto fail;
	}

	goto success;

success:
	return true;
fail:
	return false;

}


bool FSRedis::close(){
	if(m_pContext){
		redisFree(this->m_pContext);
		m_pContext = NULL;
		return true;
	}
	return false;
}


bool FSRedis::selectDB(int index){
	if( executeCommand("SELECT %d", index) ){
		m_iSelectedDB = index;
		return true;
	}
	return false;
}
int FSRedis::getDBNumber(){
	return m_iSelectedDB;
}

bool FSRedis::checkReplay(redisReply* replay){
	return replay != NULL;
}
bool FSRedis::executeCommand(const char* command, ...){
	va_list ap;
	va_start(ap,command);
	bool ret = executeCommand(command, ap);
    va_end(ap);
	return ret;
}

bool FSRedis::executeCommand(const char* command, va_list ap){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, command, ap);
	if(!checkReplay(reply)){
		return false;
	}
	freeReplyObject(reply);
	return true;
}


bool FSRedis::setString(const char* key, const char* value, unsigned int expire){
	_CHECK_CONNECT
	redisReply* reply = NULL;
	if(expire != 0){
		reply = (redisReply*)redisCommand(m_pContext, "SETEX %s %d %s", key, expire, value);
	}else{
		reply = (redisReply*)redisCommand(m_pContext, "SET %s %s", key, value);
	}
	if(!checkReplay(reply)){
		return false;
	}
	freeReplyObject(reply);
	return true;
}
bool FSRedis::setBinary(const char* key, unsigned char* data, size_t len){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "SET %s %b", key, data, len);
	if(!checkReplay(reply)){
		return false;
	}
	freeReplyObject(reply);
	return true;
}
bool FSRedis::setHashString(const char* hash_name, const char* key, const char* value){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "HSET %s %s %s", hash_name, key, value);
	if(!checkReplay(reply)){
		return false;
	}
	freeReplyObject(reply);
	return true;
}
bool FSRedis::setHashBinary(const char* hash_name, const char* key, unsigned char* data, size_t len){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "HSET %s %s %b", hash_name, key, data, len);
	if(!checkReplay(reply)){
		return false;
	}
	freeReplyObject(reply);
	return true;
}

bool  FSRedis::setBinaryToList(const char* list_name, int index, char* data, size_t len) {
	_CHECK_CONNECT
	redisReply* reply = (redisReply*) redisCommand(m_pContext, "LSET %s %d %b", list_name, index, data, len);
	if (!checkReplay(reply)) {
		return false;
	}
	freeReplyObject(reply);
	return true;
}
bool  FSRedis::setStringToList(const char* list_name, int index, const char* value) {
	_CHECK_CONNECT
	redisReply* reply = (redisReply*) redisCommand(m_pContext, "LSET %s %d %s", list_name, index, value);
	if(!checkReplay(reply)){ return false; }
	freeReplyObject(reply);
	return true;
}
int  FSRedis::pushStringToList(const char* list_name, const char* value){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "RPUSH %s %s", list_name, value);
	if(!checkReplay(reply)){
		return -1;
	}
	int len = reply->integer;
	freeReplyObject(reply);
	return len;
}

int  FSRedis::pushBinaryToList(const char* list_name, char* binary, size_t len){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "RPUSH %s %b", list_name, binary, len);
	if(!checkReplay(reply)){
		return -1;
	}
	int ret = reply->integer;
	freeReplyObject(reply);
	return ret;
}
void FSRedis::addSortedSet(const char* set_name, int score, const char* value){
	if(!m_pContext) return;
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "ZADD %s %d %s", set_name, score, value);
	freeReplyObject(reply);
}
int  FSRedis::getSortByString(const char* set_name, const char* value){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "ZRANK %s %s", set_name,  value);
	if(!checkReplay(reply)){
		return -1;
	}
	int ret = reply->integer;
	freeReplyObject(reply);
	return ret;
}
bool FSRedis::getDataFromKey(const char* key, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "GET %s", key);
	if(!checkReplay(reply)){ return false; }
	((FSRedisData*)outdata)->initReply(reply);
	return true;
}
bool FSRedis::getDataFromHash(const char* hash_name, const char* key, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "HGET %s %s", hash_name, key);
	if(!checkReplay(reply)){ return false; }
	((FSRedisData*)outdata)->initReply(reply);
	return true;
}

int  FSRedis::getListLen(const char* list_name) {
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "LLEN %s", list_name);
	if(!checkReplay(reply)){ return 0; }
	int ret = reply->integer;
	freeReplyObject(reply);
	return ret;
}
bool FSRedis::getDataFromList(const char* list_name, size_t start, size_t end, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "LRANGE %s %d %d", list_name, start, end);
	if(!checkReplay(reply)){ return false; }
	((FSRedisData*)outdata)->initReply(reply);
	return true;
}
bool  FSRedis::getDataFromSoctedSet(const char* set_name, size_t start, size_t end, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*) redisCommand(m_pContext, "ZRANGE %s %d %d", set_name, start, end);
	if (!checkReplay(reply)) {
		return false;
	}
	((FSRedisData*) outdata)->initReply(reply);
	return true;
}
bool FSRedis::shiftDataFromList(const char* list_name, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "LPOP %s %s", list_name);
	if(!checkReplay(reply)){ return false; }
	((FSRedisData*)outdata)->initReply(reply);
	return true;
}
bool FSRedis::popDataFromList(const char* list_name, FSCacheData* outdata){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "RPOP %s %s", list_name);
	if(!checkReplay(reply)){ return false; }
	((FSRedisData*)outdata)->initReply(reply);
	return true;
}
int FSRedis::incrKey(const char* key){
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "INCR %s", key);
	if(!checkReplay(reply)) return false;
	int ret = reply->integer;
	freeReplyObject(reply);
	return ret;
}

bool FSRedis::delKey(const char* key) {
	_CHECK_CONNECT
	redisReply* reply = (redisReply*)redisCommand(m_pContext, "DEL %s", key);
	if(!checkReplay(reply)) return false;
	int ret = reply->integer;
	freeReplyObject(reply);
	return ret > 0;
}



test


#include <iostream>
#include <memory.h>
#include <string.h>
#include "FSOutputStream.h"
#include "FSInputStream.h"
#include <hiredis/hiredis.h>
#include "FSRedis.h"

using namespace std;

void test(){



	FSRedisData data;
	FSRedisConfig conf;
	conf.db_index = 0;
	conf.host = "127.0.0.1";
	conf.port = 6379;
	conf.timeout.tv_sec = 3;
	conf.timeout.tv_usec = 0;

	FSRedis db;
	db.connect(&conf);

	db.setString("MYNAME", "FRODO");
	db.setString("MYLOVE", "QIAO");

	db.getDataFromKey("MYNAME", &data);
	printf("%s\n", data.getString());
	db.getDataFromKey("MYLOVE", &data);
	printf("%s\n", data.getString());

	FSOutputStream fos;
	for(int i = 0 ; i < 50 ; i++){
		fos.writeInt32(i);
	}
	db.setBinary("IDS", fos.getData(), fos.getLength());
	db.getDataFromKey("IDS", &data);
	FSInputStream fis(data.getBinary(), data.getLength());

	for(int i = 0 ; i< 50 ; i++){
		printf("%d \n", fis.readUInt32());
	}

	if(db.getDataFromKey("MYLOVE", &data)){
		printf("%s\n", data.getString());
	}else{
		printf("get data fail\n");
	}


}

int main() {
	test();



	return 0;
}



会魔法的猫
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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操作函数
热门推荐
彼方的博客
04-24 1万+
C++简单封装Redis操作函数
2024年C C++最全Redis学习笔记(四) Redis哨兵(sentinel)_-sdown sentinel，2024年最新C C++开发需要什么基础
2401_84976751的博客
05-13 859
可以看出slave重新加入到了主从复制中-sdown: 说明是恢复服务现在将Master 强制杀掉哨兵控制台打印我们进入 6381 查看状态6381 已经是 master了 并且拥有一个 6380的slave重新启动63796379已经恢复,并且将6379设置为6380的slave这时我们查看sentinel.conf 发现 我们刚刚配置的端口已经变成6381而6381也有2个slave。
Redis知识点总结
shipeng101的博客
04-29 1004
做一个redis知识点的回忆和总结，大部分基于javaguide，比较简略，详细可见https://javaguide.cn/database/redis/redis-questions-01.html 什么是redis redis是一个数据库，与传统数据库不同的是，redis的数据是存在内存中的。所以读写速度非常快，经常被拿来做缓存使用。除此之外也会拿来做分布式锁和消息队列使用。 redis提供了多种数据类型来支持不同业务场景下的使用，还具有事务、持久化、Lua脚本和集群等特性。 为什么要用redis/缓
【Go】格式化字符串指令大全 && Redis常用命令
Welcome To As.Kai 's Home
10-27 617
【Go】格式化字符串指令大全 && Redis常用命令原创：@As.Kai。
redis简介（一）
不才的专栏
05-08 279
0. redis是什么 redis是一个高性能的缓存数据库，支持不限于key-value结构的数据缓存和持久化。直白的讲，可用于进程间通信或者说共享资源，比unix socket、共享内存、消息队列等更方便便捷，而且支持跨语言，凭借着简单实用性能高，被非常广泛应用。 Hiredis是Redis数据库的一个简单的C客户端库。它的接口只有简单的几个，但足够大多数场景使用。 1. 安装 1.1 运行环境和 C语言客户端库 这里直接用yum源安装了，这是最简单的方式、 yum instal..
redis使用c++ API 的hiredis连接详解
10-18
此代码实现了redis使用hiredis c接口开发，具体实现了string和list类型的存取，具体信息请看 https://blog.csdn.net/bwangk/article/details/83060374
c++ 操作redis数据库
02-10
2. C++库选择：熟悉cpp-redis、hiredis等C++ Redis客户端库，了解其API用法。 3. 网络编程：理解TCP/IP协议基础，能够建立和管理网络连接。 4. 数据序列化：了解如何将C++的数据结构转换为Redis能识别的命令格式，...
C++基于redis的分布式锁redisAPI
12-12
本文将深入探讨如何使用C++结合Redis实现分布式锁，并详细讲解Redis API在C++中的应用，以及如何处理与Boost库的集成。 首先，Redis是一个高性能的键值存储数据库，广泛用于缓存、消息队列、分布式锁等场景。分布式...
redis c++封装.zip
04-28
在C++中对Redis进行封装，可以方便地在C++程序中利用Redis的功能，提高开发效率。以下是一些关于“Redis C++封装”的核心知识点： 1. **Redis数据结构**：Redis支持多种数据结构，如字符串（String）、哈希表（Hash...
C++ Redis 客户端简单使用
最新发布
06-17
另一个是`cpp-redis`，这是一个完全用C++编写的客户端库，提供了更友好的API。我们以`cpp-redis`为例来讲解。 1. **安装cpp-redis**：首先，你需要从GitHub（https://github.com/cpp-redis/cpp-redis）下载源代码，...
C++ Redis mset二进制数据接口封装方案
12-22
C++ Redis mset 二进制数据接口封装方案 　　需求 　　C++中使用hiredis客户端接口访问redis； 　　需要使用mset一次设置多个二进制数据 　　以下给出三种封装实现方案； 　　简单拼接方案 　　在redis-cli中，mset的语法是这样的： 　　/opt/colin$./redis-cli mset a 11 b 22 c 333 　　OK 　　按照这样的语法拼接后，直接使用hiredis字符串接口redisCommand传递： void msetNotBinary(redisContext *c， const vector<string> &v
C++封装Redis访问类
04-26
C++封装Redis访问类，封装set和get操作
HiRedis Redis 数据库 C++ 操作，支持 Windows
04-03
网际风 http://www.nezip.net 崇尚简洁实用。示例将Hiredis的操作封装为两个导出函数 Set 与 Get， 支持 Unicode 编码方式，支持二进制读写，有断线重连功能，可以使用静态库或动态库。 唯一实时Hiredis.dll 动态库方式。示例在 Win 10 VS2015 环境下编译通过。
Redis开源库ACL_CPP封装
muyunxm12的博客
08-24 231
本文基于ACL_CPP，提供对Redis操作的封装。ACL_CPP是一个C++库，用于与Redis进行交互。它提供了一组类和函数，用于执行各种Redis命令和操作。该库基于BSD许可证，具有良好的跨平台支持，可用于多种操作系统和编译器。
hiredis包装redis数据库操作接口及测试（增删改查与连接）
poetteaes的博客
06-10 3706
前两篇文章（redis安装配置与测试、redis的数据类型）总计了redis的一些基本知识，这里要进行一下redis的实践，先介绍一个实际应用场景，对于客户频繁需要查询的信息，可以将其放在redis内存数据库中，相当于一个缓存，每次查的时候先去redis内存数据库中去查询，如果查询不到再去oracle数据库中查询，这样提高了效率。 本文，使用redis的C与语操作接口hiredis包装了redi...
Redis连接池C/C++设计
locahuang的博客
12-04 2116
一、概述 Redis的C/C++编程，可以借助Hiredis。我们可以借助Hiredis提供的接口 ，实现对redis的读写操作。 Hiredis是一个Redis的C客户端库函数，基本实现了Redis的协议的最小集。 二、hiredis的使用 1、hiredis安装 安装步骤： 1）解压：tar -zxvf hiredis-0.14.0.tar.gz 2）编译：make 3）安装：make install 2、同步API接口的说明 项目中我一般使用的hireds接口都是同步的API，所谓同步意思就是使用
redis的redisvCommand的%b
zhangge3663的博客
04-20 787
如下代码，向redis发送命令 SendCommand("HSET %b %b %b", key.data(), key.size(), field.data(), field.size(), value.data(), value.size()); 实际调用的即如下接口redisvCommand,上面第一个参数即对应着为const char *format redisReply *raw_...
Redis中五种基础数据结构及其底层实现
qq_45537574的博客
04-06 3226
redis
redis c++
11-07
Redis C++是Redis的C++客户端，它提供了一组易于使用的API，可以方便地与Redis服务器进行通信。Redis C++支持连接池、异步操作、管道等特性，可以提高Redis客户端的性能和可靠性。在引用中的代码演示了如何使用Redis...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值