ChatServer网络模块代码、业务模块代码和网络模块耦合度降级处理

_小菜鸟
83 阅读4分钟

这个项目包含了开发服务器的网络模块、业务模块和数据模块(数据库)。

一、网络模块代码

首先，我们在include下的server下创建头文件：chatserver.hpp

#ifndef CHATSERVER_H
#define CHATSERVER_H

#include <muduo/net/TcpServer.h>
#include <muduo/net/EventLoop.h>
using namespace muduo;
using namespace muduo::net;

//聊天服务器的主类
class ChatServer
{
public:
    //初始化聊天服务器对象
    ChatServer(EventLoop *loop,
               const InetAddress &listenAddr,
               const string &nameArg);

    //启动服务
    void start();

private:
    //上报连接相关信息的回调函数
    void onConnection(const TcpConnectionPtr &);
    //上报读写事件相关信息的回调函数
    void onMessage(const TcpConnectionPtr &,
                   Buffer *,
                   Timestamp);
    TcpServer _server; //组合的muduo库，实现服务器功能的类对象
    EventLoop *_loop; //指向事件循环对象的指针
};

#endif

接下来我们在src下的server下创建文件：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));

    //注册消息回调
    _server.setMessageCallback(std::bind(&ChatServer::onMessage, this, _1, _2, _3));

    //设置线程数量
    _server.setThreadNum(4);
}
void ChatServer::start()
{
    _server.start();
}

void ChatServer::onConnection(const TcpConnectionPtr &conn)
{
    if(conn->connected()){
        cout << conn->peerAddress().toIpPort() << " -> " << conn->localAddress().toIpPort() << "online" << endl;
    }else{ //客户端断开连接
        cout << conn->peerAddress().toIpPort() << " -> " << conn->localAddress().toIpPort() << "offline" << endl;
        conn->shutdown();  // 关闭套接字的写端
        // loop.quit();
    }
}

void ChatServer::onMessage(const TcpConnectionPtr &conn,
                           Buffer *buffer,
                           Timestamp time)
{
    string buf = buffer->retrieveAllAsString();

    cout << "recv data:" << buf << "time:" << time.toString() << endl;
    conn->send(buf);

}

我们在src下的server下创建文件：main.cpp

#include "chatserver.hpp"
#include <iostream>
using namespace std;

int main(){
    EventLoop loop;
    InetAddress addr("127.0.0.1", 6000);
    ChatServer server(&loop, addr, "ChatServer");

    server.start();
    loop.loop();

    return 0;
}

使用工程根目录下的CMakeLists.txt编译 如何把网络模块收到的消息派发到业务模块（服务模块），让网络模块的代码和服务模块的代码完全解耦。

二、业务模块代码

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

#ifndef CHATSERVICE_H
#define CHATSERVICE_H

#include <muduo/net/TcpConnection.h>
#include <unordered_map>
#include<functional>
using namespace std;
using namespace muduo;
using namespace muduo::net;

#include "json.hpp"
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);
    //处理注册业务
    void reg(const TcpConnectionPtr &conn, json &js, Timestamp);
    //获取消息对应的处理器
    MsgHandler getHandler(int msgid);
private:
    ChatService();
    //存储消息id和其对应的业务处理方法
    unordered_map<int, MsgHandler> _msgHandlerMap;
};

#endif

聊天业务对象用于网络层获取相应的回调处理函数，有一个实例就够了，使用单例模式

在src/server下创建一个文件：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)});
}

 //获取消息对应的处理器
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)
{
    LOG_INFO<<"do login service!!!";
}
//处理注册业务
void ChatService :: reg(const TcpConnectionPtr &conn, json &js, Timestamp)
{
    LOG_INFO<<"do reg service!!!";
}

在include下定义一个server和client公共的文件：public.hpp

#ifndef PUBLIC_H
#define PUBLIC_H

//server和client的公共文件
enum EnMsgType
{
    LOGIN_MSG = 1, //登录消息
    REG_MSG //注册消息
};

#endif

三、网络模块耦合度降级处理

src/server下的文件chatserver.cpp，利用oop上回调的思想完全解耦网络模块和业务模块的代码

#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));

    //注册消息回调
    _server.setMessageCallback(std::bind(&ChatServer::onMessage, this, _1, _2, _3));

    //设置线程数量
    _server.setThreadNum(4);
}
void ChatServer::start()
{
    _server.start();
}

void ChatServer::onConnection(const TcpConnectionPtr &conn)
{
    if(conn->connected()){
        cout << conn->peerAddress().toIpPort() << " -> " << conn->localAddress().toIpPort() << "online" << endl;
    }else{ //客户端断开连接
        cout << conn->peerAddress().toIpPort() << " -> " << conn->localAddress().toIpPort() << "offline" << endl;
        conn->shutdown();  // 关闭套接字的写端
        // loop.quit();
    }
}

void ChatServer::onMessage(const TcpConnectionPtr &conn,
                           Buffer *buffer,
                           Timestamp time)
{
    string buf = buffer->retrieveAllAsString();

    //数据的反序列化
    json js = json::parse(buf);
    //json里肯定包含msg_type，要根据什么业务调用什么方法这样不好，会把网络模块的代码和业务模块代码强耦合到一块
    //通过js["msgid"]，实现绑定一个回调操作，即一个id对应一个操作，这样就不用管网络具体做什么业务，
    //只解析到msgid就可以通过msgid获取到一个业务处理器handler,这个处理器就是事先绑定的一个方法，在网络模块是看不见的
   auto msgHandler = ChatService::instance()->getHandler(js["msgid"].get<int>());
   //回调消息对应的绑定好的事件处理器来执行相应的业务处理
   msgHandler(conn,js,time);

}

在onMessage方法中，只有根据msgid获取并调用回调函数的代码，并没有显示调用注册、登录的代码，这样就通过回调函数实现了网络模块和业务模块的解耦。无论业务代码怎么改，网络模块只负责调用，解耦后不需要改动添加头文件搜索路径。

编译并启动ChatServer测试 image.png

在oop语言与要解耦模块之间的关系有两种

  1. 使用基于面向接口的编程，在C++里接口就是抽象基类
  2. 基于回调函数
avatar
文章
阅读
粉丝