C++ 封装 hredis-win32 实现底层操作解耦,并实现自动重连

windows上操作redis貌似一直不是redis官方的主流想法，如果用C#操作的话，我推荐NServiceKit.Redis这个开源库来操作，但是如果你使用的是VC++操作redis，很抱歉并没有什么特别好用库可以非常方便的操作redis所有功能，经过精挑细选，我找到了

开源库hredis-win32：https://github.com/texnician/hiredis-win32

但是这个库也是有不少坑，尤其是编译过程中“”结构体成员对齐“”他默认选择的1字节对齐，所以你这样编译出来的lib文件对VC编译器大部分使用默认8字节对齐简直就是灾难。为了避免大家踩坑我这里放一个VS2013 MDd模式，默认结构对齐方式 编译 好的一个lib库给大家下载，免走编译坑。http://pan.baidu.com/s/1kVAxg0Z

剩下就废话不多说直接上我对这个库的二次封装代码吧。先看主函数调用效果(封装好后就是这么Easy使用)

注意hiredisD_VS2013.lib这个lib库要附加到工程里编译额（后续有时间一定放上完整能跑的工程到Csdn下载中心）

完整源码工程VS2013 http://download.csdn.net/detail/lightspear/9762453

// PBHelper_hiredis-win32-Test.cpp : 定义控制台应用程序的入口点。
//

#include <iostream>
#include "src/hiredis/hiredishelper.h"
#include <vector>
int main()
{
	PBLIB::Redis::hiredisUtility redisclass;

	//redisclass.Start();// 内部异步实现了自动重连

	redisclass.Connect(1000);//开始连接Redis


	redisclass.Set("ABC", "123");//设置key
	redisclass.Set("QWE", "123456789", 4);//设置key

	std::string str;
	redisclass.Get("ABC", str);//获取key
	redisclass.LPush("listA", "123546");//压入一个list值
	redisclass.LPush("listA", "654321");//压入一个list值
	std::string popval;
	redisclass.LPop("listA", popval);//弹出一个list值

	std::vector<std::string> vec;
	redisclass.GetList("listA", vec);//获取一个list读到vector中

	return 0;
}

接下来直接上封装过程

#pragma once


#include <iostream>
#include <functional>
#include <mutex>
#include <vector>
namespace PBLIB
{
	namespace Redis
	{

		enum class PB_HIREDISUTILITY_EVENT
		{
			Connect = 100,
			TryConnect,
			DisConnect
		};

		class   hiredisUtility
		{
		public:
			typedef std::function<void(const char * msg, PB_HIREDISUTILITY_EVENT, void*)>  EventHandler;

			hiredisUtility();

			~hiredisUtility();

			void Start();

			void Connect(int millisecond);

			void Disonnect();

			bool Ping();

			bool CmdGetString(std::string &restr, const char *format, ...);

			bool CmdGetInteger(long long &val, const char *format, ...);

			bool  CmdAndEuqalString(const char * equalval, const char *format, ...);

			//Key,Value
			void Get(const char *key, std::string &restr);
			bool Set(const char *key, const std::string &valstr);
			bool Set(const char *key, char * buff, int size);


			//List
			long long LPush(const char * listId, char * buff, int size);
			long long LPush(const char * listId, const std::string &valstr);
		
			bool LPop(const char * listId, std::string &valstr);
			int LLen(const char * listId);
			bool LRange(const char * listId, int startingFrom, int endingAt,std::vector<std::string> &vec);

			bool GetList(const char * listId, std::vector<std::string> &vec);


			EventHandler evenhandler;
			std::mutex m_Cmdmutex;
		private:
			void* Cmd(const char *format, ...);
			bool IsAutoReconnect;
			char m_ip[15];
			int m_port;
			void * m_Context;

			
			std::string m_errorDetail;
		};
	}
}

#include "hiredishelper.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <exception>
#include <thread>

#include "WinSock2.h"
#include "../../external/hiredis-win32-master/include/hiredis.h"

#pragma comment(lib, "ws2_32.lib")



namespace PBLIB
{
	namespace Redis
	{
#define REDIS_REPLY_STR_OK "OK"


		hiredisUtility::hiredisUtility() :m_port(6379)
		{
			strcpy(m_ip, "127.0.0.1");
			m_Context = nullptr;
			evenhandler = nullptr;

			//main2();
		}

		hiredisUtility::~hiredisUtility()
		{
			IsAutoReconnect = false;//停止自动重连线程
		}

		//http://blog.csdn.net/gdutliuyun827/article/details/44339007

		bool hiredisUtility::Ping()
		{
			return CmdAndEuqalString("PONG", "PING");
		}

		//万能方案备用
		void* hiredisUtility::Cmd(const char *format, ...)
		{
			if (m_Context == nullptr) return NULL;

			redisContext *c = (redisContext*)m_Context;

			va_list ap;
			void *reply = NULL;
			va_start(ap, format);
			reply = redisvCommand(c, format, ap);
			va_end(ap);

			if (!c->err)
			{
				return reply;
			}
			return NULL;
		}

		bool hiredisUtility::CmdGetString(std::string &restr, const char *format, ...)
		{
			if (m_Context == nullptr) return false;

			std::lock_guard<std::mutex> locker(m_Cmdmutex);
			redisContext *c = (redisContext*)m_Context;

			va_list ap;
			void *reply = NULL;
			va_start(ap, format);
			reply = redisvCommand(c, format, ap);
			va_end(ap);

			if (!c->err)
			{
				bool IsErroring = false;
				bool flag = false;
				redisReply* r = (redisReply*)reply;
				if (r->type == REDIS_REPLY_STRING)
				{
					restr = r->str;
					flag = true;
				}
				if (r->type == REDIS_REPLY_ERROR)
				{
					IsErroring = true;
					m_errorDetail = r->str;
				}
				freeReplyObject(r);
				if (IsErroring)  throw std::exception(m_errorDetail.data());//直接丢错
				return flag;
			}
			return false;
		}

		bool hiredisUtility::CmdGetInteger(long long &val, const char *format, ...)
		{
			if (m_Context == nullptr) return false;

			std::lock_guard<std::mutex> locker(m_Cmdmutex);
			redisContext *c = (redisContext*)m_Context;

			va_list ap;
			void *reply = NULL;
			va_start(ap, format);
			reply = redisvCommand(c, format, ap);
			va_end(ap);

			if (!c->err)
			{
				bool IsErroring = false;
				bool flag = false;
				redisReply* r = (redisReply*)reply;
				if (r->type == REDIS_REPLY_INTEGER)
				{
					val = r->integer;
					flag = true;
				}
				if (r->type == REDIS_REPLY_ERROR)
				{
					IsErroring = true;
					m_errorDetail = r->str;
				}
				freeReplyObject(r);
				if (IsErroring)  throw std::exception(m_errorDetail.data());//直接丢错
				return flag;
			}
			return false;
		}

		bool hiredisUtility::CmdAndEuqalString(const char * equalval, const char *format, ...)
		{
			if (m_Context == nullptr) return false;
			std::lock_guard<std::mutex> locker(m_Cmdmutex);

			redisContext *c = (redisContext*)m_Context;

			va_list ap;
			void *reply = NULL;
			va_start(ap, format);
			reply = redisvCommand(c, format, ap);
			va_end(ap);

			if (!c->err)
			{
				bool IsErroring = false;
				bool flag = false;
				redisReply* r = (redisReply*)reply;
				if (r->str != NULL)
					flag = strcmp(equalval, r->str) == 0;//如果返回是str
				if (r->type == REDIS_REPLY_ERROR)
				{
					IsErroring = true;
					m_errorDetail = r->str;
				}
				freeReplyObject(r);
				if (IsErroring)  throw std::exception(m_errorDetail.data());//直接丢错
				return flag;
			}
			return false;
		}

		void hiredisUtility::Get(const char *key, std::string &restr)
		{
			CmdGetString(restr, "get %s", key);
		}

		bool hiredisUtility::Set(const char *key, const std::string &valstr)
		{
			return	CmdAndEuqalString(REDIS_REPLY_STR_OK, "set %b %b", key, strlen(key), valstr.data(), valstr.size());
		}

		bool hiredisUtility::Set(const char *key, char * buff, int size){
			return	CmdAndEuqalString(REDIS_REPLY_STR_OK, "set %b %b", key, strlen(key), buff, size);
		}



		long long hiredisUtility::LPush(const char * listId, char * buff, int size)
		{
			long long res = 0;
			CmdGetInteger(res, "LPush %b %b", listId, strlen(listId), buff, size);
			return res;
		}

		long long hiredisUtility::LPush(const char * listId, const std::string &valstr){

			long long res = 0;
			CmdGetInteger(res, "LPush %b %b", listId, strlen(listId), valstr.data(), valstr.size());
			return res;
		}

		bool hiredisUtility::LPop(const char * listId, std::string &valstr)
		{
			return CmdGetString(valstr, "LPop %s", listId);
		}

		void hiredisUtility::Connect(int millisecond)
		{
			if (m_Context != nullptr) return;

			int tv_sec = millisecond / 1000;
			int millisec = millisecond % 1000;
			long tv_usec = millisec * 1000;
			struct timeval timeout;
			timeout.tv_sec = tv_sec;
			timeout.tv_usec = tv_usec;

			redisContext  *c;
			c = redisConnectWithTimeout(m_ip, m_port, timeout);
			if (c != NULL && c->err)
			{
				redisFree(c);
				return;
			}

			m_Context = c;

			if (m_Context != nullptr)
				if (evenhandler != nullptr)
					evenhandler("Redis连接上", PB_HIREDISUTILITY_EVENT::Connect, NULL);
		}

		int hiredisUtility::LLen(const char * listId)
		{
			long long res = 0;
			CmdGetInteger(res, "LLen %b", listId, strlen(listId));
			return res;
		}

		bool hiredisUtility::LRange(const char * listId, int startingFrom, int endingAt, std::vector<std::string> &vec)
		{
			std::lock_guard<std::mutex> locker(m_Cmdmutex);
			void *reply = Cmd("LRange %s %d %d", listId, startingFrom, endingAt);
			if (reply == NULL) return false;
			bool IsErroring = false;
			bool flag = false;
			redisReply* r = (redisReply*)reply;
			if (r->type == REDIS_REPLY_ERROR)
			{
				IsErroring = true;
				m_errorDetail = r->str;
			}
			if (r->type == REDIS_REPLY_ARRAY)
			{
				flag = true;
				for (int j = 0; j < r->elements; j++)
				{
					std::string str = r->element[j]->str;
					vec.push_back(str);
				}
			}
			freeReplyObject(r);
			if (IsErroring)  throw std::exception(m_errorDetail.data());//直接丢错
			return flag;
		}

		bool hiredisUtility::GetList(const char * listId, std::vector<std::string> &vec){
			int len = LLen(listId);
			return LRange(listId, 0, len - 1, vec);
		}

		void hiredisUtility::Start()
		{
			IsAutoReconnect = true;
			std::thread th([this](){

				while (IsAutoReconnect)
				{
					std::chrono::milliseconds timespan(1000);
					std::this_thread::sleep_for(timespan);
					if (Ping() == false)
					{
						Disonnect();
						evenhandler("Redis尝试连接", PB_HIREDISUTILITY_EVENT::TryConnect, NULL);
						Connect(1000);
					}
				}
				Disonnect();
			});
			th.detach();
		}

		void hiredisUtility::Disonnect()
		{

			if (m_Context == nullptr) return;

			redisContext *c = (redisContext*)m_Context;
			if (c != NULL)
			{
				redisFree(c);
				m_Context = nullptr;
				evenhandler("Redis断开了", PB_HIREDISUTILITY_EVENT::Connect, NULL);
			}
		}


		//void redisFree(redisContext *c);










	}
}