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 = 0;
        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") != 0))
        {
            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") == 0))
        {
            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", 6379, 5);
    if (!b)
        return -1;

    r.Set("testtimes", 1);
    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", 1111, "field2", "f2");
    


    r.HashSet("hset", "myhash", "field1", 123.2342343);
    r.HashSet("hmset", "myhash", "field1", 1111, "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 0;
}

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