1. 基础设施与底层封装#

首先编写通用的工具类，这些类不依赖于网络逻辑，但会被后续所有模块使用。

1.1 Log.hpp (日志模块)#

• 作用：提供统一的日志输出格式（DEBUG, INFO, ERROR 等），方便后续调试。

1
#pragma once
2

3
#include "Mutex.hpp"
4
#include <ctime>
5
#include <filesystem> // c++17 文件系统库
6
#include <fstream>
7
#include <iostream>
8
#include <memory>
9
#include <sstream>
10
#include <string>
11
#include <unistd.h>
12

13
namespace LogModule {
14
    using namespace MutexModule;
15

16
    // --- 默认配置 ---
17
    const std::string defaultpath = "./log/"; // 默认日志文件存放目录
18
    const std::string defaultname = "log.txt";
19

20
    // --- 日志等级定义 ---
21
    enum class LogLevel {
22
        DEBUG,   // 调试信息
23
        INFO,    // 常规信息
24
        WARNING, // 警告信息
25
        ERROR,   // 错误信息
26
        FATAL    // 致命错误
27
    };
28

29
    // 将日志等级枚举转换为可读字符串
30
    std::string LogLevelToString(LogLevel level) {
31
        switch (level) {
32
            case LogLevel::DEBUG:   return "DEBUG";
33
            case LogLevel::INFO:    return "INFO";
34
            case LogLevel::WARNING: return "WARNING";
35
            case LogLevel::ERROR:   return "ERROR";
36
            case LogLevel::FATAL:   return "FATAL";
37
            default:                return "UNKNOWN";
38
        }
39
    }
40

41
    // 获取当前时间的格式化字符串，如“2026-04-08 15:30:45”
42
    // 使用 localtime_r 保证线程安全
43
    std::string GetCurrTime() {
44
        time_t tm = time(nullptr);
45
        struct tm curr; // tm 为 <time.h> 定义的一个结构体类型
46
        localtime_r(&tm, &curr);
47

48
        char timebuffer[64];
49
        snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
50
                 curr.tm_year + 1900, curr.tm_mon + 1, curr.tm_mday,
51
                 curr.tm_hour, curr.tm_min, curr.tm_sec);
52
        return timebuffer;
53
    }
54

55
    // --- 策略模式：抽象基类 ---
56
    // 定义日志输出策略的统一接口
57
    class LogStrategy {
58
    public:
59
        virtual void SyncLog(const std::string &message) = 0;
60
        virtual ~LogStrategy() = default;
61
    };
62

63
    // --- 控制台输出策略 ---
64
    // 将日志输出到标准错误流（stderr）
65
    class ConsoleLogStrategy : public LogStrategy {
66
    public:
67
        void SyncLog(const std::string &message) override {
68
            LockGuard lockguard(_mutex);
69
            std::cerr << message << std::endl;
70
        }
71
        ~ConsoleLogStrategy() {}
72

73
    private:
74
        Mutex _mutex; // 保护 cerr 共享资源
75
    };
76

77
    // --- 文件输出策略 ---
78
    // 将日志追加到指定路径的文件中
79
    class FileLogStrategy : public LogStrategy {
80
    public:
81
        FileLogStrategy(const std::string logpath = defaultpath, std::string logfilename = defaultname)
82
            : _logpath(logpath), _logfilename(logfilename) {

1.2 InetAddr.hpp (地址类封装)#

• 作用：封装 struct sockaddr_in，将 IP 和端口号转化成更方便操作的对象。

1
#pragma once
2

3
#include "Common.hpp"
4

5
// 网络地址和主机地址之间进行转换的类
6
class InetAddr
7
{
8
public:
9
    InetAddr() {}
10

11
    InetAddr(struct sockaddr_in &addr)
12
    {
13
        SetAddr(addr);
14
    }
15

16
    InetAddr(const std::string &ip, uint16_t port)
17
        : _ip(ip), _port(port)
18
    {
19
        // 主机转网络
20
        memset(&_addr, 0, sizeof(_addr));
21
        _addr.sin_family = AF_INET;
22
        inet_pton(AF_INET, _ip.c_str(), &_addr.sin_addr);
23
        _addr.sin_port = htons(_port);
24
        // local.sin_addr.s_addr = inet_addr(_ip.c_str()); // TODO
25
    }
26

27
    InetAddr(uint16_t port)
28
        : _port(port), _ip()
29
    {
30
        // 主机转网络
31
        memset(&_addr, 0, sizeof(_addr));
32
        _addr.sin_family = AF_INET;
33
        _addr.sin_addr.s_addr = INADDR_ANY;
34
        _addr.sin_port = htons(_port);
35
    }
36

37
    void SetAddr(struct sockaddr_in &addr)
38
    {
39
        _addr = addr;
40
        // 网络转主机
41
        _port = ntohs(_addr.sin_port); // 从网络中拿到的！网络序列
42
        // _ip = inet_ntoa(_addr.sin_addr); // 4字节网络风格的IP -> 点分十进制的字符串风格的IP
43

44
        char ipbuffer[64];
45
        inet_ntop(AF_INET, &_addr.sin_addr, ipbuffer, sizeof(_addr));
46
        _ip = ipbuffer;
47
    }
48

49
    uint16_t Port() { return _port; }
50

51
    std::string Ip() { return _ip; }
52

53
    const struct sockaddr_in &NetAddr() { return _addr; }
54

55
    const struct sockaddr *NetAddrPtr()
56
    {
57
        return CONV(_addr);
58
    }
59

60
    socklen_t NetAddrLen()
61
    {
62
        return sizeof(_addr);
63
    }
64

65
    bool operator==(const InetAddr &addr)
66
    {
67
        return addr._ip == _ip && addr._port == _port;
68
    }
69

70
    std::string StringAddr()
71
    {
72
        return _ip + ":" + std::to_string(_port);
73
    }
74

75
    ~InetAddr()
76
    {
77
    }
78

79
private:
80
    struct sockaddr_in _addr;
81
    std::string _ip;
82
    uint16_t _port;
83
};

1.3 Socket.hpp (套接字封装)#

• 作用：利用模版方法模式或虚函数，封装 socket, bind, listen, accept, connect 等系统调用。 • 核心：实现一个 TcpSocket类，隐藏繁琐的底层参数设置。

1
#pragma once
2

3
#include "Common.hpp"
4
#include "InetAddr.hpp"
5
#include "Log.hpp"
6
#include <arpa/inet.h>
7
#include <cstdlib>
8
#include <iostream>
9
#include <memory>
10
#include <netinet/in.h>
11
#include <string>
12
#include <sys/socket.h>
13
#include <sys/types.h>
14
#include <unistd.h>
15

16
namespace SocketModule {
17
    using namespace LogModule;
18

19
    const static int gbacklog = 16;  // 全局默认监听队列长度
20
    const static int defaultfd = -1; // 默认无效文件描述符
21

22
    // --- 抽象基类：定义 Socket 操作的接口和模板流程 ---
23
    class Socket {
24
    public:
25
        virtual ~Socket() {};
26

27
        // 纯虚函数：留给子类（Tcp/Udp）去实现具体的系统调用
28
        virtual void SocketOrDie() = 0;                                       // 创建套接字
29
        virtual void BindOrDie(uint16_t port) = 0;                            // 绑定端口
30
        virtual void ListenOrDie(int backlog) = 0;                            // 进入监听状态
31
        virtual std::shared_ptr<Socket> Accept(InetAddr *client) = 0;         // 接收新连接
32
        virtual void Close() = 0;                                             // 关闭文件描述符
33
        virtual int Recv(std::string *out) = 0;                               // 读取数据
34
        virtual int Send(const std::string &message) = 0;                     // 发送数据
35
        virtual int Connect(const std::string &server_ip, uint16_t port) = 0; // 连接
36

37
    public:
38
        // 模板方法：构建 TCP 服务器的固定步骤
39
        // 1.创建 2.绑定 3.监听
40
        void BuildTcpSocketMethod(uint16_t port, int backlog = gbacklog) {
41
            SocketOrDie();
42
            BindOrDie(port);
43
            ListenOrDie(backlog);
44
        }
45

46
        // 构建 TCP 客户端固定步骤
47
        void BuildTcpClientSocketMethod() {
48
            SocketOrDie(); // 客户端只需创建套接字，绑定由 OS 自动完成
49
        }
50
    };
51

52
    // --- 派生类：基于 TCP 协议的具体实现 ---
53
    class TcpSocket : public Socket {
54
    public:
55
        // 默认构造
56
        TcpSocket() : _sockfd(defaultfd) {
57
        }
58

59
        // 带参构造
60
        TcpSocket(int fd) : _sockfd(fd) {
61
        }
62

63
        ~TcpSocket() {
64
        }
65

66
        // 创建流式套接字（AF_INET + SOCK_STREAM, 0）
67
        void SocketOrDie() override {
68
            _sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
69
            if (_sockfd < 0) {
70
                LOG(LogLevel::FATAL) << "socket error";
71
                exit(SOCKET_ERR);
72
            }
73
            LOG(LogLevel::INFO) << "socket success,fd: " << _sockfd;
74
        }
75

76
        // 绑定本地地址和端口
77
        void BindOrDie(uint16_t port) override {
78
            InetAddr localaddr(port); // 使用 InetAddr 辅助类处理 sockaddr_in
79
            int n = ::bind(_sockfd, localaddr.NetAddrPtr(), localaddr.NetAddrLen());
80
            if (n < 0) {
81
                LOG(LogLevel::FATAL) << "bind error";
82
                exit(BIND_ERR);
83
            }
84
            LOG(LogLevel::INFO) << "bind success";
85
        }
86

87
        // 开始监听连接请求
88
        void ListenOrDie(int backlog) override {
89
            int n = ::listen(_sockfd, backlog);
90
            if (n < 0) {
91
                LOG(LogLevel::FATAL) << "listen error";
92
                exit(LISTEN_ERR);
93
            }
94
            LOG(LogLevel::INFO) << "listen success";
95
        }
96

97
        // 阻塞获取新连接，并将其封装成新的 TcpSocket 对象返回
98
        std::shared_ptr<Socket> Accept(InetAddr *client) override {
99
            struct sockaddr_in peer;
100
            socklen_t len = sizeof(peer);
101
            int fd = ::accept(_sockfd, (struct sockaddr *)&peer, &len);
102
            if (fd < 0) {
103
                LOG(LogLevel::WARNING) << "accept warning ...";
104
                return nullptr;
105
            }
106
            client->SetAddr(peer); // 填入客户端的 IP 和端口信息
107

108
            // 返回共享指针，自动管理生命周期，防止文件描述符泄露
109
            return std::make_shared<TcpSocket>(fd);
110
        }
111

112
        // 接收数据（字节流读取）
113
        int Recv(std::string *out) override {
114
            char buffer[1024];
115
            ssize_t n = ::recv(_sockfd, buffer, sizeof(buffer) - 1, 0);
116
            if (n > 0) {
117
                buffer[n] = 0;
118
                *out += buffer;
119
            }
120
            return n;
121
        }
122

123
        // 发送数据
124
        int Send(const std::string &message) override {
125
            return ::send(_sockfd, message.c_str(), message.size(), 0);
126
        }
127

128
        void Close() override {
129
            if (_sockfd >= 0) {
130
                ::close(_sockfd);
131
                _sockfd = defaultfd;
132
            }
133
        }
134

135
        // 客户端连接服务器
136
        int Connect(const std::string &server_ip, uint16_t port) override {
137
            InetAddr server(server_ip, port);
138
            return ::connect(_sockfd, server.NetAddrPtr(), server.NetAddrLen());
139
        }
140

141
    private:
142
        int _sockfd; // 底层文件描述符
143
    };
144
} // namespace SocketModule

抽象基类 `Socket`#

这类定义了所有套接字必须具备的公共接口。

SocketOrDie(): 纯虚函数。用于创建套接字。如果创建失败，程序会记录错误并直接退出（“Or Die” 的含义）。
BindOrDie(uint16_t port): 纯虚函数。将套接字绑定到指定的本地端口。
ListenOrDie(int backlog): 纯虚函数。将套接字设置为监听状态，准备接收连接请求。
Accept(InetAddr *client): 纯虚函数。等待并接受客户端连接。返回一个新的 Socket 对象（通常是 TcpSocket）用于后续通信。
Recv(std::string *out): 纯虚函数。接收对端发送的数据。
Send(const std::string &message): 纯虚函数。向对端发送数据。
Connect(const std::string &server_ip, uint16_t port): 纯虚函数。客户端逻辑，用于连接远程服务器。
Close(): 纯虚函数。关闭文件描述符，释放资源。

模板方法#

BuildTcpSocketMethod(...): 核心模板方法。它通过固定顺序调用 SocketOrDie -> BindOrDie -> ListenOrDie，封装了服务端启动的标准化流程。
BuildTcpClientSocketMethod(): 封装了客户端启动的基本流程（仅创建套接字）。

具体实现类 `TcpSocket`#

这是针对 TCP 协议的具体实现。

构造函数 TcpSocket(int fd): 允许通过现有的文件描述符创建对象。这通常用于 Accept 成功后，为新建立的连接创建专门的通信对象。
SocketOrDie(): 调用系统调用 ::socket(AF_INET, SOCK_STREAM, 0) 创建一个 TCP 流式套接字。
BindOrDie(uint16_t port):
1. 实例化 InetAddr 对象（处理主机转网络序列）。
2. 调用 ::bind 绑定地址，失败则报 FATAL 错误。
ListenOrDie(int backlog): 调用 ::listen。backlog 参数决定了全连接队列的最大长度（即允许多少个请求在未被 accept 的情况下排队）。
Accept(InetAddr *client):
1. 调用系统调用 ::accept。
2. 如果成功，将客户端的 IP 和端口信息填充到 client 对象中。
3. 返回一个包装了新文件描述符的 TcpSocket 智能指针，实现多态。
Recv(std::string *out):
1. 使用 char buffer[1024] 作为缓冲区。
2. 调用 ::recv 读取数据。
3. 将读取到的字符拼接到输出字符串 out 中。
Send(const std::string &message): 调用 ::send 将字符串内容发送出去。
Close(): 检查 _sockfd 是否合法，若合法则调用 ::close 关闭连接。
Connect(...):
1. 根据传入的 IP 和端口构建 InetAddr。
2. 调用 ::connect 发起 TCP 三次握手连接。

2. 应用层协议设计#

这是网络程序最关键的部分，决定了客户端和服务器如何“对话”。

2.1 Protocol.hpp#

1
#pragma once
2

3
#include "Socket.hpp"
4
#include <iostream>
5
#include <string>
6
#include <memory>
7
#include <jsoncpp/json/json.h>
8
#include <functional>
9

10
// 实现一个自定义的网络版本的计算器
11
using namespace SocketModule;
12

13
// =========================================================
14
// 1. 数据模型与序列化层
15
// =========================================================
16

17
// 客户端 -> 服务端的请求载体
18
class Request {
19
public:
20
    Request() {}
21
    Request(int x, int y, char oper) : _x(x), _y(y), _oper(oper) {}
22

23
    // 序列化：将对象数据转为 JSON 字符串
24
    std::string Serialize() {
25
        Json::Value root;
26
        root["x"] = _x;
27
        root["y"] = _y;
28
        root["oper"] = _oper; // 字符会被按 ASCII 码整数存储
29

30
        Json::FastWriter writer;
31
        return writer.write(root);
32
    }
33

34
    // 反序列化：将 JSON 字符串转回对象数据
35
    bool Deserialize(const std::string &in) {
36
        Json::Value root;
37
        Json::Reader reader;
38
        bool ok = reader.parse(in, root);
39
        if (ok) {
40
            _x = root["x"].asInt();
41
            _y = root["y"].asInt();
42
            _oper = (char)root["oper"].asInt();
43
        }
44
        return ok;
45
    }
46

47
    ~Request() {}
48
    int X() { return _x; }
49
    int Y() { return _y; }
50
    char Oper() { return _oper; }
51

52
private:
53
    int _x;
54
    int _y;
55
    char _oper;
56
};
57

58
// 服务端 -> 客户端的响应载体
59
class Response {
60
public:
61
    Response() {}
62
    Response(int result, int code) : _result(result), _code(code) {}
63

64
    // 序列化
65
    std::string Serialize() {
66
        Json::Value root;
67
        root["result"] = _result;
68
        root["code"] = _code;
69

70
        Json::FastWriter writer;
71
        return writer.write(root);
72
    }
73

74
    // 反序列化
75
    bool Deserialize(const std::string &in) {
76
        Json::Value root;
77
        Json::Reader reader;
78
        bool ok = reader.parse(in, root);
79
        if (ok) {
80
            _result = root["result"].asInt();
81
            _code = root["code"].asInt();
82
        }
83
        return ok;
84
    }
85

86
    ~Response() {}
87
    void SetResult(int res) { _result = res; }
88
    void SetCode(int code) { _code = code; }
89
    void ShowResult() {
90
        std::cout << "计算结果是: " << _result << " [状态码: " << _code << "]" << std::endl;
91
    }
92

93
private:
94
    int _result; // 运算结果
95
    int _code;   // 状态码：0表示成功，非0表示异常（如除0错误）
96
};
97

98
// =========================================================
99
// 2. 协议控制层（解决 TCP 粘包问题）
100
// =========================================================
101

102
const std::string sep = "\r\n"; // 报头与报体之间的分隔符
103

104
// 业务逻辑回调类型声明：输入 Request, 返回 Response
105
using func_t = std::function<Response(Request &req)>;
106

107
class Protocol {
108
public:
109
    Protocol() {}
110
    Protocol(func_t func) : _func(func) {}
111

112
    // 【添加报头】封装应用层协议：长度 + \r\n + JSON 串 + \r\n
113
    std::string Encode(const std::string &jsonstr) {
114
        std::string len = std::to_string(jsonstr.size());
115
        return len + sep + jsonstr + sep;
116
    }
117

118
    // 【解析报文】从接收缓冲区中安全提取一个完整的 JSON 字符串
119
    // 解决 TCP 面向字节流带来的“半包”和“粘包”问题
120
    bool Decode(std::string &buffer, std::string *package) {
121
        // 1. 找第一个分隔符，如果找不到，说明长度报头没收全
122
        size_t pos = buffer.find(sep);
123
        if (pos == std::string::npos)
124
            return false;
125

126
        // 2. 提取长度字段
127
        std::string package_len_str = buffer.substr(0, pos);
128
        int package_len_int = std::stoi(package_len_str);
129

130
        // 3. 计算一个完整报文需要的总长度：长度字符数 + 分隔符1 + JSON正文 + 分隔符2
131
        int target_len = package_len_str.size() + package_len_int + 2 * sep.size();
132

133
        // 4. 如果缓冲区数据不够，说明出现了“半包”，等待下次接收
134
        if (buffer.size() < (size_t)target_len)
135
            return false;
136

137
        // 5. 提取 JSON 正文部分
138
        *package = buffer.substr(pos + sep.size(), package_len_int);
139

140
        // 6. 从缓冲区中抹掉已处理的报文
141
        buffer.erase(0, target_len);
142
        return true;
143
    }
144

145
    // 服务端读取流程：读取流 -> 提取包 -> 反序列化 -> 业务计算 -> 序列化 -> 封包 -> 发送
146
    void GetRequest(std::shared_ptr<Socket> &sock, InetAddr &client) {
147
        std::string buffer_queue; // 用户态接收缓冲区
148
        while (true) {
149
            int n = sock->Recv(&buffer_queue); // 追加式读取
150
            if (n > 0) {
151
                std::string json_package;
152
                // 使用 while 处理粘包：一次 Recv 可能包含多个请求
153
                while (Decode(buffer_queue, &json_package)) {
154
                    LOG(LogLevel::DEBUG) << client.StringAddr() << " 请求：" << json_package;
155

156
                    // 1. 反序列化
157
                    Request req;
158
                    if (!req.Deserialize(json_package))
159
                        continue;
160

161
                    // 2. 执行业务回调，得到结果
162
                    Response resp = _func(req);
163

164
                    // 3. 结果序列化并封装报文
165
                    std::string send_str = Encode(resp.Serialize());
166

167
                    // 4. 发送给客户端
168
                    sock->Send(send_str);
169
                }
170
            } else if (n == 0) {
171
                LOG(LogLevel::INFO) << "client: " << client.StringAddr() << " Quit!";
172
                break;
173
            } else {
174
                LOG(LogLevel::WARNING) << "client: " << client.StringAddr() << ", recv error";
175
                break;
176
            }
177
        }
178
    }
179

180
    // 客户端读取流程：读取流 -> 提取包 -> 反序列化得到 Response
181
    bool GetResponse(std::shared_ptr<Socket> &client, std::string &resp_buff, Response *resp) {
182
        while (true) {
183
            int n = client->Recv(&resp_buff);
184
            if (n > 0) {
185
                std::string json_package;
186
                if (Decode(resp_buff, &json_package)) {
187
                    resp->Deserialize(json_package);
188
                    return true;
189
                }
190
                // 如果 Decode 返回 false，说明数据还没收全，继续循环 Recv
191
            } else {
192
                return false;
193
            }
194
        }
195
    }
196

197
    // 客户端发包辅助函数
198
    std::string BuildRequestString(int x, int y, char oper) {
199
        Request req(x, y, oper);
200
        return Encode(req.Serialize());
201
    }
202

203
    ~Protocol() {}
204

205
private:
206
    func_t _func;
207
};

这份代码实现了一个完整的应用层协议栈，它处于 OSI 模型中的应用层和表示层，解决了如何在不稳定的 TCP 字节流上可靠地传输“结构化数据”的问题。

整个模块可以分为三个核心维度：

数据表示层#

通过 Request 和 Response 两个类，将内存中的 C++ 对象（如整数、字符）转换为跨网络的通用格式（JSON）。

Request (请求)：封装了操作数 x, y 和运算符 oper。
Response (响应)：封装了计算结果 result 和状态码 code。状态码至关重要，它能区分“计算成功”与“除 0 错误”等业务异常。
Jsoncpp 的应用：使用 JSON 而不是二进制结构体，是为了更好的兼容性和可读性。即便客户端是用 Python 或 Java 写的，也能通过相同的 JSON 字段与这个 C++ 服务端通信。

协议控制层#

TCP 协议是面向字节流的，它不保证发送方的一个 send 对应接收方的一个 recv。数据可能在传输过程中被拆分（半包）或合并（粘包）。

代码采用**“长度前缀 + 分隔符”** 的方案来划定报文边界：

封装格式："Content-Length" + "\r\n" + "{JSON-Data}" + "\r\n"。
Encode (封包)：在发送前给数据戴上“帽子”（长度）和“尾巴”（分隔符）。
Decode (解包)：
1. 先找第一个 \r\n，确定报文长度。
2. 检查缓冲区剩余长度是否满足这个包的大小。
3. 只有数据完全到齐，才会将包从缓冲区中提取出来处理。
4. erase 操作：处理完一个包后立即将其从缓冲区抹除，这是处理“持续字节流”的标准做法。

业务逻辑层#

Protocol 类并没有把计算逻辑（加减乘除）写死在里面，而是通过 std::function<Response(Request &req)> 接受一个回调函数。

GetRequest (服务端主循环)：
- 它负责从 Socket 读数据到缓冲区。
- 调用 Decode 不断尝试拆包。
- 业务解耦：解析出 Request 后，直接丢给 _func 回调。它不关心你是做加法还是做复杂的科学运算。
- 拿到结果后再经过序列化和封包发回客户端。

5步#

IO 读取：从内核读取字节流。
协议解包：将字节流转化为一个个完整的报文（解决粘包）。
反序列化：将报文转化为业务对象。
业务处理：执行逻辑计算。
逆向封装：序列化 -> 封包 -> IO 发送

音乐

音乐

1. 基础设施与底层封装#

1.1 Log.hpp (日志模块)#

1.2 InetAddr.hpp (地址类封装)#

1.3 Socket.hpp (套接字封装)#

抽象基类 `Socket`#

模板方法#

具体实现类 `TcpSocket`#

2. 应用层协议设计#

2.1 Protocol.hpp#

数据表示层#

协议控制层#

业务逻辑层#

5步#

文章分享

音乐

TCP序列化与反序列化网络计算器

1. 基础设施与底层封装#

1.1 Log.hpp (日志模块)#

1.2 InetAddr.hpp (地址类封装)#

1.3 Socket.hpp (套接字封装)#

抽象基类 Socket#

模板方法#

具体实现类 TcpSocket#

2. 应用层协议设计#

2.1 Protocol.hpp#

数据表示层#

协议控制层#

业务逻辑层#

5步#

文章分享

抽象基类 `Socket`#

具体实现类 `TcpSocket`#