\u5b8c\u6574\u4ee3\u7801\u89c1：deng-c-f\/redis_pool (gitee.com)<\/p>\n<\/p>\n
#ifndef CACHEPOOL_H_
\n#define CACHEPOOL_H_<\/p>\n
#include <condition_variable>
\n#include <iostream>
\n#include <list>
\n#include <map>
\n#include <mutex>
\n#include <vector><\/p>\n
#include <hiredis\/hiredis.h><\/p>\n
using std::list;
\nusing std::map;
\nusing std::string;
\nusing std::vector;<\/p>\n
#define REDIS_COMMAND_SIZE 300 \/* redis Command \u6307\u4ee4\u6700\u5927\u957f\u5ea6 *\/
\n#define FIELD_ID_SIZE 100 \/* redis hash\u8868field\u57df\u5b57\u6bb5\u957f\u5ea6 *\/
\n#define VALUES_ID_SIZE 1024 \/* redis value\u57df\u5b57\u6bb5\u957f\u5ea6 *\/
\ntypedef char (
\n *RFIELDS)[FIELD_ID_SIZE]; \/* redis hash\u8868\u5b58\u653e\u6279\u91cffield\u5b57\u7b26\u4e32\u6570\u7ec4\u7c7b\u578b *\/<\/p>\n
\/\/\u6570\u7ec4\u6307\u9488\u7c7b\u578b，\u5176\u53d8\u91cf\u6307\u5411 char[1024]
\ntypedef char (
\n *RVALUES)[VALUES_ID_SIZE]; \/* redis \u8868\u5b58\u653e\u6279\u91cfvalue\u5b57\u7b26\u4e32\u6570\u7ec4\u7c7b\u578b *\/<\/p>\n
class CachePool;<\/p>\n
class CacheConn {
\n public:
\n CacheConn(const char *server_ip, int server_port, int db_index,
\n const char *password, const char *pool_name = "");
\n CacheConn(CachePool *pCachePool);
\n virtual ~CacheConn();<\/p>\n
int Init();
\n void DeInit();
\n const char *GetPoolName();
\n \/\/ \u901a\u7528\u64cd\u4f5c
\n \/\/ \u5224\u65ad\u4e00\u4e2akey\u662f\u5426\u5b58\u5728
\n bool IsExists(string &key);
\n \/\/ \u5220\u9664\u67d0\u4e2akey
\n long Del(string key);<\/p>\n
\/\/ ——————- \u5b57\u7b26\u4e32\u76f8\u5173 ——————-
\n string Get(string key);
\n string Set(string key, string value);
\n string SetEx(string key, int timeout, string value);<\/p>\n
\/\/ string mset(string key, map);
\n \/\/\u6279\u91cf\u83b7\u53d6
\n bool MGet(const vector<string> &keys, map<string, string> &ret_value);
\n \/\/\u539f\u5b50\u52a0\u51cf1
\n int Incr(string key, int64_t &value);
\n int Decr(string key, int64_t &value);<\/p>\n
\/\/ —————- \u54c8\u5e0c\u76f8\u5173 ————————
\n long Hdel(string key, string field);
\n string Hget(string key, string field);
\n int Hget(string key, char *field, char *value);
\n bool HgetAll(string key, map<string, string> &ret_value);
\n long Hset(string key, string field, string value);<\/p>\n
long HincrBy(string key, string field, long value);
\n long IncrBy(string key, long value);
\n string Hmset(string key, map<string, string> &hash);
\n bool Hmget(string key, list<string> &fields, list<string> &ret_value);<\/p>\n
\/\/ ———— \u94fe\u8868\u76f8\u5173 ————
\n long Lpush(string key, string value);
\n long Rpush(string key, string value);
\n long Llen(string key);
\n bool Lrange(string key, long start, long end, list<string> &ret_value);<\/p>\n
\/\/ zset \u76f8\u5173
\n int ZsetExit(string key, string member);
\n int ZsetAdd(string key, long score, string member);
\n int ZsetZrem(string key, string member);
\n int ZsetIncr(string key, string member);
\n int ZsetZcard(string key);
\n int ZsetZrevrange(string key, int from_pos, int end_pos, RVALUES values,
\n int &get_num);
\n int ZsetGetScore(string key, string member);<\/p>\n
\/\/ \u83b7\u53d6\u6d88\u606f\u961f\u5217\u76f8\u5173\u547d\u4ee4
\n \/**
\n * key ：\u961f\u5217\u540d
\n end ：\u7ed3\u675f\u503c， + \u8868\u793a\u6700\u5927\u503c
\n start ：\u5f00\u59cb\u503c， – \u8868\u793a\u6700\u5c0f\u503c
\n count ：\u6570\u91cf
\n *\/
\n bool GetXrevrange(const string & key,
\n const string start, const string end, int count, std::vector<std::pair<string, string>> &msgs);
\n \/\/ \/ \u6dfb\u52a0\u6d88\u606f\u5230\u6d41
\n bool Xadd(const string& key, string& id, const std::vector<std::pair<string, string>>& field_value_pairs);<\/p>\n
bool FlushDb();<\/p>\n
private:
\n CachePool *cache_pool_;
\n redisContext *context_; \/\/ \u6bcf\u4e2aredis\u8fde\u63a5 redisContext redis\u5ba2\u6237\u7aef\u7f16\u7a0b\u7684\u5bf9\u8c61
\n uint64_t last_connect_time_;
\n uint16_t server_port_;
\n string server_ip_;
\n string password_;
\n uint16_t db_index_;
\n string pool_name_;
\n};<\/p>\n
class CachePool {
\n public:
\n \/\/ db_index\u548cmysql\u4e0d\u540c\u7684\u5730\u65b9
\n CachePool(const char *pool_name, const char *server_ip, int server_port,
\n int db_index, const char *password, int max_conn_cnt);
\n virtual ~CachePool();<\/p>\n
int Init();
\n \/\/ \u83b7\u53d6\u7a7a\u95f2\u7684\u8fde\u63a5\u8d44\u6e90
\n CacheConn *GetCacheConn(const int timeout_ms = 0);
\n \/\/ Pool\u56de\u6536\u8fde\u63a5\u8d44\u6e90
\n void RelCacheConn(CacheConn *cache_conn);<\/p>\n
const char *GetPoolName() { return pool_name_.c_str(); }
\n const char *GetServerIP() { return server_ip_.c_str(); }
\n const char *GetPassword() { return password_.c_str(); }
\n int GetServerPort() { return m_server_port; }
\n int GetDBIndex() { return db_index_; }<\/p>\n
private:
\n string pool_name_;
\n string server_ip_;
\n string password_;
\n int m_server_port;
\n int db_index_; \/\/ mysql \u6570\u636e\u5e93\u540d\u5b57， redis db index<\/p>\n
int cur_conn_cnt_;
\n int max_conn_cnt_;
\n list<CacheConn *> free_list_;<\/p>\n
std::mutex m_mutex;
\n std::condition_variable cond_var_;
\n bool abort_request_ = false;
\n};<\/p>\n
class CacheManager {
\n public:
\n virtual ~CacheManager();
\n \/\/\/ @brief
\n \/\/\/ @param conf_path
\n static void SetConfPath(const char *conf_path);
\n static CacheManager *getInstance();<\/p>\n
int Init();
\n CacheConn *GetCacheConn(const char *pool_name);
\n void RelCacheConn(CacheConn *cache_conn);<\/p>\n
private:
\n CacheManager();<\/p>\n
private:
\n static CacheManager *s_cache_manager;
\n map<string, CachePool *> m_cache_pool_map;
\n static string conf_path_;
\n};<\/p>\n
class AutoRelCacheCon {
\n public:
\n AutoRelCacheCon(CacheManager *manger, CacheConn *conn)
\n : manger_(manger), conn_(conn) {}
\n ~AutoRelCacheCon() {
\n if (manger_) {
\n manger_->RelCacheConn(conn_);
\n }
\n \/\/ std::cout << "\u6d4b\u8bd5\u8fde\u63a5\u56de\u6536" << std::endl; \/\/ \u6d4b\u8bd5\u81ea\u52a8\u56de\u6536
\n } \/\/\u5728\u6790\u6784\u51fd\u6570\u89c4\u5212
\n private:
\n CacheManager *manger_ = NULL;
\n CacheConn *conn_ = NULL;
\n};<\/p>\n
#define AUTO_REL_CACHECONN(m, c) AutoRelCacheCon autorelcacheconn(m, c)<\/p>\n
#endif \/* CACHEPOOL_H_ *\/<\/p>\n
#include "cache_pool.h"<\/p>\n
#include ".\/base\/util.h"
\n#include <stdlib.h>
\n#include <string.h>
\n#define log_error printf
\n#define log_info printf
\n#define log_warn printf
\n\/\/ #define log printf
\n#define MIN_CACHE_CONN_CNT 2
\n#define MAX_CACHE_CONN_FAIL_NUM 10<\/p>\n
#include ".\/base\/config_file_reader.h"
\n#include <utility><\/p>\n
CacheManager *CacheManager::s_cache_manager = NULL;
\nstring CacheManager::conf_path_ = "";\/\/"tc_http_server.conf"; \/\/ \u9ed8\u8ba4
\nCacheConn::CacheConn(const char *server_ip, int server_port, int db_index,
\n const char *password, const char *pool_name) {
\n server_ip_ = server_ip;
\n server_port_ = server_port;<\/p>\n
db_index_ = db_index;
\n password_ = password;
\n pool_name_ = pool_name;
\n context_ = NULL;
\n last_connect_time_ = 0;
\n}<\/p>\n
CacheConn::CacheConn(CachePool *pCachePool) {
\n cache_pool_ = pCachePool;
\n if (pCachePool) {
\n server_ip_ = pCachePool->GetServerIP();
\n server_port_ = pCachePool->GetServerPort();
\n db_index_ = pCachePool->GetDBIndex();
\n password_ = pCachePool->GetPassword();
\n pool_name_ = pCachePool->GetPoolName();
\n } else {
\n log_error("pCachePool is NULL\\\\n");
\n }<\/p>\n
context_ = NULL;
\n last_connect_time_ = 0;
\n}<\/p>\n
CacheConn::~CacheConn() {
\n if (context_) {
\n redisFree(context_);
\n context_ = NULL;
\n }
\n}<\/p>\n
\/*
\n * redis\u521d\u59cb\u5316\u8fde\u63a5\u548c\u91cd\u8fde\u64cd\u4f5c，\u7c7b\u4f3cmysql_ping()
\n *\/
\nint CacheConn::Init() {
\n if (context_) \/\/ \u975e\u7a7a，\u8fde\u63a5\u662f\u6b63\u5e38\u7684
\n {
\n return 0;
\n }<\/p>\n
\/\/ 1s \u5c1d\u8bd5\u91cd\u8fde\u4e00\u6b21
\n uint64_t cur_time = (uint64_t)time(NULL);
\n if (cur_time < last_connect_time_ + 1) \/\/ \u91cd\u8fde\u5c1d\u8bd5 \u95f4\u96941\u79d2
\n {
\n printf("cur_time:%lu, m_last_connect_time:%lu\\\\n", cur_time,
\n last_connect_time_);
\n return 1;
\n }
\n \/\/ printf("m_last_connect_time = cur_time\\\\n");
\n last_connect_time_ = cur_time;<\/p>\n
\/\/ 1000ms\u8d85\u65f6
\n struct timeval timeout = {0, 1000000};
\n \/\/ \u5efa\u7acb\u8fde\u63a5\u540e\u4f7f\u7528 redisContext \u6765\u4fdd\u5b58\u8fde\u63a5\u72b6\u6001\u3002
\n \/\/ redisContext \u5728\u6bcf\u6b21\u64cd\u4f5c\u540e\u4f1a\u4fee\u6539\u5176\u4e2d\u7684 err \u548c errstr
\n \/\/ \u5b57\u6bb5\u6765\u8868\u793a\u53d1\u751f\u7684\u9519\u8bef\u7801（\u5927\u4e8e0）\u548c\u5bf9\u5e94\u7684\u63cf\u8ff0\u3002
\n context_ =
\n redisConnectWithTimeout(server_ip_.c_str(), server_port_, timeout);<\/p>\n
if (!context_ || context_->err) {
\n if (context_) {
\n log_error("redisConnect failed: %s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n } else {
\n log_error("redisConnect failed\\\\n");
\n }<\/p>\n
return 1;
\n }<\/p>\n
redisReply *reply;
\n \/\/ \u9a8c\u8bc1
\n if (!password_.empty()) {
\n reply =
\n (redisReply *)redisCommand(context_, "AUTH %s", password_.c_str());<\/p>\n
if (!reply || reply->type == REDIS_REPLY_ERROR) {
\n log_error("Authentication failure:%p\\\\n", reply);
\n if (reply)
\n freeReplyObject(reply);
\n return -1;
\n } else {
\n \/\/ log_info("Authentication success\\\\n");
\n }<\/p>\n
freeReplyObject(reply);
\n }<\/p>\n
reply = (redisReply *)redisCommand(context_, "SELECT %d", db_index_);<\/p>\n
if (reply && (reply->type == REDIS_REPLY_STATUS) &&
\n (strncmp(reply->str, "OK", 2) == 0)) {
\n freeReplyObject(reply);
\n return 0;
\n } else {
\n if (reply)
\n log_error("select cache db failed:%s\\\\n", reply->str);
\n return 2;
\n }
\n}<\/p>\n
void CacheConn::DeInit() {
\n if (context_) {
\n redisFree(context_);
\n context_ = NULL;
\n }
\n}<\/p>\n
const char *CacheConn::GetPoolName() { return pool_name_.c_str(); }<\/p>\n
string CacheConn::Get(string key) {
\n string value;<\/p>\n
if (Init()) {
\n return value;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "GET %s", key.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return value;
\n }<\/p>\n
if (reply->type == REDIS_REPLY_STRING) {
\n value.append(reply->str, reply->len);
\n }<\/p>\n
freeReplyObject(reply);
\n return value;
\n}<\/p>\n
string CacheConn::Set(string key, string value) {
\n string ret_value;<\/p>\n
if (Init()) {
\n return ret_value;
\n }
\n \/\/ \u8fd4\u56de\u7684\u7ed3\u679c\u5b58\u653e\u5728redisReply
\n redisReply *reply = (redisReply *)redisCommand(context_, "SET %s %s",
\n key.c_str(), value.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return ret_value;
\n }<\/p>\n
ret_value.append(reply->str, reply->len);
\n freeReplyObject(reply); \/\/ \u91ca\u653e\u8d44\u6e90
\n return ret_value;
\n}<\/p>\n
string CacheConn::SetEx(string key, int timeout, string value) {
\n string ret_value;<\/p>\n
if (Init()) {
\n return ret_value;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(
\n context_, "SETEX %s %d %s", key.c_str(), timeout, value.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return ret_value;
\n }<\/p>\n
ret_value.append(reply->str, reply->len);
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
bool CacheConn::MGet(const vector<string> &keys,
\n map<string, string> &ret_value) {
\n if (Init()) {
\n return false;
\n }
\n if (keys.empty()) {
\n return false;
\n }<\/p>\n
string strKey;
\n bool bFirst = true;
\n for (vector<string>::const_iterator it = keys.begin(); it != keys.end();
\n ++it) {
\n if (bFirst) {
\n bFirst = false;
\n strKey = *it;
\n } else {
\n strKey += " " + *it;
\n }
\n }<\/p>\n
if (strKey.empty()) {
\n return false;
\n }
\n strKey = "MGET " + strKey;
\n redisReply *reply = (redisReply *)redisCommand(context_, strKey.c_str());
\n if (!reply) {
\n log_info("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return false;
\n }
\n if (reply->type == REDIS_REPLY_ARRAY) {
\n for (size_t i = 0; i < reply->elements; ++i) {
\n redisReply *child_reply = reply->element[i];
\n if (child_reply->type == REDIS_REPLY_STRING) {
\n ret_value[keys[i]] = child_reply->str;
\n }
\n }
\n }
\n freeReplyObject(reply);
\n return true;
\n}<\/p>\n
bool CacheConn::IsExists(string &key) {
\n if (Init()) {
\n return false;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "EXISTS %s", key.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return false;
\n }
\n long ret_value = reply->integer;
\n freeReplyObject(reply);
\n if (0 == ret_value) {
\n return false;
\n } else {
\n return true;
\n }
\n}<\/p>\n
long CacheConn::Del(string key) {
\n if (Init()) {
\n return 0;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "DEL %s", key.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return 0;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
long CacheConn::Hdel(string key, string field) {
\n if (Init()) {
\n return -1;
\n }
\n redisReply *reply = (redisReply *)redisCommand(context_, "HDEL %s %s",
\n key.c_str(), field.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
string CacheConn::Hget(string key, string field) {
\n string ret_value;
\n if (Init()) {
\n return ret_value;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "HGET %s %s",
\n key.c_str(), field.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return ret_value;
\n }<\/p>\n
if (reply->type == REDIS_REPLY_STRING) {
\n ret_value.append(reply->str, reply->len);
\n }<\/p>\n
freeReplyObject(reply);
\n return ret_value;
\n}
\nint CacheConn::Hget(string key, char *field, char *value) {
\n int retn = 0;
\n int len = 0;<\/p>\n
if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "hget %s %s", key.c_str(), field);
\n if (reply == NULL || reply->type != REDIS_REPLY_STRING) {
\n printf("hget %s %s error %s\\\\n", key.c_str(), field, context_->errstr);
\n retn = -1;
\n goto END;
\n }<\/p>\n
len = reply->len > VALUES_ID_SIZE ? VALUES_ID_SIZE : reply->len;
\n strncpy(value, reply->str, len);<\/p>\n
value[len] = '\\\\0';<\/p>\n
END:
\n freeReplyObject(reply);<\/p>\n
return retn;
\n}
\nbool CacheConn::HgetAll(string key, map<string, string> &ret_value) {
\n if (Init()) {
\n return false;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "HGETALL %s", key.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return false;
\n }<\/p>\n
if ((reply->type == REDIS_REPLY_ARRAY) && (reply->elements % 2 == 0)) {
\n for (size_t i = 0; i < reply->elements; i += 2) {
\n redisReply *field_reply = reply->element[i];
\n redisReply *value_reply = reply->element[i + 1];<\/p>\n
string field(field_reply->str, field_reply->len);
\n string value(value_reply->str, value_reply->len);
\n ret_value.insert(make_pair(field, value));
\n }
\n }<\/p>\n
freeReplyObject(reply);
\n return true;
\n}<\/p>\n
long CacheConn::Hset(string key, string field, string value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(
\n context_, "HSET %s %s %s", key.c_str(), field.c_str(), value.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
long CacheConn::HincrBy(string key, string field, long value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(
\n context_, "HINCRBY %s %s %ld", key.c_str(), field.c_str(), value);
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
long CacheConn::IncrBy(string key, long value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "INCRBY %s %ld",
\n key.c_str(), value);
\n if (!reply) {
\n log_error("redis Command failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }
\n long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
string CacheConn::Hmset(string key, map<string, string> &hash) {
\n string ret_value;<\/p>\n
if (Init()) {
\n return ret_value;
\n }<\/p>\n
int argc = hash.size() * 2 + 2;
\n const char **argv = new const char *[argc];
\n if (!argv) {
\n return ret_value;
\n }<\/p>\n
argv[0] = "HMSET";
\n argv[1] = key.c_str();
\n int i = 2;
\n for (map<string, string>::iterator it = hash.begin(); it != hash.end();
\n it++) {
\n argv[i++] = it->first.c_str();
\n argv[i++] = it->second.c_str();
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommandArgv(context_, argc, argv, NULL);
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n delete[] argv;<\/p>\n
redisFree(context_);
\n context_ = NULL;
\n return ret_value;
\n }<\/p>\n
ret_value.append(reply->str, reply->len);<\/p>\n
delete[] argv;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
bool CacheConn::Hmget(string key, list<string> &fields,
\n list<string> &ret_value) {
\n if (Init()) {
\n return false;
\n }<\/p>\n
int argc = fields.size() + 2;
\n const char **argv = new const char *[argc];
\n if (!argv) {
\n return false;
\n }<\/p>\n
argv[0] = "HMGET";
\n argv[1] = key.c_str();
\n int i = 2;
\n for (list<string>::iterator it = fields.begin(); it != fields.end(); it++) {
\n argv[i++] = it->c_str();
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommandArgv(
\n context_, argc, (const char **)argv, NULL);
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n delete[] argv;<\/p>\n
redisFree(context_);
\n context_ = NULL;<\/p>\n
return false;
\n }<\/p>\n
if (reply->type == REDIS_REPLY_ARRAY) {
\n for (size_t i = 0; i < reply->elements; i++) {
\n redisReply *value_reply = reply->element[i];
\n string value(value_reply->str, value_reply->len);
\n ret_value.push_back(value);
\n }
\n }<\/p>\n
delete[] argv;
\n freeReplyObject(reply);
\n return true;
\n}<\/p>\n
int CacheConn::Incr(string key, int64_t &value) {
\n value = 0;
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "INCR %s", key.c_str());
\n if (!reply) {
\n log_error("redis Command failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }
\n value = reply->integer;
\n freeReplyObject(reply);
\n return 0;
\n}<\/p>\n
int CacheConn::Decr(string key, int64_t &value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "DECR %s", key.c_str());
\n if (!reply) {
\n log_error("redis Command failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }
\n value = reply->integer;
\n freeReplyObject(reply);
\n return 0;
\n}<\/p>\n
long CacheConn::Lpush(string key, string value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "LPUSH %s %s",
\n key.c_str(), value.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
long CacheConn::Rpush(string key, string value) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "RPUSH %s %s",
\n key.c_str(), value.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
long CacheConn::Llen(string key) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
redisReply *reply =
\n (redisReply *)redisCommand(context_, "LLEN %s", key.c_str());
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return -1;
\n }<\/p>\n
long ret_value = reply->integer;
\n freeReplyObject(reply);
\n return ret_value;
\n}<\/p>\n
bool CacheConn::Lrange(string key, long start, long end,
\n list<string> &ret_value) {
\n if (Init()) {
\n return false;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "LRANGE %s %d %d",
\n key.c_str(), start, end);
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return false;
\n }<\/p>\n
if (reply->type == REDIS_REPLY_ARRAY) {
\n for (size_t i = 0; i < reply->elements; i++) {
\n redisReply *value_reply = reply->element[i];
\n string value(value_reply->str, value_reply->len);
\n ret_value.push_back(value);
\n }
\n }<\/p>\n
freeReplyObject(reply);
\n return true;
\n}<\/p>\n
int CacheConn::ZsetExit(string key, string member) {
\n int retn = 0;
\n redisReply *reply = NULL;
\n if (Init()) {
\n return -1;
\n }<\/p>\n
\/\/\u6267\u884c\u547d\u4ee4
\n reply =
\n (redisReply *)redisCommand(context_, "zlexcount %s [%s [%s",
\n key.c_str(), member.c_str(), member.c_str());<\/p>\n
if (reply->type != REDIS_REPLY_INTEGER) {
\n log_error("zlexcount: %s,member: %s Error:%s,%s\\\\n", key.c_str(),
\n member.c_str(), reply->str, context_->errstr);
\n retn = -1;
\n goto END;
\n }<\/p>\n
retn = reply->integer;<\/p>\n
END:<\/p>\n
freeReplyObject(reply);
\n return retn;
\n}<\/p>\n
int CacheConn::ZsetAdd(string key, long score, string member) {
\n int retn = 0;
\n redisReply *reply = NULL;
\n if (Init()) {
\n std::cout << "Init() -> failed";
\n return -1;
\n }<\/p>\n
\/\/\u6267\u884c\u547d\u4ee4, reply->integer\u6210\u529f\u8fd4\u56de1，reply->integer\u5931\u8d25\u8fd4\u56de0
\n reply = (redisReply *)redisCommand(context_, "ZADD %s %ld %s", key.c_str(),
\n score, member.c_str());
\n \/\/ rop_test_reply_type(reply);<\/p>\n
if (reply->type != REDIS_REPLY_INTEGER) {
\n printf("ZADD: %s,member: %s Error:%s,%s, reply->integer:%lld, %d\\\\n",
\n key.c_str(), member.c_str(), reply->str, context_->errstr,
\n reply->integer, reply->type);
\n retn = -1;
\n goto END;
\n }<\/p>\n
END:<\/p>\n
freeReplyObject(reply);
\n return retn;
\n}<\/p>\n
int CacheConn::ZsetZrem(string key, string member) {
\n int retn = 0;
\n redisReply *reply = NULL;
\n if (Init()) {
\n std::cout << "Init() -> failed";
\n return -1;
\n }<\/p>\n
\/\/\u6267\u884c\u547d\u4ee4, reply->integer\u6210\u529f\u8fd4\u56de1，reply->integer\u5931\u8d25\u8fd4\u56de0
\n reply = (redisReply *)redisCommand(context_, "ZREM %s %s", key.c_str(),
\n member.c_str());
\n if (reply->type != REDIS_REPLY_INTEGER) {
\n printf("ZREM: %s,member: %s Error:%s,%s\\\\n", key.c_str(), member.c_str(),
\n reply->str, context_->errstr);
\n retn = -1;
\n goto END;
\n }
\nEND:<\/p>\n
freeReplyObject(reply);
\n return retn;
\n}
\nint CacheConn::ZsetIncr(string key, string member) {
\n int retn = 0;
\n redisReply *reply = NULL;
\n if (Init()) {
\n return false;
\n }<\/p>\n
reply = (redisReply *)redisCommand(context_, "ZINCRBY %s 1 %s", key.c_str(),
\n member.c_str());
\n \/\/ rop_test_reply_type(reply);
\n if (strcmp(reply->str, "OK") != 0) {
\n printf("Add or increment table: %s,member: %s Error:%s,%s\\\\n",
\n key.c_str(), member.c_str(), reply->str, context_->errstr);<\/p>\n
retn = -1;
\n goto END;
\n }<\/p>\n
END:
\n freeReplyObject(reply);
\n return retn;
\n}<\/p>\n
int CacheConn::ZsetZcard(string key) {
\n redisReply *reply = NULL;
\n if (Init()) {
\n return -1;
\n }<\/p>\n
int cnt = 0;<\/p>\n
reply = (redisReply *)redisCommand(context_, "ZCARD %s", key.c_str());
\n if (reply->type != REDIS_REPLY_INTEGER) {
\n printf("ZCARD %s error %s\\\\n", key.c_str(), context_->errstr);
\n cnt = -1;
\n goto END;
\n }<\/p>\n
cnt = reply->integer;<\/p>\n
END:
\n freeReplyObject(reply);
\n return cnt;
\n}
\nint CacheConn::ZsetZrevrange(string key, int from_pos, int end_pos,
\n RVALUES values, int &get_num) {
\n int retn = 0;
\n redisReply *reply = NULL;
\n if (Init()) {
\n return -1;
\n }
\n int i = 0;
\n int max_count = 0;<\/p>\n
int count = end_pos – from_pos + 1; \/\/\u8bf7\u6c42\u5143\u7d20\u4e2a\u6570<\/p>\n
\/\/\u964d\u5e8f\u83b7\u53d6\u6709\u5e8f\u96c6\u5408\u7684\u5143\u7d20
\n reply = (redisReply *)redisCommand(context_, "ZREVRANGE %s %d %d",
\n key.c_str(), from_pos, end_pos);
\n if (reply->type != REDIS_REPLY_ARRAY) \/\/\u5982\u679c\u8fd4\u56de\u4e0d\u662f\u6570\u7ec4
\n {
\n printf("ZREVRANGE %s error!%s\\\\n", key.c_str(), context_->errstr);
\n retn = -1;
\n goto END;
\n }<\/p>\n
\/\/\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4，\u67e5\u770belements\u7684\u503c(\u6570\u7ec4\u4e2a\u6570)
\n \/\/\u901a\u8fc7element[index] \u7684\u65b9\u5f0f\u8bbf\u95ee\u6570\u7ec4\u5143\u7d20
\n \/\/\u6bcf\u4e2a\u6570\u7ec4\u5143\u7d20\u662f\u4e00\u4e2aredisReply\u5bf9\u8c61\u7684\u6307\u9488<\/p>\n
max_count = (reply->elements > count) ? count : reply->elements;
\n get_num = max_count; \/\/\u5f97\u5230\u7ed3\u679cvalue\u7684\u4e2a\u6570<\/p>\n
for (i = 0; i < max_count; ++i) {
\n strncpy(values[i], reply->element[i]->str, VALUES_ID_SIZE – 1);
\n values[i][VALUES_ID_SIZE – 1] = 0; \/\/\u7ed3\u675f\u7b26
\n }<\/p>\n
END:
\n if (reply != NULL) {
\n freeReplyObject(reply);
\n }<\/p>\n
return retn;
\n}<\/p>\n
int CacheConn::ZsetGetScore(string key, string member) {
\n if (Init()) {
\n return -1;
\n }<\/p>\n
int score = 0;<\/p>\n
redisReply *reply = NULL;<\/p>\n
reply = (redisReply *)redisCommand(context_, "ZSCORE %s %s", key.c_str(),
\n member.c_str());<\/p>\n
if (reply->type != REDIS_REPLY_STRING) {
\n printf("[-][GMS_REDIS]ZSCORE %s %s error %s\\\\n", key.c_str(),
\n member.c_str(), context_->errstr);
\n score = -1;
\n goto END;
\n }
\n score = atoi(reply->str);<\/p>\n
END:
\n freeReplyObject(reply);<\/p>\n
return score;
\n}<\/p>\n
\/\/ \u83b7\u53d6\u6d88\u606f\u961f\u5217\u76f8\u5173\u547d\u4ee4
\n\/**
\n * key ：\u961f\u5217\u540d
\n end ：\u7ed3\u675f\u503c， + \u8868\u793a\u6700\u5927\u503c
\n start ：\u5f00\u59cb\u503c， – \u8868\u793a\u6700\u5c0f\u503c
\n count ：\u6570\u91cf
\n *\/
\n\/\/ XREVRANGE mystream + –
\n\/\/ XREVRANGE \u7a0b\u5e8f\u5458\u8001\u5ed62 + –
\n\/\/ XREVRANGE \u7a0b\u5e8f\u5458\u8001\u5ed6 + –
\nbool CacheConn::GetXrevrange(const string & key,
\n const string start, const string end, int count, std::vector<std::pair<string, string>> &msgs) {
\n bool ret = false;
\n if (Init()) {
\n return false;
\n }
\n \/\/ \u6784\u5efa XREVRANGE \u547d\u4ee4
\n string command = "XREVRANGE " + key + " " + start + " " + end;
\n if (count > 0) {
\n command += " COUNT " + std::to_string(count);
\n }
\n std::cout << "command: " << command;
\n \/\/ \u53d1\u9001\u547d\u4ee4
\n redisReply* reply = (redisReply*)redisCommand(context_, command.c_str());
\n if (!reply) {
\n std::cerr << "Failed to execute XREVRANGE command" << std::endl;
\n return false;
\n }<\/p>\n
\/\/ \u68c0\u67e5\u56de\u590d\u7c7b\u578b
\n if (reply->type != REDIS_REPLY_ARRAY) {
\n std::cerr << "Unexpected reply type: " << reply->type << std::endl;
\n freeReplyObject(reply);
\n return false;
\n }<\/p>\n
\/\/ \u89e3\u6790\u56de\u590d
\n for (size_t i = 0; i < reply->elements; i++) {
\n redisReply* entry = reply->element[i];
\n if (entry->type == REDIS_REPLY_ARRAY && entry->elements >= 2) {
\n \/\/ \u7b2c\u4e00\u4e2a\u5143\u7d20\u662f\u6d88\u606f ID
\n string message_id = entry->element[0]->str; \/\/\u6d88\u606fid \u83b7\u53d6\u56de\u6765\u7684<\/p>\n
\/\/ \u7b2c\u4e8c\u4e2a\u5143\u7d20\u662f\u6d88\u606f\u5185\u5bb9（\u5b57\u6bb5-\u503c\u5bf9）
\n redisReply* fields = entry->element[1];
\n if (fields->type == REDIS_REPLY_ARRAY) {
\n string message_content;
\n string value;
\n for (size_t j = 0; j < fields->elements; j += 2) {
\n string field = fields->element[j]->str;
\n value = fields->element[j + 1]->str;
\n message_content += field + ": " + value + ", ";
\n }
\n \/\/ std::cout << string( "key: " + key + ", ID: " + message_id + ", Content: " + message_content);
\n msgs.push_back({message_id, value});
\n }
\n }
\n }<\/p>\n
\/\/ \u91ca\u653e\u56de\u590d\u5bf9\u8c61
\n freeReplyObject(reply);
\n return true;
\n}<\/p>\n
bool CacheConn::Xadd(const string& key, string& id, const std::vector<std::pair<string, string>>& field_value_pairs)
\n{
\n bool ret = false;
\n if (Init()) {
\n return false;
\n }
\n \/\/ \u6784\u5efa XADD \u547d\u4ee4
\n string command = "XADD " + key + " " + id;<\/p>\n
\/\/ \u6dfb\u52a0\u5b57\u6bb5-\u503c\u5bf9
\n for (const auto& pair : field_value_pairs) {
\n command += " " + pair.first + " " + pair.second;
\n }
\n std::cout << "command: " << command;
\n \/\/ \u53d1\u9001\u547d\u4ee4
\n redisReply* reply = (redisReply*)redisCommand(context_, command.c_str());
\n if (!reply) {
\n std::cerr << "Failed to execute XADD command" << std::endl;
\n return false;
\n }<\/p>\n
\/\/ \u68c0\u67e5\u56de\u590d\u7c7b\u578b
\n if (reply->type == REDIS_REPLY_ERROR) {
\n std::cerr << "Error: " << reply->str << std::endl;
\n freeReplyObject(reply);
\n return false;
\n }<\/p>\n
\/\/ \u6253\u5370\u6210\u529f\u6d88\u606f
\n \/\/ std::cout << "Message added with ID: " << reply->str << std::endl;
\n id = reply->str;
\n \/\/ \u91ca\u653e\u56de\u590d\u5bf9\u8c61
\n freeReplyObject(reply);
\n return true;
\n}
\nbool CacheConn::FlushDb() {
\n bool ret = false;
\n if (Init()) {
\n return false;
\n }<\/p>\n
redisReply *reply = (redisReply *)redisCommand(context_, "FLUSHDB");
\n if (!reply) {
\n log_error("redisCommand failed:%s\\\\n", context_->errstr);
\n redisFree(context_);
\n context_ = NULL;
\n return false;
\n }<\/p>\n
if (reply->type == REDIS_REPLY_STRING &&
\n strncmp(reply->str, "OK", 2) == 0) {
\n ret = true;
\n }<\/p>\n
freeReplyObject(reply);<\/p>\n
return ret;
\n}
\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
\nCachePool::CachePool(const char *pool_name, const char *server_ip,
\n int server_port, int db_index, const char *password,
\n int max_conn_cnt) {
\n pool_name_ = pool_name;
\n server_ip_ = server_ip;
\n m_server_port = server_port;
\n db_index_ = db_index;
\n password_ = password;
\n max_conn_cnt_ = max_conn_cnt;
\n cur_conn_cnt_ = MIN_CACHE_CONN_CNT;
\n}<\/p>\n
CachePool::~CachePool() {
\n {
\n std::lock_guard<std::mutex> lock(m_mutex);
\n abort_request_ = true;
\n cond_var_.notify_all(); \/\/ \u901a\u77e5\u6240\u6709\u5728\u7b49\u5f85\u7684
\n }
\n {
\n std::lock_guard<std::mutex> lock(m_mutex);
\n for (list<CacheConn *>::iterator it = free_list_.begin();
\n it != free_list_.end(); it++) {
\n CacheConn *pConn = *it;
\n delete pConn;
\n }
\n }<\/p>\n
free_list_.clear();
\n cur_conn_cnt_ = 0;
\n}<\/p>\n
int CachePool::Init() {
\n for (int i = 0; i < cur_conn_cnt_; i++) {
\n CacheConn *pConn =
\n new CacheConn(server_ip_.c_str(), m_server_port, db_index_,
\n password_.c_str(), pool_name_.c_str());
\n if (pConn->Init()) {
\n delete pConn;
\n return 1;
\n }<\/p>\n
free_list_.push_back(pConn);
\n }<\/p>\n
log_info("cache pool: %s, list size: %lu\\\\n", pool_name_.c_str(),
\n free_list_.size());
\n return 0;
\n}<\/p>\n
CacheConn *CachePool::GetCacheConn(const int timeout_ms) {
\n std::unique_lock<std::mutex> lock(m_mutex);
\n if (abort_request_) {
\n log_info("have aboort\\\\n");
\n return NULL;
\n }<\/p>\n
if (free_list_.empty()) \/\/ 2 \u5f53\u6ca1\u6709\u8fde\u63a5\u53ef\u4ee5\u7528\u65f6
\n {
\n \/\/ \u7b2c\u4e00\u6b65\u5148\u68c0\u6d4b \u5f53\u524d\u8fde\u63a5\u6570\u91cf\u662f\u5426\u8fbe\u5230\u6700\u5927\u7684\u8fde\u63a5\u6570\u91cf
\n if (cur_conn_cnt_ >= max_conn_cnt_) \/\/ \u7b49\u5f85\u7684\u903b\u8f91
\n {
\n \/\/ \u5982\u679c\u5df2\u7ecf\u5230\u8fbe\u4e86，\u770b\u770b\u662f\u5426\u9700\u8981\u8d85\u65f6\u7b49\u5f85
\n if (timeout_ms <= 0) \/\/ \u6b7b\u7b49，\u76f4\u5230\u6709\u8fde\u63a5\u53ef\u4ee5\u7528 \u6216\u8005 \u8fde\u63a5\u6c60\u8981\u9000\u51fa
\n {
\n log_info("wait ms:%d\\\\n", timeout_ms);
\n cond_var_.wait(lock, [this] {
\n \/\/ \u5f53\u524d\u8fde\u63a5\u6570\u91cf\u5c0f\u4e8e\u6700\u5927\u8fde\u63a5\u6570\u91cf \u6216\u8005\u8bf7\u6c42\u91ca\u653e\u8fde\u63a5\u6c60\u65f6\u9000\u51fa
\n return (!free_list_.empty()) | abort_request_;
\n });
\n } else {
\n \/\/ return\u5982\u679c\u8fd4\u56de false，\u7ee7\u7eedwait(\u6216\u8005\u8d85\u65f6),
\n \/\/ \u5982\u679c\u8fd4\u56detrue\u9000\u51fawait 1.m_free_list\u4e0d\u4e3a\u7a7a 2.\u8d85\u65f6\u9000\u51fa
\n \/\/ 3. m_abort_request\u88ab\u7f6e\u4e3atrue，\u8981\u91ca\u653e\u6574\u4e2a\u8fde\u63a5\u6c60
\n cond_var_.wait_for(
\n lock, std::chrono::milliseconds(timeout_ms),
\n [this] { return (!free_list_.empty()) | abort_request_; });
\n \/\/ \u5e26\u8d85\u65f6\u529f\u80fd\u65f6\u8fd8\u8981\u5224\u65ad\u662f\u5426\u4e3a\u7a7a
\n if (free_list_.empty()) \/\/ \u5982\u679c\u8fde\u63a5\u6c60\u8fd8\u662f\u6ca1\u6709\u7a7a\u95f2\u5219\u9000\u51fa
\n {
\n return NULL;
\n }
\n }<\/p>\n
if (abort_request_) {
\n log_warn("have aboort\\\\n");
\n return NULL;
\n }
\n } else \/\/ \u8fd8\u6ca1\u6709\u5230\u6700\u5927\u8fde\u63a5\u5219\u521b\u5efa\u8fde\u63a5
\n {
\n CacheConn *db_conn =
\n new CacheConn(server_ip_.c_str(), m_server_port, db_index_,
\n password_.c_str(), pool_name_.c_str()); \/\/\u65b0\u5efa\u8fde\u63a5
\n int ret = db_conn->Init();
\n if (ret) {
\n log_error("Init DBConnecton failed\\\\n\\\\n");
\n delete db_conn;
\n return NULL;
\n } else {
\n free_list_.push_back(db_conn);
\n cur_conn_cnt_++;
\n \/\/ log_info("new db connection: %s, conn_cnt: %d\\\\n",
\n \/\/ m_pool_name.c_str(), m_cur_conn_cnt);
\n }
\n }
\n }<\/p>\n
CacheConn *pConn = free_list_.front();
\n free_list_.pop_front();<\/p>\n
return pConn;
\n}<\/p>\n
void CachePool::RelCacheConn(CacheConn *p_cache_conn) {
\n std::lock_guard<std::mutex> lock(m_mutex);<\/p>\n
list<CacheConn *>::iterator it = free_list_.begin();
\n for (; it != free_list_.end(); it++) {
\n if (*it == p_cache_conn) {
\n break;
\n }
\n }<\/p>\n
if (it == free_list_.end()) {
\n \/\/ m_used_list.remove(pConn);
\n free_list_.push_back(p_cache_conn);
\n cond_var_.notify_one(); \/\/ \u901a\u77e5\u53d6\u961f\u5217
\n } else {
\n log_error("RelDBConn failed\\\\n"); \/\/ \u4e0d\u518d\u6b21\u56de\u6536\u8fde\u63a5
\n }
\n}<\/p>\n
\/\/\/\/\/\/\/\/\/\/\/
\nCacheManager::CacheManager() {}<\/p>\n
CacheManager::~CacheManager() {}<\/p>\n
void CacheManager::SetConfPath(const char *conf_path) {
\n conf_path_ = conf_path;
\n}<\/p>\n
CacheManager *CacheManager::getInstance() {
\n if (!s_cache_manager) {
\n s_cache_manager = new CacheManager();
\n if (s_cache_manager->Init()) {
\n delete s_cache_manager;
\n s_cache_manager = NULL;
\n }
\n }<\/p>\n
return s_cache_manager;
\n}<\/p>\n
int CacheManager::Init() {
\n std::cout << "Init";
\n CConfigFileReader config_file(conf_path_.c_str());<\/p>\n
char *cache_instances = config_file.GetConfigName("CacheInstances");
\n if (!cache_instances) {
\n std::cout << "not configure CacheIntance";
\n return 1;
\n }<\/p>\n
char host[64];
\n char port[64];
\n char db[64];
\n char maxconncnt[64];
\n CStrExplode instances_name(cache_instances, ',');
\n for (uint32_t i = 0; i < instances_name.GetItemCnt(); i++) {
\n char *pool_name = instances_name.GetItem(i);
\n \/\/ printf("%s", pool_name);
\n snprintf(host, 64, "%s_host", pool_name);
\n snprintf(port, 64, "%s_port", pool_name);
\n snprintf(db, 64, "%s_db", pool_name);
\n snprintf(maxconncnt, 64, "%s_maxconncnt", pool_name);<\/p>\n
char *cache_host = config_file.GetConfigName(host);
\n char *str_cache_port = config_file.GetConfigName(port);
\n char *str_cache_db = config_file.GetConfigName(db);
\n char *str_max_conn_cnt = config_file.GetConfigName(maxconncnt);
\n if (!cache_host || !str_cache_port || !str_cache_db ||
\n !str_max_conn_cnt) {
\n if(!cache_host)
\n std::cout << "not configure cache instance: " << pool_name << ", cache_host is null";
\n if(!str_cache_port)
\n std::cout << "not configure cache instance: " << pool_name << ", str_cache_port is null";
\n if(!str_cache_db)
\n std::cout << "not configure cache instance: " << pool_name << ", str_cache_db is null";
\n if(!str_max_conn_cnt)
\n std::cout << "not configure cache instance: " << pool_name << ", str_max_conn_cnt is null";
\n return 2;
\n }<\/p>\n
CachePool *pCachePool =
\n new CachePool(pool_name, cache_host, atoi(str_cache_port),
\n atoi(str_cache_db), "", atoi(str_max_conn_cnt));
\n if (pCachePool->Init()) {
\n std::cout << "Init cache pool failed";
\n return 3;
\n }<\/p>\n
m_cache_pool_map.insert(make_pair(pool_name, pCachePool));
\n }<\/p>\n
return 0;
\n}<\/p>\n
CacheConn *CacheManager::GetCacheConn(const char *pool_name) {
\n map<string, CachePool *>::iterator it = m_cache_pool_map.find(pool_name);
\n if (it != m_cache_pool_map.end()) {
\n return it->second->GetCacheConn();
\n } else {
\n return NULL;
\n }
\n}<\/p>\n
void CacheManager::RelCacheConn(CacheConn *cache_conn) {
\n if (!cache_conn) {
\n return;
\n }<\/p>\n
map<string, CachePool *>::iterator it =
\n m_cache_pool_map.find(cache_conn->GetPoolName());
\n if (it != m_cache_pool_map.end()) {
\n return it->second->RelCacheConn(cache_conn);
\n }
\n}<\/p>\n
CacheInstances=master
\nmaster_host=127.0.0.1
\nmaster_port=6379
\nmaster_db=0 #\u521d\u59cb\u5316conn\u65f6\u9ed8\u8ba4\u6267\u884c Select db
\nmaster_maxconncnt=128<\/p>\n","protected":false},"excerpt":{"rendered":"
\u5b8c\u6574\u4ee3\u7801\u89c1：deng-c-f\/redis_pool (gitee.com) cache_pool.h #ifndef CACHEPOOL_H_
\n#define CACHEPOOL_H_#include
\n#include
\n#include
\n#include <\/p>\n