redis发布-订阅的客户端编程
redis支持多种不同的客户端编程语言,例如Java对应jedis、php对应phpredis、C++对应的则是hiredis。下面是安装hiredis的步骤:
1. git clone https://github.com/redis/hiredis 从github上下载hiredis客户端,进行源码编译安装
2、cd hiredis
3、make
4、sudo make install
拷贝生成的动态库到/usr/local/lib目录下!
5、sudo ldconfig /usr/local/lib
Redis发布订阅消息队列在项目上的代码实现
我们在include下的server下创建文件夹:redis
我们在include的server的redis下创建文件:redis.hpp
#ifndef REDIS_H
#define REDIS_H
#include <hiredis/hiredis.h>
#include <thread>
#include <functional>
using namespace std;
class Redis
{
public:
Redis();
~Redis();
//连接redis服务器
bool connect();
//向redis指定的通道channel发布消息
bool publish(int channel, string message);
//向redis指定的通道subscribe订阅消息
bool subscribe(int channel);
//向redis指定的通道unsubscribe取消订阅消息
bool unsubscribe(int channel);
//在独立线程中接收订阅通道中的消息
void observer_channel_message();
//初始化向业务层上报通道消息的回调对象
void init_notify_handler(function<void(int, string)> fn);
private:
//hiredis同步上下文对象,负责publish消息,相当于客户端一个redis-client
redisContext *_publish_context;
//hiredis同步上下文对象,负责subscribe消息,相当于客户端一个redis-client ,
// _publish和_subcribe不能在一个上下文处理 ,会阻塞
redisContext *_subcribe_context;
//回调操作,收到订阅的消息,给service层上报
function<void(int, string)> _notify_message_handler;
};
#endif
我们完善一下项目工程chatserver下的CMakeLists.txt
我们在src下的server下创建文件夹:redis
在src下的server下的redis下创建文件:redis.cpp
#include "redis.hpp"
#include <iostream>
using namespace std;
Redis::Redis()
: _publish_context(nullptr), _subcribe_context(nullptr)//两个上下文指针
{
}
Redis::~Redis()
{
if (_publish_context != nullptr)
{
redisFree(_publish_context);
}
if (_subcribe_context != nullptr)
{
redisFree(_subcribe_context);
}
}
bool Redis::connect()
{
//负责publish发布消息的上下文连接
_publish_context = redisConnect("127.0.0.1", 6379);
if (nullptr == _publish_context)
{
cerr << "connect redis failed!" << endl;
return false;
}
//负责subscribe订阅消息的上下文连接
_subcribe_context = redisConnect("127.0.0.1", 6379);
if (nullptr == _subcribe_context)
{
cerr << "connect redis failed!" << endl;
return false;
}
//在单独的线程中,监听通道上的事件,有消息给业务层进行上报
thread t([&]() {
observer_channel_message();
});
t.detach();
cout << "connect redis-server success!" << endl;
return true;
}
//向redis指定的通道channel发布消息
//redisCommand先把命令缓存在本地,然后把命令发送到redis-server,然后阻塞等待命令的执行结果
bool Redis::publish(int channel, string message)
{
redisReply *reply = (redisReply *)redisCommand(_publish_context, "PUBLISH %d %s", channel, message.c_str());
if (nullptr == reply)
{
cerr << "publish command failed!" << endl;
return false;
}
freeReplyObject(reply);
return true;
}
//向redis指定的通道subscribe订阅消息
bool Redis::subscribe(int channel)
{
//SUBSCRIBE命令本身会造成线程阻塞等待通道里面发生消息,这里只做订阅通道,不接收通道消息
//通道消息的接收专门在observer_channel_message函数中的独立线程中进行
//只负责发送命令,不阻塞接收redis server响应消息,否则和notifyMsg线程抢占响应资源
if (REDIS_ERR == redisAppendCommand(this->_subcribe_context, "SUBSCRIBE %d", channel))
{
cerr << "subscribe command failed!" << endl;
return false;
}
//redisBufferWrite可以循环发送缓冲区,直到缓冲区数据发送完毕(done被置为1)
int done = 0;
while (!done)
{
if (REDIS_ERR == redisBufferWrite(this->_subcribe_context, &done))
{
cerr << "subscribe command failed!" << endl;
return false;
}
}
//redisGetReply
return true;
}
//向redis指定的通道unsubscribe取消订阅消息
bool Redis::unsubscribe(int channel)
{
if (REDIS_ERR == redisAppendCommand(this->_subcribe_context, "UNSUBSCRIBE %d", channel))
{
cerr << "unsubscribe command failed!" << endl;
return false;
}
//redisBufferWrite可以循环发送缓冲区,直到缓冲区数据发送完毕(done被置为1)
int done = 0;
while (!done)
{
if (REDIS_ERR == redisBufferWrite(this->_subcribe_context, &done))
{
cerr << "unsubscribe command failed!" << endl;
return false;
}
}
return true;
}
//在独立线程中接收订阅通道中的消息
void Redis::observer_channel_message()
{
redisReply *reply = nullptr;
while (REDIS_OK == redisGetReply(this->_subcribe_context, (void **)&reply))
{
//订阅收到的消息是一个带三元素的数组
if (reply != nullptr && reply->element[2] != nullptr && reply->element[2]->str != nullptr)
{
//给业务层上报通道上发生的消息
_notify_message_handler(atoi(reply->element[1]->str) , reply->element[2]->str);
}
freeReplyObject(reply);
}
cerr << ">>>>>>>>>>>>> observer_channel_message quit <<<<<<<<<<<<<" << endl;
}
void Redis::init_notify_handler(function<void(int,string)> fn)
{
this->_notify_message_handler = fn;
}
我们完善src下的server下的CMakeLists.txt
redis在项目代码中的添加
我们完善chatservice.hpp
#ifndef CHATSERVICE_H
#define CHATSERVICE_H
#include <muduo/net/TcpConnection.h>
#include <unordered_map>//一个消息ID映射一个事件处理
#include <functional>
#include <mutex>
using namespace std;
using namespace muduo;
using namespace muduo::net;
#include "redis.hpp"
#include "groupmodel.hpp"
#include "usermodel.hpp"
#include "offlinemessagemodel.hpp"
#include "friendmodel.hpp"
#include "json.hpp"
using json = nlohmann::json;
//表示处理消息的事件回调方法类型,事件处理器,派发3个东西
using MsgHandler = std::function<void(const TcpConnectionPtr &conn, json &js, Timestamp)>;
//聊天服务器业务类
class ChatService
{
public:
//获取单例对象的接口函数
static ChatService *instance();
//处理登录业务
void login(const TcpConnectionPtr &conn, json &js, Timestamp time);
//处理注册业务
void reg(const TcpConnectionPtr &conn, json &js, Timestamp time);
//一对一聊天业务
void oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
//添加好友业务
void addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time);
//创建群组业务
void createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
//加入群组业务
void addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
//群组聊天业务
void groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
//处理注销业务
void loginout(const TcpConnectionPtr &conn, json &js, Timestamp time);
//处理客户端异常退出
void clientCloseException(const TcpConnectionPtr &conn);
//服务器异常,业务重置方法
void reset();
//获取消息对应的处理器
MsgHandler getHandler(int msgid);
//从redis消息队列中获取订阅的消息
void handleRedisSubscribeMessage(int, string);
private:
ChatService();//单例
//存储消息id和其对应的业务处理方法,消息处理器的一个表,写消息id对应的处理操作
unordered_map<int, MsgHandler> _msgHandlerMap;
//存储在线用户的通信连接,用户的id, TcpConnectionPtr
unordered_map<int, TcpConnectionPtr> _userConnMap;
//定义互斥锁,保证_userConnMap的线程安全
mutex _connMutex;
//数据操作类对象
UserModel _userModel;
OfflineMsgModel _offlineMsgModel;
FriendModel _friendModel;
GroupModel _groupModel;
//redis操作对象
Redis _redis;
};
#endif
我们完善chatservice.cpp
#include "chatservice.hpp"
#include "public.hpp"
#include <muduo/base/Logging.h>//muduo的日志
#include <vector>
using namespace std;
using namespace muduo;
//获取单例对象的接口函数
ChatService *ChatService::instance()
{
static ChatService service;
return &service;
}
//构造方法,注册消息以及对应的Handler回调操作
ChatService::ChatService()
{
//用户基本业务管理相关事件处理回调注册
_msgHandlerMap.insert({LOGIN_MSG, std::bind(&ChatService::login, this, _1, _2, _3)});
_msgHandlerMap.insert({LOGINOUT_MSG, std::bind(&ChatService::loginout, this, _1, _2, _3)});
_msgHandlerMap.insert({REG_MSG, std::bind(&ChatService::reg, this, _1, _2, _3)});
_msgHandlerMap.insert({ONE_CHAT_MSG, std::bind(&ChatService::oneChat, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_FRIEND_MSG, std::bind(&ChatService::addFriend, this, _1, _2, _3)});
//群组业务管理相关事件处理回调注册
_msgHandlerMap.insert({CREATE_GROUP_MSG, std::bind(&ChatService::createGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_GROUP_MSG, std::bind(&ChatService::addGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({GROUP_CHAT_MSG, std::bind(&ChatService::groupChat, this, _1, _2, _3)});
//连接redis服务器
if (_redis.connect())
{
//设置上报消息的回调
_redis.init_notify_handler(std::bind(&ChatService::handleRedisSubscribeMessage, this, _1, _2));
}
}
//服务器异常,业务重置方法
void ChatService::reset()
{
//把online状态的用户,设置成offline
_userModel.resetState();
}
//获取消息对应的处理器
MsgHandler ChatService::getHandler(int msgid)
{
//记录错误日志,msgid没有对应的事件处理回调
auto it = _msgHandlerMap.find(msgid);
if (it == _msgHandlerMap.end())//找不到
{
//返回一个默认的处理器,空操作,=按值获取
return [=](const TcpConnectionPtr &conn, json &js, Timestamp) {
LOG_ERROR << "msgid:" << msgid << " can not find handler!";//muduo日志会自动输出endl
};
}
else//成功的话
{
return _msgHandlerMap[msgid];//返回这个处理器
}
}
//处理登录业务 id pwd 检测pwd
void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int id = js["id"].get<int>();//获取id号
string pwd = js["password"];//获取密码
User user = _userModel.query(id);//查找
if (user.getId() == id && user.getPwd() == pwd)//查出来了,登录成功
{
if (user.getState() == "online")
//该用户已经登录,不允许重复登录
{
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 2;
response["errmsg"] = "this account is using, input another!";
conn->send(response.dump());
}
else
{
//登录成功,记录用户连接信息,要考虑线程安全,因为多线程访问
{
lock_guard<mutex> lock(_connMutex);
_userConnMap.insert({id, conn});
}//加个作用域,出了这个右括号就自动解锁
//id用户登录成功后,向redis订阅channel(id)
_redis.subscribe(id);
//登录成功,更新用户状态信息 state offline=>online
user.setState("online");
_userModel.updateState(user);
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
response["name"] = user.getName();
//查询该用户是否有离线消息
vector<string> vec = _offlineMsgModel.query(id);//查当用户id
if (!vec.empty())//不为空
{
response["offlinemsg"] = vec;//json库可以和容器之间序列化和反序列化
//读取该用户的离线消息后,把该用户的所有离线消息删除掉
_offlineMsgModel.remove(id);
}
//查询该用户的好友信息并返回
vector<User> userVec = _friendModel.query(id);
if (!userVec.empty())
{
vector<string> vec2;
for (User &user : userVec)
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
vec2.push_back(js.dump());
}
response["friends"] = vec2;
}
//查询用户的群组信息
vector<Group> groupuserVec = _groupModel.queryGroups(id);
if (!groupuserVec.empty())
{
//group:[{groupid:[xxx, xxx, xxx, xxx]}]
vector<string> groupV;
for (Group &group : groupuserVec)
{
json grpjson;
grpjson["id"] = group.getId();
grpjson["groupname"] = group.getName();
grpjson["groupdesc"] = group.getDesc();
vector<string> userV;
for (GroupUser &user : group.getUsers())
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
js["role"] = user.getRole();
userV.push_back(js.dump());
}
grpjson["users"] = userV;
groupV.push_back(grpjson.dump());
}
response["groups"] = groupV;
}
conn->send(response.dump());
}
}
else
{
//该用户不存在,用户存在但是密码错误,登录失败
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 1;
response["errmsg"] = "id or password is invalid!";
conn->send(response.dump());
}
}
//处理注册业务 name password
void ChatService::reg(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
string name = js["name"];//获取名字
string pwd = js["password"];//获取密码
User user;//创建用户对象
user.setName(name);
user.setPwd(pwd);
bool state = _userModel.insert(user);//新用户的插入
if (state)//插入成功
{
//注册成功
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
conn->send(response.dump());//回调 ,返回json字符串
}
else//插入失败
{
//注册失败
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 1;
conn->send(response.dump());//回调 ,返回json字符串
}
}
//处理注销业务
void ChatService::loginout(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(userid);
if (it != _userConnMap.end())
{
_userConnMap.erase(it);
}
}
//用户注销,相当于就是下线,在redis中取消订阅通道
_redis.unsubscribe(userid);
//更新用户的状态信息
User user(userid, "", "", "offline");
_userModel.updateState(user);
}
//处理客户端异常退出
void ChatService::clientCloseException(const TcpConnectionPtr &conn)
{
User user;
{
lock_guard<mutex> lock(_connMutex);
for (auto it = _userConnMap.begin(); it != _userConnMap.end(); ++it)//用迭代器
{
if (it->second == conn)
{
//从map表删除用户的链接信息
user.setId(it->first);
_userConnMap.erase(it);
break;
}
}
}
//用户注销,相当于就是下线,在redis中取消订阅通道
_redis.unsubscribe(user.getId());
//更新用户的状态信息
if (user.getId() != -1)
{
user.setState("offline");
_userModel.updateState(user);
}
}
//一对一聊天业务
void ChatService::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int toid = js["toid"].get<int>();//获取对方的id号
{
lock_guard<mutex> lock(_connMutex);//访问连接信息表,要保证线程安全
auto it = _userConnMap.find(toid);//查找对方id号
if (it != _userConnMap.end())//找到了
{
//toid在线,转发消息 服务器主动推送消息给toid用户
it->second->send(js.dump());
return;
}
}
//查询toid是否在线
User user = _userModel.query(toid);
if (user.getState() == "online")
{
_redis.publish(toid, js.dump());
return;
}
//toid不在线,存储离线消息
_offlineMsgModel.insert(toid, js.dump());
}
//添加好友业务 格式: msgid id friendid
void ChatService::addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();//当前用户的id
int friendid = js["friendid"].get<int>();//添加好友的id
//存储好友信息
_friendModel.insert(userid, friendid);
}
//创建群组业务
void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();//创建群的用户的id
string name = js["groupname"];
string desc = js["groupdesc"];
//存储新创建的群组信息
Group group(-1, name, desc);
if (_groupModel.createGroup(group))
{
//存储群组创建人信息
_groupModel.addGroup(userid, group.getId(), "creator");
}
}
//加入群组业务
void ChatService::addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
_groupModel.addGroup(userid, groupid, "normal");
}
//群组聊天业务
void ChatService::groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
vector<int> useridVec = _groupModel.queryGroupUsers(userid, groupid);//查询这个用户所在群组的其他用户id
lock_guard<mutex> lock(_connMutex);//不允许其他人在map里面增删改查
for (int id : useridVec)
{
auto it = _userConnMap.find(id);
if (it != _userConnMap.end())//证明在线,直接转发
{
//转发群消息
it->second->send(js.dump());
}
else
{
//查询toid是否在线
User user = _userModel.query(id);
if (user.getState() == "online")
{
_redis.publish(id, js.dump());
}
else
{
//存储离线群消息
_offlineMsgModel.insert(id, js.dump());
}
}
}
}
//从redis消息队列中获取订阅的消息
void ChatService::handleRedisSubscribeMessage(int userid, string msg)
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(userid);
if (it != _userConnMap.end())
{
it->second->send(msg);
return;
}
//存储该用户的离线消息
_offlineMsgModel.insert(userid, msg);
}
编译成功
测试
我们启动2个服务器
我们再打开1个客户端,分别登录linzeyu
我们再打开一个终端,登录zhangsan
测试成功!!!