施磊老师基于muduo网络库的集群聊天服务器(一)

技术栈

1. Json序列化和反序列化
2. muduo网络库开发
3. nginx源码编译安装和环境部署
4. nginx的tcp负载均衡器配置
5. redis缓存服务器编程实践
6. 基于发布-订阅的服务器中间件redis消息队列编程实践
7. MySQL数据库编程
8. CMake构建编译环境
9. Github托管项目

项目需求

1. 客户端新用户注册
2. 客户端用户登录
3. 添加好友和添加群组
4. 好友聊天
5. 群组聊天
6. 离线消息
7. nginx配置tcp负载均衡
8. 集群聊天系统支持客户端跨服务器通信

环境安装

muduo网络库安装

具体安装方法: 见老师博客

https://blog.csdn.net/QIANGWEIYUAN/article/details/89023980

编译错误:

以下编译错误, 是由于 Boost 库在头文件中使用了 C 风格的类型转换（(Model*)0），而你的编译器设置了 -Werror=old-style-cast，将所有警告视为错误，导致编译失败。

/root/anaconda3/include/boost/concept/detail/general.hpp: In static member function ‘static void boost::concepts::requirement<Model>::failed()’:
/root/anaconda3/include/boost/concept/detail/general.hpp:35:37: error: use of old-style cast to ‘Model*’ [-Werror=old-style-cast]
   35 |     static void failed() { ((Model*)0)->~Model(); }
      |                                     ^
/root/anaconda3/include/boost/concept/detail/general.hpp: In static member function ‘static void boost::concepts::requirement<boost::concepts::failed************ Model::************>::failed()’:
/root/anaconda3/include/boost/concept/detail/general.hpp:50:37: error: use of old-style cast to ‘Model*’ [-Werror=old-style-cast]
   50 |     static void failed() { ((Model*)0)->~Model(); }
      |                                     ^
/root/anaconda3/include/boost/concept/detail/general.hpp: In static member function ‘static void boost::concepts::constraint<Model>::failed()’:
/root/anaconda3/include/boost/concept/detail/general.hpp:65:37: error: use of old-style cast to ‘Model*’ [-Werror=old-style-cast]
   65 |     static void failed() { ((Model*)0)->constraints(); }
      |                                     ^
In file included from /root/anaconda3/include/boost/concept_check.hpp:31,
                 from /root/anaconda3/include/boost/circular_buffer/base.hpp:22,
                 from /root/anaconda3/include/boost/circular_buffer.hpp:58,
                 from /root/hzhdata/2025-bigproject/1-chat-web/package/muduo/muduo/base/BoundedBlockingQueue.h:12,
                 from /root/hzhdata/2025-bigproject/1-chat-web/package/muduo/muduo/base/AsyncLogging.h:10,
                 from /root/hzhdata/2025-bigproject/1-chat-web/package/muduo/muduo/base/AsyncLogging.cc:6:
/root/anaconda3/include/boost/concept/usage.hpp: In destructor ‘boost::concepts::usage_requirements<Model>::~usage_requirements()’:
/root/anaconda3/include/boost/concept/usage.hpp:20:38: error: use of old-style cast to ‘Model*’ [-Werror=old-style-cast]
   20 |     ~usage_requirements() { ((Model*)0)->~Model(); }
      |                                      ^
cc1plus: all warnings being treated as errors
make[2]: *** [muduo/base/CMakeFiles/muduo_base.dir/build.make:63: muduo/base/CMakeFiles/muduo_base.dir/AsyncLogging.cc.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:196: muduo/base/CMakeFiles/muduo_base.dir/all] Error 2
make: *** [Makefile:141: all] Error 2

解决办法:

修改 CMakeLists.txt

在 CMakeLists.txt 中添加：

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    add_compile_options(-Wno-old-style-cast)  # 忽略该警告
endif()

移动头文件和库文件

install命令并没有把它们拷贝到系统路径下，导致我们每次编译程序都需要指定muduo库的头文件和库文件路径，很麻烦，所以我们选择直接把inlcude（头文件）和lib（库文件）目录下的文件拷贝到系统目录下：

root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11# ls
include  lib
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11# cd include/
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/include# ls
muduo
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/include# mv muduo/ /usr/include/
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/include# cd ..
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11# ls
include  lib
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11# cd lib/
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/lib# ls
libmuduo_base.a  libmuduo_http.a  libmuduo_inspect.a  libmuduo_net.a
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/lib# mv * /usr/local/lib/
root@tony-virtual-machine:/home/tony/package/build/release-install-cpp11/lib# 

拷贝完成以后使用muduo库编写C++网络程序，不用在指定头文件和lib库文件路径信息了，因为g++会自动从/usr/include和/usr/local/lib路径下寻找所需要的文件。

redis和mysql安装

ubuntu的 包安装

sudo apt install mysql-server
sudo apt install redis-server

验证mysql环境

查看 运行中的 服务

netstat -tanp

mysql 默认 3306 端口

tcp        0      0 127.0.0.1:3306          0.0.0.0:*               LISTEN      70276/mysqld 

登录一下 mysql

初次安装-----> 先查看 默认密码

sudo cat /etc/mysql/debian.cnf

然后

mysql -u root -p<密码>

可能的错误:

ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)

这是由于 socket文件路径不正确

临时修改:----> 查看密码时, 就显示了 socket的路径

mysql -u root -p<密码> -S /var/run/mysqld/mysqld.sock

永久修改:

sudo nano /etc/mysql/my.cnf
    
//添加
[client]
socket = /var/run/mysqld/mysqld.sock

修改mysql密码

//进入mysql后
ALTER USER 'root'@'localhost' IDENTIFIED BY '你的新密码';
FLUSH PRIVILEGES;  -- 刷新权限

Nginx–先不安装

先做一个 单机的

Json介绍

为什么需要json?

之所以需要 JSON（JavaScript Object Notation），是因为它是一种非常方便、通用的数据交换格式。简单来说，JSON 是让不同系统或程序之间沟通的一种“通用语言”。

什么是 json 序列化?

一个形象的例子:

常用的数据传输序列化格式?

在网络中，常用的数据传输序列化格式有XML，Json，ProtoBuf，在公司级别的项目中，大量的在使用ProtoBuf作为数据序列化的方式，以其数据压缩编码传输，占用带宽小，同样的数据信息，是Json的1/10，XML的1/20，但是使用起来比Json稍复杂一些，所以项目中我们选择常用的Json格式来打包传输数据。

关于 protobuf , 有另一个项目, rpc 框架

直接使用json第三方库

JSON for Modern C++

优点如下：

• 仅是一个头文件 : json.hpp， 直接 拉入项目 即可
• C++ 11 标准编写
• 使用 json 像使用 STL 容器一样
• STL 和 json 容器之间可以相互转换

直接去 github 下载 json.hpp 文件即可

https://github.com/nlohmann/json/releases/tag/v3.12.0

json序列化代码演示

何为序列化? ----> 数据对象 转化为 json 字符串

主要函数: string str = js.dump(); 这是 转换字符串的 主要 函数

nlohmann::json 默认使用 std::map 存储对象，而 std::map 本身就是自动按 key 排序（字典序）的。

因此 默认 输出 是字典序

using ordered_json = nlohmann::ordered_json; 就可以不排序, 按照插入顺序

头文件:

#include "json.hpp"
using json = nlohmann::json;    // 这个作用域是作者名字, 在 hpp文件就可以看到, 不用记

演示:

#include "json.hpp"
using json = nlohmann::json;

#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std;

// json序列化示例1
void func1()
{
    json js;
    js["msg_type"] = 2;
    js["from"] = "zhangsan";
    js["to"] = "li si";
    js["msg"] = "hello, waht are you doing?";

    cout << js << endl;

    // 转字符串输出
    string sendbuf = js.dump();
    cout << sendbuf.c_str() << endl;   // 网络传送一般都是 char*, string 转一下
}

int main()
{
    func1();

    return 0;
}

输出:

{"from":"zhangsan","msg":"hello, waht are you doing?","msg_type":2,"to":"li si"}
{"from":"zhangsan","msg":"hello, waht are you doing?","msg_type":2,"to":"li si"}

复杂键值对演示

键的值还是键

void func2()
{
    json js;
    // 添加数组
    js["id"] = {1, 2, 3, 4, 5};
    // 添加key-value
    js["name"] = "zhang san";
    // 添加对象
    js["msg"]["zhang san"] = "hello world";
    js["msg"]["liu shuo"] = "hello china";
    // 上面等同于下面这句一次性添加数组对象
    js["msg"] = {{"zhang san", "hello world"}, {"liu shuo", "hello china"}};
    cout << js << endl;
}

输出:

{"id":[1,2,3,4,5],"msg":{"liu shuo":"hello china","zhang san":"hello world"},"name":"zhang san"}

发现: msg是一个键, 其内部还有两个键值对

容器序列化演示

void func3()
{
    json js;
    // 直接序列化一个vector容器
    vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(5);
    js["list"] = vec;
    
    // 直接序列化一个map容器
    map<int, string> m;
    m.insert({1, "黄山"});
    m.insert({2, "华山"});
    m.insert({3, "泰山"});
    js["path"] = m;

    cout << js << endl;
    
    string sendbuf = js.dump();
    cout<<sendbuf.c_str()<<endl;
    
}

输出:

{"list":[1,2,5],"path":[[1,"黄山"],[2,"华山"],[3,"泰山"]]}
{"list":[1,2,5],"path":[[1,"黄山"],[2,"华山"],[3,"泰山"]]}

json反序列化演示

json 字符串 ---> 数据对象

主要函数: json jsbuf = json::parse(string); —> 这里的string: js.dump()

会保留 原来的 数据类型!!

将 上面的 函数 返回值 修改为 string, return js.dump()

#include "json.hpp"
using json = nlohmann::json;

#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std;

// json序列化示例1
string func1()
{
    json js;
    js["msg_type"] = 2;
    js["from"] = "zhangsan";
    js["to"] = "li si";
    js["msg"] = "hello, waht are you doing?";

    // cout << js << endl;

    // // 转字符串输出
    // string sendbuf = js.dump();
    // cout << sendbuf.c_str() << endl; // 网络传送一般都是 char*, string 转一下
    return js.dump();
}

int main()
{

    string recvBuf = func1();
    json jsbuf = json::parse(recvBuf);
    cout<<jsbuf["from"]<<endl; 
     cout<<jsbuf["msg_type"]<<endl; 
    cout<<jsbuf["to"]<<endl; 

    return 0;
}

string func2()
{
    json js;
    // 添加数组
    js["id"] = {1, 2, 3, 4, 5};
    // 添加key-value
    js["name"] = "zhang san";
    // 添加对象
    js["msg"]["zhang san"] = "hello world";
    js["msg"]["liu shuo"] = "hello china";
    // 上面等同于下面这句一次性添加数组对象
    js["msg"] = {{"zhang san", "hello world"}, {"liu shuo", "hello china"}};
    // cout << js << endl;
    return js.dump();
}

int main()
{

    //使用 auto 不关注 返回类型, 并且可以存储
    string recvBuf = func2();
    json jsbuf = json::parse(recvBuf);
    auto arr = jsbuf["id"];
    cout<<arr<<endl;   // [1,2,3,4,5]

    return 0;
}

string func3()
{
    json js;
    // 直接序列化一个vector容器
    vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(5);
    js["list"] = vec;

    // 直接序列化一个map容器
    map<int, string> m;
    m.insert({1, "黄山"});
    m.insert({2, "华山"});
    m.insert({3, "泰山"});
    js["path"] = m;

    // cout << js << endl;
    
    // string sendbuf = js.dump();
    // cout<<sendbuf.c_str()<<endl;
    return js.dump();
}

int main()
{

    string recvBuf = func3();
    json jsbuf = json::parse(recvBuf);
    vector<int> vec = jsbuf["list"];
    for(int &v:vec)
    {
        cout<<v<<" ";
    }
    cout<<endl;

    map<int, string> mymap = jsbuf["path"];
    for(auto &p:mymap)
    {
        cout<<p.first<<" "<<p.second<<" ";
    }
    cout<<endl;
    

    return 0;
}

使用总结

序列化: dump

反序列化: json::parse(…);

muduo网络库简介

多看pdf

先学会用

再去看源码, 去手撕

muduo网络库是什么?

Muduo 网络库是一个 用 C++ 编写的高性能网络编程库，它的核心目标是让你能用现代 C++ 编写高并发、高性能的服务器程序，特别适合 Linux 平台上的多线程网络编程。

网络程序 项目 用的最多的第三方库:

1. muduo网络库
2. libevent库(黑马网络编程有)

二者都是基于 多路IO复用的 epool+线程池 网络模型

核心思想

reactors in threads - one loop per thread

每个线程只运行一个 EventLoop，这个 EventLoop 只处理自己负责的连接。

这就叫：One loop per thread（一个线程对应一个事件循环）

这也是高并发的基础

线程数量–> 一般由 cpu核数确定

过多耗费 cpu io 的任务, 会被交给Threadpool 线程池 中, 专门处理耗时 的计算任务, 如下图

补充muduo网络库知识

Muduo 的线程模型概览：

Muduo 网络库一般分为两个主要的线程角色：

1. 主线程（IO线程 / Reactor线程 / EventLoop线程）
2. 工作线程（线程池中的线程 / 业务线程）

主线程（EventLoop 所在线程）

• 每个 EventLoop 对象运行在一个特定线程中，一般称之为 IO 线程。

• 用来监听 IO 事件（如连接、读写事件），并调用对应的回调函数。

• 连接也是 IO 事件的一种，更准确地说是：

  “新连接到来” 是监听 socket（listen fd）上的一种“可读事件（readable event）"。

• 典型用途：

  • 接受新连接（通过 Acceptor）
  • 分发读写事件
  • 执行 Channel 上绑定的回调函数（如 onMessage, onConnection）

特点：

• 一个 EventLoop 不能被多个线程调用（有断言保证）。
• 所有操作必须在它自己的线程中执行，避免加锁。

工作线程（线程池中的线程）

• Muduo 提供了 EventLoopThreadPool，可以配置多个工作线程，每个线程都拥有一个独立的 EventLoop。
• 新连接接入后，主线程通过轮询（round-robin）方式将连接分发给工作线程。
• 工作线程处理与该连接相关的 IO 操作。

为什么这样设计？

• 主线程只负责接入连接和分发，避免在主线程中执行复杂逻辑，保持高响应。
• 工作线程处理数据读写，用户可以在这些线程中执行业务逻辑。
• 这种模式提高了系统的并发处理能力，同时又能保持线程之间的最小同步需求。

线程之间如何通信？

• 主线程和工作线程之间通过**EventLoop::runInLoop() 或 queueInLoop()**机制异步通信。
• 所有跨线程调用最终都在 EventLoop 所在线程中执行，避免数据竞争。

muduo网络库编程

库的搜索路径问题

muduo网络库在使用时, 需要链接 一些动态库文件

lmuduo_net -lmuduo_base -lpthread

g++ main.cpp -o myserver -lmuduo_net -lmuduo_base -lpthread -lrt

如果动态库 在 usr/lib 或者 usr/local/lib 就不需要配置了

如果不在系统路径, 就需要 自己配置了

muduo的便利性

muduo网络库给用户提供了两个主要的类

1. TcpServer：用于编写服务器程序的

2. TcpClient：用于编写客户端程序的

epoll + 线程池

好处：能够把网络I/O的代码和业务代码区分开

业务代码 主要 暴露仅 两个 : 用户的连接和断开用户可读写事件

不需要关心怎么连接, 多少连接, 这些在网络io模块 就完成了

基于muduo的服务器编程

头文件:

#include <muduo/net/TcpServer.h> //服务端
#include <muduo/net/EventLoop.h>

TcpServer 构造函数的参数:

  TcpServer(EventLoop* loop,
            const InetAddress& listenAddr,
            const string& nameArg,
            Option option = kNoReusePort);

在实际使用muduo库 时, 仅需要关注 --------------> 其余的 代码基本是死的, 不用管

1. 连接与断开 的回调函数-----> 下面的 onConnection函数
2. 处理用户 的 读写时间 的回调函数-----> 下面的 onMessage 函数

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

#include <functional> // 内含绑定器 bind

/*基于muduo网络库开发服务器程序
1. 组合TcpServer对象
2. 创建EventLoop事件循环对象的指针
3. 明确TcpServer构造函数需要什么参数, 输出ChatServer的构造函数----需要看源码
4. 在当前服务器类的 构造函数中, 注册 处理连接的 回调函数和 处理读写事件 的回调函数
5. 设置合适的 服务端线程数量, muduo 库会自己划分 i/o线程和 worker线程
*/

class ChatServer
{
public:
    // 构造函数 #3
    ChatServer(EventLoop *loop,               // 时间循环--反应堆
               const InetAddress &listenAddr, // 服务器地址结构--IP+PORT
               const string &nameArg)         // 服务器名字
        : _loop(loop), _server(loop, listenAddr, nameArg)

    {
        // 由于使用了 网络库, 就代表 不需要 自己写网络代码, 只需要关注 业务代码 漏出的 接口

        // 由于不知道什么时候发生, 因此 借助回调函数, 在事件发生后, 去进行回调, 执行回调函数里的代码即可

        // 1. 给服务器注册用户连接的 创建 和 断开 回调 #5
        // void setConnectionCallback(const ConnectionCallback& cb){..}  函数原型
        _server.setConnectionCallback(std::bind(&ChatServer::onConnection, this, _1)); // 传入的就是 回调函数, 而在这个类里, 写的回调函数是 成员方法, 有this指针, 但是只需要第二个传参,  因此使用 绑定器: this固定, const TcpConnectionPtr& 交给 传入者

        // 2. 给服务器注册用户 读写时间回调
        _server.setMessageCallback(std::bind(&ChatServer::onMessage, this, _1, _2, _3));

        // 设置 服务器端的 线程数量
        // 设定为 4, 一个 IO线程, 3个worker线程
        _server.setThreadNum(4); // 如果不加, 默认是一个线程, 既要监听, 还要处理 读写----> 如果设置为 2, 则监听占用一个, 剩下一个, 要处理所有的读写事件,  效率都不高
    };

    // 开启事件循环 #4
    void start()
    {
        _server.start();
    }

private:
    // 专门处理用户的连接与断开  仅处理回调接口即可 #4
    //  经过epoll litsenfd accept, 到达accept 说明有新用户连接了
    /* 然而 网络库 已经封装好 socket相关的了, 仅暴露了 回调接口!!!*/
    void onConnection(const TcpConnectionPtr &conn) // 要学会 从源码 找 类型
    // typedef std::function<void (const TcpConnectionPtr&)> ConnectionCallback;
    {
        if (conn->connected()) // bool值
        {
            cout << conn->peerAddress().toIpPort() << "->" << conn->localAddress().toIpPort() << "  state:online" << endl;
        }
        else
        {
            cout << conn->peerAddress().toIpPort() << "->" << conn->localAddress().toIpPort() << "  state:off" << endl;

            conn->shutdown();   // close(fd)
            // _loop->quit(); //退出整个服务器
        }
    }

    // 专门处理用户的 读写事件
    void onMessage(const TcpConnectionPtr &conn, // 连接
                   Buffer *buffer,               // 缓冲区
                   Timestamp time)               // 时间
    {
        string buf = buffer->retrieveAllAsString();                          // 封装了 把数据 全部放到 字符串中
        cout << "recv data: " << buf << " time:" << time.toString() << endl; // time 也是 封装的, 把时间信息转化为字符串
        conn->send(buf);                                                     // 收到 并处理后返回, 这里测试 使用 原数据返回
    }

    TcpServer _server; // #1
    EventLoop *_loop;  // #2 epoll循环, 可以注册信号,捕捉信号, 时间循环
};

int main()
{
    EventLoop loop;                      // 相当于 创建epoll      muduo::net::EventLoop
    InetAddress addr("127.0.0.1", 6000); //  muduo::net::InetAddress
    ChatServer server(&loop, addr, "ChatServer");

    server.start();  // listenfd --- 使用epoll_ctl 添加到epoll上
    loop.loop(); // epoll_wait 以阻塞方式 等待新用户连接, 已连接用户的读写事件等

    return 0;
}

InetAddress addr("127.0.0.1", 6000);
这行代码创建了一个 InetAddress 对象，代表服务器监听的 IP地址和端口号。

具体解释如下：

“127.0.0.1”：是 本地回环地址（localhost），意味着这个服务器只接受来自本机的连接。如果你希望接受外部机器的连接，可以将其改成 0.0.0.0（表示监听所有网络接口）或者具体的本机IP。

6000：是 端口号，表示服务器将监听这个端口，等待客户端连接。

编译错误问题解决

直接run code 会出现 编译错误:

g++的 ld..... -------> 这是 链接错误, ld 是 link editor 的缩写

解决办法1:

这里就 用到了 库的搜索路径问题

g++ nuduo_server.cpp -o server -lmuduo_net -lmuduo_base -lpthread

-lmuduo_net 必须在前面, 后面的base 用到了 net

解决办法2:

直接设置 vscode

按F1 ----> 搜 c++的json配置文件 ----> c_cpp_properties.json

//一般的 编译命令
gcc -I头文件搜索路径  -L库文件搜索路径 -l库名称

/usr/include    /usr/local/include
//一般是 默认的 头文件搜索路径, 这个就不用加了

//对应的
 /usr/lib    /usr/local/lib

在项目文件页, ctrl+shift+b(build)—>关闭搜狗输入法的 没用的快捷键, 会冲突, 打开 g++ 配置文件 task.json

在编译选项, 添加那几个即可:

"args": [
				"-fdiagnostics-color=always",
				"-g",
				"${file}",
				"-o",
				"${fileDirname}/${fileBasenameNoExtension}",
				"-lmuduo_net",
				"-lmuduo_base",
				"-lpthread"
			],

继续 ctrl+shift+b(build), 进行编译!!!

即可 看到 输出 里包含了 这些库

vscode 三大最重要的 json 文件:

1. c_cpp_properties.json：配置编译器路径和头文件搜索路径，让 VSCode 能正确识别代码（自动补全、跳转定义）。
2. tasks.json：定义一键编译命令（如 g++），按 Ctrl+Shift+B 直接运行，省去手动输命令。
3. launch.json：配置调试器（如 GDB），按 F5 启动调试，可设断点、看变量。

三文件配合，实现 写代码 → 编译 → 调试 全流程自动化！