394-客户端异常退出业务代码和测试

朴灿烈づ我的快乐病毒、 2022-09-03 10:21 158阅读 0赞

我们要处理一下客户端的异常退出，客户端在没有任何响应的情况下，直接给异常退出了，它在目前的代码下，退出没有合法的json字符串，json请求，而只是网络连接断开了，我们还要修改用户的状态为offline。

## 客户端异常退出业务代码和测试 ##

如果客户端异常退出，它根本就没有发出合法的json消息，而是直接断开连接了。  
**chatserver.cpp**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]  
**所以，在这里，我们专门写一个方法。**

//上报链接相关信息的回调函数
    void ChatServer::onConnection(const TcpConnectionPtr &conn)
    {
        
        //客户端断开链接
        if (!conn->connected())
        {
        
            ChatService::instance()->clientCloseException(conn);//客户端异常关闭 
            conn->shutdown();
        }
    }

**完善好的chatserver.cpp**

#include "chatserver.hpp"
    #include "json.hpp"
    #include "chatservice.hpp"
    
    #include <iostream>
    #include <functional>
    #include <string>
    using namespace std;
    using namespace placeholders;//占位符 
    using json = nlohmann::json;
    
    //初始化聊天服务器对象
    ChatServer::ChatServer(EventLoop *loop,
                           const InetAddress &listenAddr,
                           const string &nameArg)
        : _server(loop, listenAddr, nameArg), _loop(loop)
    {
        
        //注册链接回调
        _server.setConnectionCallback(std::bind(&ChatServer::onConnection, this, _1));//绑定器bind
    
        //注册消息回调
        _server.setMessageCallback(std::bind(&ChatServer::onMessage, this, _1, _2, _3));//绑定器bind 
    
        //设置线程数量4
        _server.setThreadNum(4);
    }
    
    //启动服务
    void ChatServer::start()
    {
        
        _server.start();
    }
    
    //上报链接相关信息的回调函数
    void ChatServer::onConnection(const TcpConnectionPtr &conn)
    {
        
        //客户端断开链接
        if (!conn->connected())
        {
        
            ChatService::instance()->clientCloseException(conn);//客户端异常关闭 
            conn->shutdown();//关闭文件描述符 
        }
    }
    
    //上报读写事件相关信息的回调函数，收到消息了， 
    void ChatServer::onMessage(const TcpConnectionPtr &conn,
                               Buffer *buffer,
                               Timestamp time)
    {
        
        string buf = buffer->retrieveAllAsString();//转成字符串接收
    
        //测试，添加json打印代码
        cout << buf << endl;
    
        //数据的反序列化
        json js = json::parse(buf);
        //达到的目的：完全解耦网络模块的代码和业务模块的代码
        //通过js["msgid"] 获取=》业务handler处理器（在业务模块事先绑定好的）=》conn  js  time传给你 
        auto msgHandler = ChatService::instance()->getHandler(js["msgid"].get<int>());//转成整型 
        //回调消息绑定好的事件处理器，来执行相应的业务处理，一个ID一个操作 
        msgHandler(conn, js, time);
    }

**完善chatservice.hpp**  
新增代码

//处理客户端异常退出
    void clientCloseException(const TcpConnectionPtr &conn);

**完善后的chatserver.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 "usermodel.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 clientCloseException(const TcpConnectionPtr &conn);
        //获取消息对应的处理器
        MsgHandler getHandler(int msgid);
    private:
        ChatService();//单例 
    
        //存储消息id和其对应的业务处理方法，消息处理器的一个表，写消息id对应的处理操作 
        unordered_map<int, MsgHandler> _msgHandlerMap;
        //存储在线用户的通信连接，用户的id， TcpConnectionPtr
        unordered_map<int, TcpConnectionPtr> _userConnMap;
        //定义互斥锁，保证_userConnMap的线程安全
        mutex _connMutex;
        //数据操作类对象
        UserModel _userModel;
    
    };
    
    #endif

**然后我们就是根据用户ID和连接构成的map表，找到用户id，把键值对从map表中删除，然后把该用户的数据库的状态信息从online改为offline。**

//存储在线用户的通信连接
        unordered_map<int, TcpConnectionPtr> _userConnMap;

**我们完善chatservice.cpp**  
新增代码

//处理客户端异常退出
    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);
        }
    }

**完善后的chatservice.cpp**

#include "chatservice.hpp"
    #include "public.hpp"
    #include <muduo/base/Logging.h>//muduo的日志 
    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({
        REG_MSG, std::bind(&ChatService::reg, 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!";//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});
                }//加个作用域，出了这个右括号就自动解锁
                
                //登录成功，更新用户状态信息 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();
                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::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);
        }
    }

**编译成功**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]

## 测试 ##

**我们打开两个终端，启动。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 2]  
**登录成功**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 3]  
**我们打开数据库查看一下用户的状态，变成online了**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 4]  
**然后我在客户端执行异常退出**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 5]  
**我们在数据库查看一下状态**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]: /images/20220829/4f456fa4caf94749aca94d0c6805a256.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]: /images/20220829/e4eed656b0584834914002696c153761.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 2]: /images/20220829/7bf3ee7a17e642f0a367f6828e74ef63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 3]: /images/20220829/a980a1508738410997408b6168b9b4c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 4]: /images/20220829/475d11a75a4f44f9a2ee89742c3b49af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 5]: /images/20220829/00eb14d607ac492a9fb85958811bf021.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 6]: /images/20220829/4d2fa89f5fb64855b8075c8b087f5d79.png