redis在游戏服务器中的使用初探(二) 客户端开源库选择

上文提到 搭建完成后 我们选择客户端的开源库进行连接 有以下三种选择

1 acl-redis 原因是支持VC 国产  作者博客   acl 框架库简介  用 acl 库编写高效的 C++ redis 客户端应用

代码支持VC编译 最好使用vc2008-vc2012编译，这样工程包含redis的示例。 我选择的是vc2017的工程图标打开工程的，所以没有示例

作者有中文博客 对该库有详细的介绍 还有QQ群可以进行讨论 技术支持比较强大。

但是问题在于 整个工程偏向C风格 居然是用自己的thread和string。

C++工程若选择该库，在使用何种风格和多线程字符串等使用方式上会收到一定的约束

2 也可以选择 上面提到的redis工程中已经封装好的hredis 可参考我的这篇文章   windows下使用redis c++    。

这个库是redis工程中就包含的 原版匹配，原本是最佳选择。作为本系列演示操作

3 cpp_redis    地址 https://github.com/cylix/cpp_redis + https://github.com/Cylix/tacopie/tree/8714fcec4ba9694fb00e83e788aadc099bd0fd5d

这个感觉是最适合开始使用的库了 c++11 轻量级 跨平台的 redis客户端

不过稳定性和效率还需要再行观察

选定库后 来个简短的例子 测试下。 代码我稍微封装了下 使用了模板，在输入不同的类型时候根据模板自动匹配到相应的类型操作函数上

 // myRedisCli.cpp: 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <assert.h>
 #include <winsock2.h>
 #include <string.h>
 #include <tuple>
 #include <iostream>
 #include <sstream>
 #include <string.h>
 #include"hiredis/hiredis.h"

 class RedisConnect {
 public:
     RedisConnect() :redisCon(nullptr), reply(nullptr) {}

     bool Init(const std::string& ip, int port) {
         if (nullptr != redisCon) {
             return false;
         }
         redisCon = redisConnect(ip.c_str(), port);
         if (redisCon->err) {
             std::cerr << "error code : " << redisCon->err << ". " << redisCon->errstr << std::endl;
             return false;
         }

         return true;
     }
     void freeReply()
     {
         if (nullptr != reply)
         {
             ::freeReplyObject(reply);
             reply = nullptr;
         }
     }

     template<class T>
     bool GetVal(const std::string& key, T& value) {
         return Get(key, value);
     }

     template<class T, class... Args>
     bool HashSet(const std::string command, T head, Args... rest) {
         std::stringstream ss;
         ss << command << " " << head << " ";
         return HashSetInner(ss, rest...);
     }

     template<typename T>
     bool Set(const std::string & key, const T& value)
     {
         bool bret = false;
         std::stringstream ss;
         ss << "SET " << key << " " << value;
         std::string s;
         getline(ss, s);
         return Set(s);
     }

     bool InitWithTimeout(const std::string& ip, int port, int seconds) {
         if (nullptr != redisCon) {
             return false;
         }
         struct timeval tv;
         tv.tv_sec = seconds;
         tv.tv_usec = ;
         redisCon = redisConnectWithTimeout(ip.c_str(), port, tv);
         if (redisCon->err) {
             std::cerr << "error code : " << redisCon->err << ". " << redisCon->errstr << std::endl;
             return false;
         }
         return true;
     }

     ~RedisConnect() {
         freeReply();
         if (nullptr == redisCon) {
             redisFree(redisCon);
             redisCon = nullptr;
         }
     }
 private:
     void GetString(const std::string & key)
     {
         freeReply();
         reply = (redisReply*)::redisCommand(redisCon, "GET %s", key.c_str());
     }

     bool Get(const std::string& key, std::string & value) {
         bool bret = false;
         GetString(key);
         if (nullptr == reply) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         else if (reply->type == REDIS_REPLY_NIL) {
             std::cout << __FUNCTION__ << ". Key = \"" << key << "\" find nothing" << std::endl << std::endl;
             return bret;
         }else if( reply->type != REDIS_REPLY_STRING) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         value = reply->str;
         bret = true;
         return bret;
     }

     bool Get(const std::string& key, int & value) {
         bool bret = false;
         GetString(key);
         if (nullptr == reply) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         else if (reply->type == REDIS_REPLY_NIL) {
             std::cout << __FUNCTION__ << ". Key = \"" << key << "\" find nothing" << std::endl << std::endl;
             return bret;
         }
         else if (reply->type != REDIS_REPLY_STRING) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         value = ::atoi(reply->str);
         bret = true;
         return bret;
     }

     bool Get(const std::string& key, float & value) {
         bool bret = false;
         GetString(key);
         if (nullptr == reply) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         else if (reply->type == REDIS_REPLY_NIL) {
             std::cout << __FUNCTION__ << ". Key = \"" << key << "\" find nothing" << std::endl << std::endl;
             return bret;
         }
         else if (reply->type != REDIS_REPLY_STRING) {
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }
         value = ::atof(reply->str);
         bret = true;
         return bret;
     }

     bool HashSetInner(std::stringstream& ss)
     {
         std::string data;
         getline(ss, data);
         //std::cout << __FUNCTION__ << " " << data << std::endl;
         bool bret = false;
         freeReply();
         reply = (redisReply*)::redisCommand(redisCon, data.c_str());

         if (reply->type == REDIS_REPLY_ERROR ||
             (reply->type == REDIS_REPLY_STATUS && _stricmp(reply->str, "OK") != ))
         {
             if (reply->str != nullptr) {
                 std::cout << reply->str << std::endl;
             }
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl << std::endl;
             return bret;
         }

         bret = true;

         return bret;
     }

     template<class T, class... Args>
     bool HashSetInner(std::stringstream& ss, T head, Args... rest)
     {
         ss << head << " ";
         return HashSetInner(ss, rest...);
     }

     bool Set(std::string data)
     {
         bool bret = false;
         freeReply();
         reply = (redisReply*)::redisCommand(redisCon, data.c_str());

         if (!(reply->type == REDIS_REPLY_STATUS && _stricmp(reply->str, "OK") == ))
         {
             std::cout << reply->str << std::endl;
             std::cout << "Failed to execute " << __FUNCTION__ << std::endl;
             return bret;
         }
         bret = true;
         return bret;
     }

     redisContext* redisCon;
     redisReply * reply;
 };

 int main()
 {
     RedisConnect r;

     bool b = r.InitWithTimeout("127.0.0.1", , );
     if (!b)
         return -;

     r.Set("testtimes", );
     r.Set("float:pi", 3.14159265);
     r.Set("string", "test");
     std::string retStr;
     r.GetVal("string", retStr);
     float f;
     r.GetVal("float:pi", f);
     int i;
     r.GetVal("testtimes", i);

     r.GetVal("wqe42", retStr);

     r.HashSet("hset", "myhash", "field1", 123.2342343);
     r.HashSet("hmset", "myhash", "field1", , "field2", "f2");

     r.HashSet("hset", "myhash", "field1", 123.2342343);
     r.HashSet("hmset", "myhash", "field1", , "field2", "f2");

     //wrong command
     //r.HashSet("hset", "myhash", "field1", 1, 123.2342343);
     //r.HashSet("hmset", "myhash", "field1", 1, 1111, "field2", "f2");

     std::cout << "finish !" << std::endl;
     return ;
 }

MyHredisCli

运行效果图:(记得开启redis)