当前位置：首页 > article >正文

【Linux网络编程】第五弹---构建基于UDP的简单聊天室系统：代码结构与功能模块详解

article 2025/1/5 6:45:41

✨个人主页：熬夜学编程的小林

💗系列专栏：【C语言详解】【数据结构详解】【C++详解】【Linux系统编程】【Linux网络编程】

1、UdpServer.hpp

1.1、UdpServer类基本结构

1.2、构造函数

1.3、Start()

2、Route.hpp

2.1、Route类基本结构

2.2、构造析构函数

2.3、Forward()

2.3.1、CheckOnlineUser()

2.3.2、Offline()

2.3.3、ForwardHelper()

3、UdpServerMain.cc

4、UdpClientMain.cc

4.1、主函数

4.2、InitClient()

4.3、RecvMessage()

4.4、SendMessage()

5、补充参考内容

5.1、地址转换函数

5.2、关于 inet_ntoa

6、完整代码

6.1、InetAddr.hpp

6.2、LockGuard.hpp

6.3、Log.hpp

6.4、Makefile

6.5、nocopy

6.6、Route.hpp

6.7、Thread.hpp

6.8、ThreadPool.hpp

6.9、UdpClientMain.cc

6.10、UdpServer.hpp

6.11、UdpServerMain.cc

6.12、Test.c

前面一弹实现了翻译版本的UDP网络通信，此弹实现一个多线程版本聊天室的网络通信(即将消息转发给所以用户)，此处先拷贝第一版本通信的代码，即第三弹的代码！

1、UdpServer.hpp

UdpServer类的启动函数是实现执行聊天室的功能，因此需要加执行函数的成员变量并适当修改构造函数，启动函数！！

1.1、UdpServer类基本结构

UdpServer类基本结构没变，只是添加了一个执行方法！

using server_t = std::function<void(int,const std::string message,InetAddr& who)>;

// UdpServer user("192.1.1.1",8899)
// 一般服务器主要是用来进行网络数据读取和写入的，即IO的
// 服务器 IO逻辑 和 业务逻辑 解耦
class UdpServer : public nocopy
{
public:
    UdpServer(server_t func, uint16_t localport = glocalport);

    void InitServer();

    void Start();

    ~UdpServer();
private:
    int _sockfd;          // 读写都用同一个sockfd，说明：udp是全双工通信的
    uint16_t _localport;  // 端口号
    bool _isrunning;

    server_t _func;       // 执行方法
};

1.2、构造函数

构造函数只需加一个函数对象的初始化！

UdpServer(server_t func, uint16_t localport = glocalport)
    : _func(func), _sockfd(gsockfd), _localport(localport), _isrunning(false)
{
}

1.3、Start()

启动函数原本只是接收并发送消息，现在改为接收消息和执行转发消息的功能！

void Start()
{
    _isrunning = true;
    char message[1024];
    while (_isrunning)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        // 收消息，返回值: 实际收到多少字节
        ssize_t n = recvfrom(_sockfd, message, sizeof(message) - 1, 0, (struct sockaddr *)&peer, &len);
        if (n > 0)
        {
            InetAddr addr(peer);
            message[n] = 0;
            LOG(DEBUG,"[%s]# %s\n",addr.AddrStr().c_str(),message);
            _func(_sockfd,message,addr); // 转发消息
            LOG(DEBUG,"return udpserver\n");
        }
        else
        {
            std::cout << "recvfrom ,error " << std::endl;
        }
    }
}

2、Route.hpp

Route类对转发消息功能的封装！

2.1、Route类基本结构

Route类 成员变量是一个InetAddr类型的vector容器，但是此处为多线程版本，可能造成数据不一致问题，因此需要加锁，内部实现转发消息的函数！

using task_t = std::function<void()>;

class Route
{
public:
    Route();
    // 检查用户是否在 在线列表中
    void CheckOnlineUser(InetAddr& who);
    // for test(移除用户)
    void Offline(InetAddr& who);
    // 转发消息函数具体实现
    void ForwardHelper(int sockfd,const std::string& message,InetAddr who);
    // 转发
    void Forward(int sockfd,const std::string& message,InetAddr& who);
    ~Route();
private:
    std::vector<InetAddr> _online_user; // 用户在线列表
    pthread_mutex_t _mutex;
};

2.2、构造析构函数

Route类的构造函数初始化互斥锁，析构函数释放互斥锁！

Route()
{
    pthread_mutex_init(&_mutex,nullptr);
}

~Route()
{
    pthread_mutex_destroy(&_mutex);
}

2.3、Forward()

转发函数有两大步骤：

1、检查用户是否在在线列表中，在则忽略，不在则添加到 _online_user中

1.1、如果转发的消息为 QUIT 或者 Q 则将用户移除在线列表

2、执行转发消息函数

// 转发
void Forward(int sockfd,const std::string& message,InetAddr& who)
{
    // 1.该用户是否在 在线用户列表中呢？如果在忽略；如果不在，自动添加到_online_user
    CheckOnlineUser(who);

    // 1.1 message == "QUIT" "Q"
    if(message == "QUIT" || message == "Q")
    {
        Offline(who);
    }
    // 2.who一定在_online_user里面
    // ForwardHelper(sockfd,message);
    task_t t = std::bind(&Route::ForwardHelper,this,sockfd,message,who);
    ThreadPool<task_t>::GetInstance()->Equeue(t);
}

2.3.1、CheckOnlineUser()

检查用户是否在在线列表中！

// 检查用户是否在 在线列表中
void CheckOnlineUser(InetAddr& who)
{
    LockGuard lockguard(&_mutex);
    for(auto& user : _online_user)
    {
        // 需要重载
        if(user == who) 
        {
            LOG(DEBUG,"[%s] is exists\n",who.AddrStr().c_str());
            return;
        }
    }
    LOG(DEBUG,"[%s] is not exists,add it\n",who.AddrStr().c_str());
    _online_user.push_back(who);
}

1、用户的比较需要在InetAddr类中实现等于的重载函数！

用户的IP 和端口都相等表示两个用户相等！

bool operator==(const InetAddr& addr)
{
    return (this->_ip == addr._ip && this->_port == addr._port);
}

2、用户的AddrStr()函数也需要实现

AddrStr()函数打印IP和端口，并使用冒号(:)拼接！

std::string AddrStr()
{
    return _ip + ":" + std::to_string(_port);
}

2.3.2、Offline()

移除用户！

注意：vector容器删除成员需要使用迭代器！

void Offline(InetAddr& who)
{
    LockGuard lockguard(&_mutex);
    // 删除需要迭代器
    auto iter = _online_user.begin();
    for(;iter != _online_user.end();iter++)
    {
        if(*iter == who)
        {
            LOG(DEBUG,"[%s] is offline\n",who.AddrStr().c_str());
            _online_user.erase(iter);
            break;
        }
    }
}

2.3.3、ForwardHelper()

转发消息函数具体实现[为了知道是谁发送的消息，此处打印的消息包含IP 和端口]！

// 转发消息函数具体实现
void ForwardHelper(int sockfd,const std::string& message,InetAddr who)
{
    LockGuard lockguard(&_mutex);
    std::string send_message = "[" + who.AddrStr() + "]# " + message;
    
    for(auto& user : _online_user)
    {
        struct sockaddr_in peer = user.Addr();
        // 无IP和端口
        // LOG(DEBUG,"Forward message to %s,message is %s\n",user.AddrStr().c_str(),message.c_str());
        // ::sendto(sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&peer,sizeof(peer));
        LOG(DEBUG,"Forward message to %s,message is %s\n",user.AddrStr().c_str(),send_message.c_str());
        ::sendto(sockfd,send_message.c_str(),send_message.size(),0,(struct sockaddr*)&peer,sizeof(peer));
    }
}

3、UdpServerMain.cc

UdpServerMain.cc 调用服务端的执行函数！！！

// .udp_client local-port
// .udp_client 8888
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << "  server-port" << std::endl;
        exit(0);
    }

    uint16_t port = std::stoi(argv[1]);

    EnableScreen();
    Route messageRoute;

    server_t message_route = std::bind(&Route::Forward, &messageRoute,
            std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

    std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(message_route,port); // C++14标准

    usvr->InitServer();
    usvr->Start();
    return 0;
}

运行结果(可能出现的问题)

因为博主前面进行过测试，可能会出现这样的情况！

运行结果(正常)

此处确实能够进行多个客户端通信，但是收到的消息还是有点乱码(因为此处的客户端是单进程单线程的程序，而服务端是多线程的)，因此需要修改客户端的主函数代码！

4、UdpClientMain.cc

客户端主函数实现成两个线程版本，一个线程用户发消息，一个线程用于收消息！

4.1、主函数

主函数通过命令行参数获取IP和端口，然后创建套接字，再创建两个线程，最后启动并回收线程！！

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << " server-ip server-port" << std::endl;
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    int sockfd = InitClient();

    Thread recver("recver-thread", std::bind(&RecvMessage, sockfd, std::placeholders::_1));
    Thread sender("sender-thread", std::bind(&SendMessage, sockfd, serverip, serverport, std::placeholders::_1));

    recver.Start();
    sender.Start();

    recver.Join();
    sender.Join();

    ::close(sockfd);
    return 0;
}

4.2、InitClient()

创建套接字，创建成功返回文件描述符！

int InitClient()
{
    int sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "create socket eror\n"
                  << std::endl;
        exit(1);
    }
    return sockfd;
}

4.3、RecvMessage()

收消息函数，如果接收消息成功向标准错误流打印结果(以便于后面测试)！

void RecvMessage(int sockfd, const std::string &name)
{
    while (true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        char buffer[1024];
        int n = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
        if (n > 0)
        {
            buffer[n] = 0;
            std::cerr << buffer << std::endl;
        }
        else
        {
            std::cerr << "recvfrom error" << std::endl;
            break;
        }
    }
}

4.4、SendMessage()

向指定网络进程发送消息！

void SendMessage(int sockfd, std::string serverip, uint16_t severport, const std::string &name)
{
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(severport); // 转换重要！！！
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    std::string cli_profix = name + "# "; // sender-thread#
    while (true)
    {
        std::string line;
        std::cout << cli_profix;
        std::getline(std::cin, line);
        // 发消息，你要知道发送给谁
        int n = sendto(sockfd, line.c_str(), line.size(), 0, (struct sockaddr *)&server, sizeof(server));
        if (n <= 0)
            break;
    }
}

5、补充参考内容

5.1、地址转换函数

本节只介绍基于 IPv4 的 socket 网络编程,sockaddr_in 中的成员 struct in_addr sin_addr 表示 32 位的 IP 地址
但是我们通常用点分十进制的字符串表示 IP 地址,以下函数可以在字符串表示和 in_addr 表示之间转换;

字符串转 in_addr 的函数:

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int inet_aton(const char *cp, struct in_addr *inp);

in_addr_t inet_addr(const char *cp);

int inet_pton(int af, const char *src, void *dst);

in_addr 转字符串的函数:

#include <arpa/inet.h>

char *inet_ntoa(struct in_addr in);

const char *inet_ntop(int af, const void *src,char *dst, socklen_t size);

其中 inet_pton 和 inet_ntop 不仅可以转换 IPv4 的 in_addr,还可以转换 IPv6 的 in6_addr,因此函数接口是 void *addrptr。

代码示例:

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main()
{
    struct sockaddr_in addr;
    inet_aton("127.0.0.1",&addr.sin_addr);
    uint32_t* ptr = (uint32_t*)&addr.sin_addr;
    printf("addr: %x\n",*ptr);
    printf("addr_str: %s\n",inet_ntoa(addr.sin_addr));
    return 0;
}