点对点聊天业务代码和测试

我们先在public.hpp中添加一对一聊天消息类型ONE_CHAT_MSG

#ifndef PUBLIC_H
#define PUBLIC_H

// server和client的公共文件
enum EnMsgType
{
    LOGIN_MSG = 1, //登录消息
    LOGIN_MSG_ACK, //登录响应消息
    REG_MSG,       //注册消息
    REG_MSG_ACK,   //注册响应消息
    ONE_CHAT_MSG   //聊天消息
};

#endif

用户用name和password注册成功，服务器返回注册成功的用户id，用户就可以使用id和password登录。当用户之间进行聊天时，我们以如下格式组织消息：

msgid:5                 # 标识消息的类型
id:1                  # 发送者的id
from:"zhang san"        # 发送者的name
to:3                  # 接收者的id
msg:"hello"           # 消息内容

服务器收到发送者的消息后，要先查看找接收者是否在线，如果在线，直接获取接收者对应的connection（所有用户的connection都用_userConnMap保存），如果不在线，存在离线消息表，等接收者上线了，服务器再发送给接收者

1. chatservice.hpp添加oneChat一对一聊天业务方法

//一对一聊天业务
void oneChat(const TcpConnectionPtr &conn, json &js, Timestamp);

2. 在chatService.cpp实现oneChat方法

修改chatservice构造函数

// 在构造函数里面把消息id对应的业务处理方法存放到_msgHandlerMap
ChatService::ChatService(){
    _msgHandlerMap.insert({LOGIN_MSG, std::bind(&ChatService::login, 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)});
}

添加聊天方法ChatService::oneChat

//一对一聊天业务
void ChatService ::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp)
{
    int toid = js["to"].get<int>();

    {
        lock_guard<mutex> lock(_connMutex);
        auto it = _userConnMap.find(toid);
        if (it != _userConnMap.end())
        {
            // toid在线，转发消息，服务器主动推送消息给toid用户
            it->second->send(js.dump());
            return;
        }
    }
    // 接收者不在线，需要存储离线消息
}

ChatService.cpp代码

#include "chatservice.hpp"
#include "public.hpp"

#include <muduo/base/Logging.h>
#include <string>
using namespace std;
using namespace muduo;

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

//注册消息以及对应的回调操作
ChatService ::ChatService()
{
    _msgHandlerMap.insert({LOGIN_MSG, bind(&ChatService::login, this, _1, _2, _3)});
    _msgHandlerMap.insert({REG_MSG, bind(&ChatService::reg, this, _1, _2, _3)});
    _msgHandlerMap.insert({ONE_CHAT_MSG, bind(&ChatService::oneChat, this, _1, _2, _3)});
}

//获取消息对应的处理器
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];
    }
}

//处理登录业务
void ChatService ::login(const TcpConnectionPtr &conn, json &js, Timestamp)
{
    int id = js["id"];
    string pwd = js["password"];

    User user = _userModel.query(id);
    if (user.getId() == id && user.getPwd() == pwd)
    {
        //该用户已经登录，不允许重复登录
        if (user.getState() == "online")
        {
            json responce;
            responce["msgid"] = LOGIN_MSG_ACK;
            responce["errno"] = 2;
            responce["errmsg"] = "该账号已经登录，请重新输入账号";
            conn->send(responce.dump());
        }
        //登陆成功，更新用户状态信息state offline->online
        else
        {
            //登陆成功，记录用户连接信息
            {
                lock_guard<mutex> lock(_connMutex);
                _userConnMap.insert({id, conn});
            }

            user.setState("online");
            _userModel.updateState(user);

            json responce;
            responce["msgid"] = LOGIN_MSG_ACK;
            responce["errno"] = 0;
            responce["id"] = user.getId();
            responce["name"] = user.getName();
            conn->send(responce.dump());
        }
    }
    else
    {
        //该用户不存在或者用户存在但是密码错误，登陆失败
        json responce;
        responce["msgid"] = LOGIN_MSG_ACK;
        responce["errno"] = 1;
        responce["errmsg"] = "用户名或密码错误";
        conn->send(responce.dump());
    }
}
//处理注册业务
void ChatService ::reg(const TcpConnectionPtr &conn, json &js, Timestamp)
{
    string name = js["name"];
    string pwd = js["password"];

    User user;
    user.setName(name);
    user.setPwd(pwd);
    bool state = _userModel.insert(user);

    if (state)
    {
        //注册成功
        json responce;
        responce["msgid"] = REG_MSG_ACK;
        // errno=0响应成功，不为0那肯定还有errmsg说明错误消息
        responce["errno"] = 0;
        responce["id"] = user.getId();
        conn->send(responce.dump());
    }
    else
    {
        //注册失败
        json responce;
        responce["msgid"] = REG_MSG_ACK;
        responce["errno"] = 1;
        conn->send(responce.dump());
    }
}
//处理客户端异常退出
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;
            }
        }
    }
    //更新用户的状态信息
    if (user.getId() != -1)
    {
        user.setState("offline");
        _userModel.updateState(user);
    }
}
//一对一聊天业务
void ChatService ::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp)
{
    int toid = js["to"].get<int>();

    {
        lock_guard<mutex> lock(_connMutex);
        auto it = _userConnMap.find(toid);
        if (it != _userConnMap.end())
        {
            // toid在线，转发消息，服务器主动推送消息给toid用户
            it->second->send(js.dump());
            return;
        }
    }
    // 接收者不在线，需要存储离线消息
}

3. 编译测试

li si注册消息：{"msgid":3,"name":"li si","password":"666666"}

查看数据库，新用户成功注册，我们可以看到li si注册成功，此时zhang san和li si都是离线状态

登录zhang san并查看数据库 再启一个终端，登录li si并查看数据库，此时zhang san和li si都是online在线状态

我们让zhang san给li si发消息：{"msgid":5,"id":27,"from":"zhang san","to":28,"msg":"hello,li si!"}

再让li si给zhang san发消息：{"msgid":5,"id":28,"from":"li si","to":27,"msg":"hello,zhang san!"}