业务模块代码ChatService

本项目没有将业务模块和网络模块写在一起，而是把网络模块收到的消息派发到业务模块，实现了网络模块和业务模块的完全解耦。

当有新的业务需要添加时，只需要改变业务模块的代码，网络模块的代码是不受影响的。

chatservice.hpp

我们在include下的server创建头文件chatservice.hpp：

#ifndef CHATSERVICE_H
#define CHATSERVICE_H

#include "friendmodel.hpp"
#include "groupmodel.hpp"
#include "json.hpp"
#include "offlinemessagemodel.hpp"
#include "redis.hpp"
#include "usermodel.hpp"
#include <functional>
#include <muduo/net/TcpConnection.h>
#include <mutex>
#include <unordered_map>

using namespace muduo;
using namespace muduo::net;

using json = nlohmann::json;
//事件处理器
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 clientCloseException(const TcpConnectionPtr &conn);
    //服务器异常，业务重置方法
    void reset();
    //创建群组业务
    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);
    //获取消息对应的处理器
    MsgHandler getHandler(int msgid);
    //从redis消息队列获取订阅的消息
    void handleRedisSubscribeMessage(int, string);

private:
    ChatService();

    //存储消息id和其对应的业务处理方法
    std::unordered_map<int, MsgHandler> _msgHandlerMap;
    //存储在线用户的通信连接，<用户的id， TcpConnectionPtr>
    std::unordered_map<int, TcpConnectionPtr> _userConnMap;
    //定义互斥锁，保证_userConnMap的线程安全
    std::mutex _connMutex;

    //操作user表的对象
    UserModel _userModel;
    //操作offlinemessage表的对象
    OfflineMsgModel _offlineMsgModel;
    //操作friend表的对象
    FriendModel _friendModel;
    //操作group的对象
    GroupModel _groupModel;

    //操作redis的对象
    Redis _redis;
};

#endif

chatservice.cpp

我们在src的server下创建一个文件chatservice.cpp：

#include "chatservice.hpp"
#include "public.hpp"
#include <muduo/base/Logging.h>
#include <vector>

using namespace muduo;

//获取单例对象
ChatService *ChatService::instance()
{
    static ChatService service;
    return &service;
}

//构造函数
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();
}

//处理客户端的异常退出
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)
            {
                user.setId(it->first);  //记录要删除的连接的id，方便更改用户user的状态
                _userConnMap.erase(it); //从map表删除用户的链接信息
                break;
            }
        }
    }

    //用户异常退出，相当于就是下线，在redis中取消订阅通道
    _redis.unsubscribe(user.getId());

    //更新用户user的状态信息
    if (user.getId() != -1)
    {
        user.setState("offline");
        _userModel.updateState(user);
    }
}

//获取消息对应的处理器
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";
        };
    }
    else //找到了
    {
        return _msgHandlerMap[msgid]; //返回这个处理器
    }
}

//添加好友业务 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); //将用户id和好友id的对应关系插入到friend表中
}

//处理登陆业务的方法 msigd id  pwd
void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
    int id = js["id"].get<int>();
    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["error"] = 2;
            response["errmsg"] = "this account is using, input another!";
            conn->send(response.dump()); //将序列化后的response发送给用户
        }
        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["error"] = 0;
            response["id"] = user.getId();
            response["name"] = user.getName();

            //处理用户的离线消息
            vector<string> vec = _offlineMsgModel.query(id); //查询该用户是否有离线消息
            if (!vec.empty())
            {
                response["offlinemsg"] = vec; //将离线消息加入到回复消息中
                _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())
            {
                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()); //将序列化后的response发送给用户
        }
    }
    else
    {
        json response;
        response["msgid"] = LOGIN_MSG_ACK;
        response["error"] = 1;
        response["errmsg"] = "id or password is invalid";
        conn->send(response.dump()); //将序列化后的response发送给用户
    }
}

//处理注册业务的方法 msgid name  password
void ChatService::reg(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
    string name = js["name"];    //获取名字
    string pwd = js["password"]; //获取密码

    User user; //创建user表对象
    user.setName(name);
    user.setPwd(pwd);
    bool state = _userModel.insert(user);
    if (state) //注册成功
    {
        json response;
        response["msigd"] = REG_MSG_ACK;
        response["error"] = 0;
        response["id"] = user.getId();
        conn->send(response.dump()); //将response序列化成为一个字符串，发送给客户端
    }
    else //注册失败
    {
        json response;
        response["msgid"] = REG_MSG_ACK;
        response["error"] = 1;
        conn->send(response.dump()); //将response序列化成为一个字符串，发送给客户端
    }
}

//处理用户注销业务 msgid id
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);
}

//一对一聊天业务 msgid id from toid msg
void ChatService::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
    int toid = js["toid"].get<int>(); //获取对方的id号

    //查询toid是否注册在本机
    {
        lock_guard<mutex> lock(_connMutex); //访问连接信息表，要保证线程安全
        auto it = _userConnMap.find(toid);  //查找对方id号
        if (it != _userConnMap.end())       //找到了
        {
            it->second->send(js.dump());
            return;
        }
    }

    //如果toid不注册在本机，则查询toid是否在线
    User user = _userModel.query(toid);
    if (user.getState() == "online")
    {
        _redis.publish(toid, js.dump());
        return;
    }

    //toid不在线，存储离线消息
    _offlineMsgModel.insert(toid, js.dump());
}

//创建群组业务msgid id groupname groupdesc
void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
    int userid = js["id"].get<int>();
    string name = js["groupname"];
    string desc = js["groupdesc"];

    //存储新创建的群组信息
    Group group(-1, name, desc);
    if (_groupModel.createGroup(group))
    {
        //存储群组创建人信息
        _groupModel.addGroup(userid, group.getId(), "creator");
    }
}

//加入群组业务 msgid id groupid
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");
}

//群组聊天业务 msgid id groupid msg
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);

    lock_guard<mutex> lock(_connMutex);
    for (int id : useridVec)
    {
        //查询toid是否注册在本机
        auto it = _userConnMap.find(id);
        if (it != _userConnMap.end()) //群组用户在线
        {
            it->second->send(js.dump());
        }
        //toid未注册在本机
        else
        {
            User user = _userModel.query(id);
            if (user.getState() == "online") //toid登陆在了其他服务器
            {
                _redis.publish(id, js.dump());
            }
            else //toid离线
            {
                _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);
}