【数据库开发】C++测试redis中的publish/subscribe

最新推荐文章于 2024-03-11 19:22:27 发布
最新推荐文章于 2024-03-11 19:22:27 发布
阅读量226 收藏
点赞数
文章标签： 数据库 c/c++
原文链接：http://www.cnblogs.com/huty/p/8517416.html
版权
运用
http://blog.csdn.net/xumaojun/article/details/51558237 中的redis_publisher.hredis_publisher.cpp redis_subscriber.h redis_subscriber.cpp四个文件,做一个操作类进行测试.
头文件 Policy.h 
#pragma once  
#include "redis_publisher.h"  
#include "redis_subscriber.h"  
#include <iostream>  
  
using namespace std;  
  
class Policy  
{  
public:  
    Policy();  
    ~Policy();  
    void publish();  
    static void recieve_message(const char *channel_name,const char *message, int len);  
  
    CRedisPublisher publisher;  
    CRedisSubscriber subscriber;  
};

代码文件 Policy.cpp 
#include "Policy.h"  
  
Policy::Policy()  
{  
    bool ret = publisher.init();  
    if (!ret) {  
        printf("Init failed.\n");  
  
    }  
  
    ret = publisher.connect();  
    if (!ret) {  
        printf("connect failed.");  
  
    }  
  
    //***********************************  
    CRedisSubscriber::NotifyMessageFn fn =  
        bind(recieve_message, std::tr1::placeholders::_1,  
             std::tr1::placeholders::_2, std::tr1::placeholders::_3);  
  
    bool ret1 = subscriber.init(fn);  
    if (!ret1) {  
        printf("Init failed.\n");  
    }  
  
    ret1 = subscriber.connect();  
    if (!ret1) {  
        printf("Connect failed.\n");  
    }  
    subscriber.subscribe("test-channel");  
}  
  
Policy::~Policy()  
{  
    publisher.disconnect();  
    publisher.uninit();  
  
    subscriber.disconnect();  
    subscriber.uninit();  
}  
  
  
void Policy::publish()  
{  
    cout<<"Policy::publish()...\n"<<endl;  
    publisher.publish("test-channel", "Test message");  
}  
  
  
void Policy::recieve_message(const char *channel_name,  
    const char *message, int len)  
{  
    printf("Recieve message:    channel name: %s    message: %s\n",  
        channel_name, message);  
}


测试文件 testPolicy.cpp 
#include "Policy.h"  
int main(int argc, char *argv[])  
{  
    Policy m_policy;  
    int i=0;  
    while(i<8){  
        m_policy.publish();  
        sleep(2);  
        cout<<"main sleep...\n";  
        i++;  
    }  
    return 0;  
}


Makefile 
EXE=server_main client_main    
CC=g++    
FLAG=-lhiredis -levent -pthread    
OBJ=redis_publisher.o redis_subscriber.o Policy.o testPolicy.o    
  
  
all:$(EXE)  
  
$(EXE):$(OBJ)  
    $(CC) -o testPolicy  redis_publisher.o redis_subscriber.o Policy.o testPolicy.o  $(FLAG)  
    
redis_publisher.o:redis_publisher.h  
redis_subscriber.o:redis_subscriber.h  
  
Policy.o:Policy.h


这样编译之后,可以自发自收.
本例的用途在于可以简单地在项目中实现异构的数据收发.

附上原作代码:
redis_publisher.h 
/*************************************************************************  
    > File Name: redis_publisher.h  
    > Author: chenzengba  
    > Mail: chenzengba@gmail.com   
    > Created Time: Sat 23 Apr 2016 10:15:09 PM CST  
    > Description: 封装hiredis，实现消息发布给redis功能  
 ************************************************************************/    
    
#ifndef REDIS_PUBLISHER_H    
#define REDIS_PUBLISHER_H    
    
#include <stdlib.h>    
#include <hiredis/async.h>    
#include <hiredis/adapters/libevent.h>    
#include <string>    
#include <vector>    
#include <unistd.h>    
#include <pthread.h>    
#include <semaphore.h>    
#include <boost/tr1/functional.hpp>    
    
class CRedisPublisher    
{    
public:        
    CRedisPublisher();    
    ~CRedisPublisher();    
    
    bool init();    
    bool uninit();    
    bool connect();    
    bool disconnect();    
        
    bool publish(const std::string &channel_name,     
        const std::string &message);    
    
private:    
     // 下面三个回调函数供redis服务调用    
    // 连接回调    
    static void connect_callback(const redisAsyncContext *redis_context,    
        int status);    
        
    // 断开连接的回调    
    static void disconnect_callback(const redisAsyncContext *redis_context,    
        int status);    
    
    // 执行命令回调    
    static void command_callback(redisAsyncContext *redis_context,    
        void *reply, void *privdata);    
    
    // 事件分发线程函数    
    static void *event_thread(void *data);    
    void *event_proc();    
    
private:    
     // libevent事件对象    
    event_base *_event_base;    
    // 事件线程ID    
    pthread_t _event_thread;    
    // 事件线程的信号量    
    sem_t _event_sem;    
    // hiredis异步对象    
    redisAsyncContext *_redis_context;    
};


redis_publisher.cpp 
/*************************************************************************  
    > File Name: redis_publisher.cpp  
    > Author: chenzengba  
    > Mail: chenzengba@gmail.com   
    > Created Time: Sat 23 Apr 2016 10:15:09 PM CST  
    > Description:   
 ************************************************************************/    
     
#include <stddef.h>    
#include <assert.h>    
#include <string.h>    
#include "redis_publisher.h"    
    
CRedisPublisher::CRedisPublisher():_event_base(0), _event_thread(0),    
_redis_context(0)    
{    
}    
    
CRedisPublisher::~CRedisPublisher()    
{    
}    
    
bool CRedisPublisher::init()    
{    
    // initialize the event    
    _event_base = event_base_new();    // 创建libevent对象    
    if (NULL == _event_base)    
    {    
        printf(": Create redis event failed.\n");    
        return false;    
    }    
    
    memset(&_event_sem, 0, sizeof(_event_sem));    
    int ret = sem_init(&_event_sem, 0, 0);    
    if (ret != 0)    
    {    
        printf(": Init sem failed.\n");    
        return false;    
    }    
    
    return true;    
}    
    
bool CRedisPublisher::uninit()    
{    
    _event_base = NULL;    
        
    sem_destroy(&_event_sem);       
    return true;    
}    
    
bool CRedisPublisher::connect()    
{    
    // connect redis    
    _redis_context = redisAsyncConnect("127.0.0.1", 6379);    // 异步连接到redis服务器上，使用默认端口    
    if (NULL == _redis_context)    
    {    
        printf(": Connect redis failed.\n");    
        return false;    
    }    
    
    if (_redis_context->err)    
    {    
        printf(": Connect redis error: %d, %s\n",     
            _redis_context->err, _redis_context->errstr);    // 输出错误信息    
        return false;    
    }    
    
    // attach the event    
    redisLibeventAttach(_redis_context, _event_base);    // 将事件绑定到redis context上，使设置给redis的回调跟事件关联    
        
    // 创建事件处理线程    
    int ret = pthread_create(&_event_thread, 0, &CRedisPublisher::event_thread, this);    
    if (ret != 0)    
    {    
        printf(": create event thread failed.\n");    
        disconnect();    
        return false;    
    }    
    
    // 设置连接回调，当异步调用连接后，服务器处理连接请求结束后调用，通知调用者连接的状态    
    redisAsyncSetConnectCallback(_redis_context,     
        &CRedisPublisher::connect_callback);    
    
    // 设置断开连接回调，当服务器断开连接后，通知调用者连接断开，调用者可以利用这个函数实现重连    
    redisAsyncSetDisconnectCallback(_redis_context,    
        &CRedisPublisher::disconnect_callback);    
    
    // 启动事件线程    
    sem_post(&_event_sem);    
    return true;    
}    
    
bool CRedisPublisher::disconnect()    
{    
    if (_redis_context)    
    {    
        redisAsyncDisconnect(_redis_context);    
        redisAsyncFree(_redis_context);    
        _redis_context = NULL;    
    }    
    
    return true;    
}    
    
bool CRedisPublisher::publish(const std::string &channel_name,    
    const std::string &message)    
{    
    int ret = redisAsyncCommand(_redis_context,     
        &CRedisPublisher::command_callback, this, "PUBLISH %s %s",     
        channel_name.c_str(), message.c_str());    
    if (REDIS_ERR == ret)    
    {    
        printf("Publish command failed: %d\n", ret);    
        return false;    
    }    
    
    return true;    
}    
    
void CRedisPublisher::connect_callback(const redisAsyncContext *redis_context,    
    int status)    
{    
    if (status != REDIS_OK)    
    {    
        printf(": Error: %s\n", redis_context->errstr);    
    }    
    else    
    {    
        printf(": Redis connected!\n");    
    }    
}    
    
void CRedisPublisher::disconnect_callback(    
    const redisAsyncContext *redis_context, int status)    
{    
    if (status != REDIS_OK)    
    {    
        // 这里异常退出，可以尝试重连    
        printf(": Error: %s\n", redis_context->errstr);    
    }    
}    
    
// 消息接收回调函数    
void CRedisPublisher::command_callback(redisAsyncContext *redis_context,    
    void *reply, void *privdata)    
{    
    printf("command callback.\n");    
    // 这里不执行任何操作    
}    
    
void *CRedisPublisher::event_thread(void *data)    
{    
    if (NULL == data)    
    {    
        printf(": Error!\n");    
        assert(false);    
        return NULL;    
    }    
    
    CRedisPublisher *self_this = reinterpret_cast<CRedisPublisher *>(data);    
    return self_this->event_proc();    
}    
    
void *CRedisPublisher::event_proc()    
{    
    sem_wait(&_event_sem);    
        
    // 开启事件分发，event_base_dispatch会阻塞    
    event_base_dispatch(_event_base);    
    
    return NULL;    
}



redis_subscriber.h 
/*************************************************************************  
    > File Name: redis_subscriber.h  
    > Author: chenzengba  
    > Mail: chenzengba@gmail.com   
    > Created Time: Sat 23 Apr 2016 10:15:09 PM CST  
    > Description: 封装hiredis，实现消息订阅redis功能  
 ************************************************************************/    
    
#ifndef REDIS_SUBSCRIBER_H    
#define REDIS_SUBSCRIBER_H    
    
#include <stdlib.h>    
#include <hiredis/async.h>    
#include <hiredis/adapters/libevent.h>    
#include <string>    
#include <vector>    
#include <unistd.h>    
#include <pthread.h>    
#include <semaphore.h>    
#include <boost/tr1/functional.hpp>    
    
class CRedisSubscriber    
{    
public:    
    typedef std::tr1::function<void (const char *, const char *, int)>         NotifyMessageFn;   // 回调函数对象类型，当接收到消息后调用回调把消息发送出去    
            
    CRedisSubscriber();    
    ~CRedisSubscriber();    
        
    bool init(const NotifyMessageFn &fn);   // 传入回调对象    
    bool uninit();    
    bool connect();    
    bool disconnect();    
        
    // 可以多次调用，订阅多个频道    
    bool subscribe(const std::string &channel_name);    
        
private:    
    // 下面三个回调函数供redis服务调用    
    // 连接回调    
    static void connect_callback(const redisAsyncContext *redis_context,    
        int status);    
        
    // 断开连接的回调    
    static void disconnect_callback(const redisAsyncContext *redis_context,    
        int status);    
    
    // 执行命令回调    
    static void command_callback(redisAsyncContext *redis_context,    
        void *reply, void *privdata);    
    
    // 事件分发线程函数    
    static void *event_thread(void *data);    
    void *event_proc();    
        
private:    
    // libevent事件对象    
    event_base *_event_base;    
    // 事件线程ID    
    pthread_t _event_thread;    
    // 事件线程的信号量    
    sem_t _event_sem;    
    // hiredis异步对象    
    redisAsyncContext *_redis_context;    
        
    // 通知外层的回调函数对象    
    NotifyMessageFn _notify_message_fn;    
};




redis_subscriber.cpp 
/*************************************************************************  
    > File Name: redis_subscriber.cpp  
    > Author: chenzengba  
    > Mail: chenzengba@gmail.com   
    > Created Time: Sat 23 Apr 2016 10:15:09 PM CST  
    > Description:   
 ************************************************************************/    
     
#include <stddef.h>    
#include <assert.h>    
#include <string.h>    
#include "redis_subscriber.h"    
    
CRedisSubscriber::CRedisSubscriber():_event_base(0), _event_thread(0),    
_redis_context(0)    
{    
}    
    
CRedisSubscriber::~CRedisSubscriber()    
{    
}    
    
bool CRedisSubscriber::init(const NotifyMessageFn &fn)    
{    
    // initialize the event    
    _notify_message_fn = fn;    
    _event_base = event_base_new();    // 创建libevent对象    
    if (NULL == _event_base)    
    {    
        printf(": Create redis event failed.\n");    
        return false;    
    }    
    
    memset(&_event_sem, 0, sizeof(_event_sem));    
    int ret = sem_init(&_event_sem, 0, 0);    
    if (ret != 0)    
    {    
        printf(": Init sem failed.\n");    
        return false;    
    }    
    
    return true;    
}    
    
bool CRedisSubscriber::uninit()    
{    
    _event_base = NULL;    
        
    sem_destroy(&_event_sem);       
    return true;    
}    
    
bool CRedisSubscriber::connect()    
{    
    // connect redis    
    _redis_context = redisAsyncConnect("127.0.0.1", 6379);    // 异步连接到redis服务器上，使用默认端口    
    if (NULL == _redis_context)    
    {    
        printf(": Connect redis failed.\n");    
        return false;    
    }    
    
    if (_redis_context->err)    
    {    
        printf(": Connect redis error: %d, %s\n",     
            _redis_context->err, _redis_context->errstr);    // 输出错误信息    
        return false;    
    }    
    
    // attach the event    
    redisLibeventAttach(_redis_context, _event_base);    // 将事件绑定到redis context上，使设置给redis的回调跟事件关联    
        
    // 创建事件处理线程    
    int ret = pthread_create(&_event_thread, 0, &CRedisSubscriber::event_thread, this);    
    if (ret != 0)    
    {    
        printf(": create event thread failed.\n");    
        disconnect();    
        return false;    
    }    
    
    // 设置连接回调，当异步调用连接后，服务器处理连接请求结束后调用，通知调用者连接的状态    
    redisAsyncSetConnectCallback(_redis_context,     
        &CRedisSubscriber::connect_callback);    
    
    // 设置断开连接回调，当服务器断开连接后，通知调用者连接断开，调用者可以利用这个函数实现重连    
    redisAsyncSetDisconnectCallback(_redis_context,    
        &CRedisSubscriber::disconnect_callback);    
    
    // 启动事件线程    
    sem_post(&_event_sem);    
    return true;    
}    
    
bool CRedisSubscriber::disconnect()    
{    
    if (_redis_context)    
    {    
        redisAsyncDisconnect(_redis_context);    
        redisAsyncFree(_redis_context);    
        _redis_context = NULL;    
    }    
    
    return true;    
}    
    
bool CRedisSubscriber::subscribe(const std::string &channel_name)    
{    
    int ret = redisAsyncCommand(_redis_context,     
        &CRedisSubscriber::command_callback, this, "SUBSCRIBE %s",     
        channel_name.c_str());    
    if (REDIS_ERR == ret)    
    {    
        printf("Subscribe command failed: %d\n", ret);    
        return false;    
    }    
        
    printf(": Subscribe success: %s\n", channel_name.c_str());    
    return true;    
}    
    
void CRedisSubscriber::connect_callback(const redisAsyncContext *redis_context,    
    int status)    
{    
    if (status != REDIS_OK)    
    {    
        printf(": Error: %s\n", redis_context->errstr);    
    }    
    else    
    {    
        printf(": Redis connected!");    
    }    
}    
    
void CRedisSubscriber::disconnect_callback(    
    const redisAsyncContext *redis_context, int status)    
{    
    if (status != REDIS_OK)    
    {    
        // 这里异常退出，可以尝试重连    
        printf(": Error: %s\n", redis_context->errstr);    
    }    
}    
    
// 消息接收回调函数    
void CRedisSubscriber::command_callback(redisAsyncContext *redis_context,    
    void *reply, void *privdata)    
{    
    if (NULL == reply || NULL == privdata) {    
        return ;    
    }    
    
    // 静态函数中，要使用类的成员变量，把当前的this指针传进来，用this指针间接访问    
    CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(privdata);    
    redisReply *redis_reply = reinterpret_cast<redisReply *>(reply);    
        
    // 订阅接收到的消息是一个带三元素的数组    
    if (redis_reply->type == REDIS_REPLY_ARRAY &&    
    redis_reply->elements == 3)    
    {    
        printf(": Recieve message:%s:%d:%s:%d:%s:%d\n",    
        redis_reply->element[0]->str, redis_reply->element[0]->len,    
        redis_reply->element[1]->str, redis_reply->element[1]->len,    
        redis_reply->element[2]->str, redis_reply->element[2]->len);    
            
        // 调用函数对象把消息通知给外层    
        self_this->_notify_message_fn(redis_reply->element[1]->str,    
            redis_reply->element[2]->str, redis_reply->element[2]->len);    
    }    
}    
    
void *CRedisSubscriber::event_thread(void *data)    
{    
    if (NULL == data)    
    {    
        printf(": Error!\n");    
        assert(false);    
        return NULL;    
    }    
    
    CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(data);    
    return self_this->event_proc();    
}    
    
void *CRedisSubscriber::event_proc()    
{    
    sem_wait(&_event_sem);    
        
    // 开启事件分发，event_base_dispatch会阻塞    
    event_base_dispatch(_event_base);    
    
    return NULL;    
}



转载于:https://www.cnblogs.com/huty/p/8517416.html

C++测试redis中的publish/subscribe
灯火阑珊处
01-17 7735
运用 http://blog.csdn.net/xumaojun/article/details/51558237 中的redis_publisher.h redis_publisher.cpp redis_subscriber.h redis_subscriber.cpp四个文件,做一个操作类进行测试. 头文件 Policy.h #pragma once #include "redi
windows c++使用hiredis同步模式实现发布订阅
caifengguo的博客
08-17 2105
#include using namespace std; #include"hiredis.h" int main() { //初始化 int ret = redisNetInit(); if(ret == 0) { printf("redisNetInit fail!"); return -1; } //通过ip.port连接redis服务(默认监听端口为
C++ 实现 redis 发布订阅 --- 使用 hiredis 同步API（二）
12-20 697
下载hiredis库源码，我的编译环境为ubuntu14，解压hiredis源码后，终端下进入源码目录，然后输入make命令编译即可，编译后将分别得到静态及动态库文件：libhiredis.a / libhiredis.so，然后结合头文件就可以在工程中使用redis了。做服务端开发基本都会用到redis，java调用redis就简单了，教程很多，库也都是现成的，多数会选择jedis库吧，但是c++调用redis就麻烦一点，基本都要自己编译才行。虽然支持c++的redis库也很多，但是用哪个呢？
C++ 实现 redis 订阅发布 --- libevent
12-15 1214
订阅、取消订阅和发布实现了发布/订阅消息范式，发布者不是计划发送消息给特定的订阅者。而是发布的消息分到不同的频道，不需要知道什么样的订阅者订阅。libevent库、boost库、 hiredis库等，因为是基于异步的发送和接收，需要回调函数来返回确认相关的信息。订阅者对一个或多个频道感兴趣，只需接收感兴趣的消息，不需要知道什么样的发布者发布的。
C++ Redis 同步 基于发布-订阅模式的消息队列
XWBDurant的博客
03-11 570
C++ 使用hiredis 完成相应基本操作
C++ Redis 客户端简单使用
06-17
首先，为了在C++中与Redis进行交互，我们需要一个支持C++的Redis客户端库。常见的选择有`hiredis`，这是一个轻量级的C库，同时也提供了C++绑定。另一个是`cpp-redis`，这是一个完全用C++编写的客户端库，提供了更...
distr-redis-master.zip_C++操作Redis_redis c++_redis c++_redis分布式_
09-20
4. **发布/订阅(Publish/Subscribe)**：Redis支持发布/订阅模式，允许不同客户端通过频道进行通信。在C++中，开发者可以创建订阅者和发布者对象来实现这一功能。 5. **事务（Transactions）**：Redis支持事务，允许...
Redis开发 保姆级Redis开发教程.zip
05-08
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。 安装 Liunx 安装 Tips：redis官网： 下载选择稳定版本 链接 Tips：自定义版本：链接 安装redis之前要先安装8版本的gcc、gcc-c++、gdb工具...
Redis事务、pub/sub、PipeLine-管道、benchmark性能测试详解
Linuxhus的博客
12-06 715
(1). 原子性一个事务(transaction)中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被恢复(Rollback)到事务开始前的状态，就像这个事务从来没有执行过一样。　Redis的事务并不是我们传统意义上理解的事务，我们都知道 单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会
windows 下C++调用redis
星星之火的语言c学习
02-11 1981
redis支持的是Linux，但是githup有window版本的，但是最早的就是redis2.4版本的，是用vs2010写的，所以最低只能用vs2010来编，cmake目前还不熟，所以不太会版本之间相互转换，我用的是vs2017编的，是可以成功的，具体步骤如下：1》下载源码包https://github.com/MicrosoftArchive/redis2》解压3》  打开msvs文件：编译s...
redis订阅机制简单的使用方法
07-23
redis订阅机制，一方面推送消息，另一方面同时接收消息。
C++封装Redis访问类
04-26
C++封装Redis访问类，封装set和get操作
redis3.0 for windows
07-10
debug程序用debug的lib，release用release的
c++聊天室redis(10)
qq_62309585的博客
08-15 718
发布订阅(pub/sub)是一种消息通信模式，主要的目的是解耦消息发布者和消息订阅者之间的耦合，这点和设计模式中的观察者模式比较相似。订阅者可以通过 subscribe 和 psubscribe 命令向 redis server 订阅自己感兴趣的消息类型，redis 将消息类型称为通道(channel)。当客户端登录的时候，服务器吧它的id号 subscribe到redis中间件，表示该服务器对这个id发生的事件感兴趣，而Redis收到发送给该id的消息时就会 把消息转发到这个服务器上。...
c++ 队列_Redis队列（三）：消息的发布与订阅的C源码实现分析
weixin_39684228的博客
11-26 718
一、概述在之前的文章分析过，Redis的消息发布与订阅支持基于频道channel的精确订阅与基于模式pattern的模糊订阅，并且是实时的消息传输，不会进行消息存储，如下从源代码来分析Redis的订阅与发布功能的实现，主要在Redis源码的pubsub.c文件定义。二、消息订阅1. 客户端和服务端的订阅存储结构消息订阅主要从客户端client和服务端server两个角度来分析。首先在客户端clie...
深入理解Redis的发布/订阅机制(pub/sub)
azurelaker的博客
12-23 1万+
Redis
linux下使用hiredis异步API实现sub/pub消息订阅和发布的功能
皇天霸的博客
04-23 5988
最近使用redis的c接口——hiredis，使客户端与redis服务器通信，实现消息订阅和发布（PUB/SUB）的功能，我把遇到的一些问题和解决方法列出来供大家学习。        废话不多说，先贴代码。 redis_publisher.h /**********************************************************************
redis的消息发布（publish）/ 订阅（subscribe）
热门推荐
baijiwei的博客
03-10 3万+
最近项目需要一个可以实现发布/订阅 机制的消息队列， 首先想到的是Kafka， RabbitMQ之类的消息队列组件， 但是感觉我们的项目也许不需要引入那么复杂的组件， Redis也有一个比较轻量的订阅机制。 我们可以参考redis的 Publish/Subscribe 机制， 来得到比较好的问题解决方案。 publish/subscribe的用法 redis提供了如下6个命令来支持该功能：...
C++操作Redis的简单例子
imxiangzi的专栏
09-03 1万+
相信做过服务端开发的应该都知道Redis的大名，它是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，我们后台是用C++开发的，问了下他们，用的缓存框架有Redis，SSDB，今天看了几个帖子，简单了解Redis的用法。记录一下过程。 首先去官网下载最新的Redis源码 http://redis.io/ 解压之后，进入目录编译 make
redisTemplate实现redis的publish/subscribe
最新发布
10-14
RedisTemplate是Spring Data Redis提供的一个封装了Jedis客户端操作的工具类，它简化了对Redis的集成和高级操作，包括发布订阅(publish/subscribe)功能。在使用`RedisTemplate`实现pub/sub时，你需要做以下几个步骤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值