运用自界说协议计划与实现“跨网络盘算器”

一、计划方案

1. 日志模块 (Log.hpp)

日志模块提供了一个简朴的日志记录功能，允许将日志输出到控制台、单个文件或按日志级别分类的文件中。它界说了差别级别的日志（Info, Debug, Warning, Error, Fatal），并允许通过Enable方法切换日志输出方式。
2. 协议模块 (Protocol.hpp)

协议模块界说了请求和响应的数据格式。Request类封装了盘算请求的数据，包罗操作数和操作符。Response类封装了盘算效果和错误代码。这两个类都提供了序列化和反序列化的方法，以便将数据转换为网络传输的格式。
3. 服务器模块 (ServerCal.hpp、Socket.hpp 和 TcpServer.hpp )

服务器模块由ServerCal、Socket.hpp和TcpServer类构成。

• ServerCal类负责处理盘算请求，它界说了一个Calculator方法来执行实际的算术运算，并返回效果和错误代码。
  
• Socket类封装了根本的socket操作，如毗连、读取和写入。
  
• TcpServer类负责网络通讯，它监听指定端口，继续客户端毗连，并利用回调函数来处理吸收到的数据。
  

4. 客户端模块 (ClientCal.cpp)

客户端模块提供了与服务器通讯的能力，ClientCal类利用Socket类来向服务器发送盘算请求，并吸收响应。
客户端程序首先检查下令行参数是否精确，然后创建一个套接字并毗连到服务器。程序将随机生成两个数字和一个操作符，创建一个请求对象，并将其序列化为字符串。然后，程序将这个字符串编码为网络字节流，并通过套接字发送给服务器。吸收到服务器的响应后，程序将其解码并反序列化为响应对象，然后打印出请求和响应的详细信息。这个过程将重复10次，每次请求后程序会停息1秒。最后，程序关闭套接字并退出。
二、日志模块、makefile文件

✅Log.hpp

1. // 预处理指令，确保头文件只被包含一次
2. #pragma once
4. // 引入必要的头文件
5. #include <iostream> // 标准输入输出流
6. #include <time.h>    // 时间函数
7. #include <stdarg.h>  // 可变参数列表
8. #include <sys/types.h> // 文件系统类型
9. #include <sys/stat.h> // 文件状态
10. #include <fcntl.h>   // 文件控制
11. #include <unistd.h>   // UNIX标准函数
12. #include <stdlib.h>   // 标准库
14. // 定义常量SIZE，用于缓冲区大小
15. #define SIZE 1024
17. // 定义日志级别，分别对应不同的日志重要性
18. #define Info 0
19. #define Debug 1
20. #define Warning 2
21. #define Error 3
22. #define Fatal 4
24. // 定义日志输出方式，分别对应控制台输出和文件输出
25. #define Screen 1
26. #define Onefile 2
27. #define Classfile 3
29. // 定义日志文件名
30. #define LogFile "log.txt"
32. // 日志类Log的声明
33. class Log
34. {
35. public:
36.     // 构造函数，初始化日志输出方式为控制台输出，日志路径为当前目录下的log文件夹
37.     Log()
38.     {
39.         printMethod = Screen; // 默认输出方式为控制台输出
40.         path = "./log/";     // 默认日志路径
41.     }
43.     // 设置日志输出方式的函数
44.     void Enable(int method)
45.     {
46.         printMethod = method; // 根据传入的参数设置输出方式
47.     }
49.     // 将日志级别转换为字符串的函数
50.     std::string levelToString(int level)
51.     {
52.         // 使用switch语句根据日志级别返回对应的字符串
53.         switch (level)
54.         {
55.             case Info:
56.                 return "Info";
57.             case Debug:
58.                 return "Debug";
59.             case Warning:
60.                 return "Warning";
61.             case Error:
62.                 return "Error";
63.             case Fatal:
64.                 return "Fatal";
65.             default:
66.                 return "None";
67.         }
68.     }
70.     // 打印日志的函数
71.     void printLog(int level, const std::string &logtxt)
72.     {
73.         // 根据输出方式选择不同的打印方法
74.         switch (printMethod)
75.         {
76.             case Screen:
77.                 std::cout << logtxt << std::endl; // 控制台输出
78.                 break;
79.             case Onefile:
80.                 printOneFile(LogFile, logtxt); // 单文件输出
81.                 break;
82.             case Classfile:
83.                 printClassFile(level, logtxt); // 分类文件输出
84.                 break;
85.             default:
86.                 break;
87.         }
88.     }
90.     // 单文件日志输出的实现
91.     void printOneFile(const std::string &logname, const std::string &logtxt)
92.     {
93.         // 拼接完整的日志文件路径
94.         std::string _logname = path + logname;
95.         // 打开文件，如果失败则直接返回
96.         int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
97.         if (fd < 0)
98.             return;
99.         // 将日志文本写入文件
100.         write(fd, logtxt.c_str(), logtxt.size());
101.         // 关闭文件描述符
102.         close(fd);
103.     }
105.     // 分类文件日志输出的实现
106.     void printClassFile(int level, const std::string &logtxt)
107.     {
108.         // 根据日志级别创建对应的文件名
109.         std::string filename = LogFile;
110.         filename += ".";
111.         filename += levelToString(level);
112.         // 调用单文件输出函数
113.         printOneFile(filename, logtxt);
114.     }
116.     // 析构函数，目前为空
117.     ~Log()
118.     {
119.     }
121.     // 重载函数调用运算符，用于格式化输出日志
122.     void operator()(int level, const char *format, ...)
123.     {
124.         // 获取当前时间
125.         time_t t = time(nullptr);
126.         struct tm *ctime = localtime(&t);
127.         // 格式化时间字符串
128.         char leftbuffer[SIZE];
129.         snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]",
130.                  levelToString(level).c_str(),
131.                  ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
132.                  ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
134.         // 使用可变参数列表进行格式化字符串
135.         va_list s;
136.         va_start(s, format);
137.         char rightbuffer[SIZE];
138.         vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
139.         va_end(s);
141.         // 拼接完整的日志文本
142.         char logtxt[SIZE * 2];
143.         snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);
145.         // 调用打印日志函数
146.         printLog(level, logtxt);
147.     }
149. private:
150.     // 日志输出方式
151.     int printMethod;
152.     // 日志文件路径
153.     std::string path;
154. };
156. // 定义一个Log类的全局对象lg，用于输出日志
157. Log lg;

复制代码

✅makefile

1. .PHONY:all
2. all:servercal clientcal
4. Flag=#-DMySelf=1
5. Lib=-ljsoncpp
7. servercal:ServerCal.cc
8.         g++ -o $@ $^ -std=c++11 $(Lib) $(Flag)
9. clientcal:ClientCal.cc
10.         g++ -o $@ $^ -std=c++11 -g $(Lib) $(Flag)
13. .PHONY:clean
14. clean:
15.         rm -f clientcal servercal

复制代码

三、协议模块（Protocol.hpp）

✅Protocol.hpp

1. #pragma once // 确保头文件在整个程序中只被包含一次
3. #include <iostream> // 包含标准输入输出流
4. #include <string> // 包含字符串类
5. #include <jsoncpp/json/json.h> // 包含JSONCPP库，用于JSON数据的处理
7. // 宏定义，用于序列化和反序列化过程中的数据分隔
8. const std::string blank_space_sep = " "; // 空格分隔符
9. const std::string protocol_sep = "\n"; // 换行符作为协议的分隔符
11. // 序列化函数，将内容字符串包装成网络传输的格式
12. std::string Encode(std::string &content)
13. {
14.     std::string package; // 创建一个字符串用于存储包装后的数据
15.     package = std::to_string(content.size()); // 将内容的长度转换为字符串
16.     package += protocol_sep; // 添加协议分隔符
17.     package += content; // 添加内容本身
18.     package += protocol_sep; // 再次添加协议分隔符，表示数据结束
20.     return package; // 返回包装后的字符串
21. }
23. // 反序列化函数，将接收到的网络数据解析为内容字符串
24. bool Decode(std::string &package, std::string *content)
25. {
26.     std::size_t pos = package.find(protocol_sep); // 查找协议分隔符的位置
27.     if(pos == std::string::npos) return false; // 如果找不到分隔符，解析失败
29.     std::string len_str = package.substr(0, pos); // 提取长度字符串
30.     std::size_t len = std::stoi(len_str); // 将长度字符串转换为数字
31.     std::size_t total_len = len_str.size() + len + 2; // 计算总长度（长度字符串 + 内容 + 分隔符）
32.     if(package.size() < total_len) return false; // 如果实际数据长度小于预期，解析失败
34.     *content = package.substr(pos+1, len); // 提取内容字符串
35.     package.erase(0, total_len); // 从原始数据中移除已解析的部分
37.     return true; // 解析成功
38. }
40. // 请求数据结构
41. class Request
42. {
43. public:
44.     // 构造函数，初始化请求的参数
45.     Request(int data1, int data2, char oper) : x(data1), y(data2), op(oper) {}
46.     // 默认构造函数
47.     Request() {}
49. public:
50.     // 序列化方法，将请求对象转换为字符串
51.     bool Serialize(std::string *out)
52.     {
53. #ifdef MySelf
54.         // 使用简单的字符串拼接方式
55.         std::string s = std::to_string(x); // 将操作数x转换为字符串
56.         s += blank_space_sep; // 添加空格分隔符
57.         s += op; // 添加操作符
58.         s += blank_space_sep; // 再次添加空格分隔符
59.         s += std::to_string(y); // 将操作数y转换为字符串
60.         *out = s; // 将拼接后的字符串赋值给输出参数
61.         return true; // 返回成功
62. #else
63.         // 使用JSON格式
64.         Json::Value root; // 创建JSON值对象
65.         root["x"] = x; // 添加操作数x
66.         root["y"] = y; // 添加操作数y
67.         root["op"] = op; // 添加操作符
68.         Json::StyledWriter w; // 创建JSON格式化写入器
69.         *out = w.write(root); // 将JSON对象转换为格式化的字符串
70.         return true; // 返回成功
71. #endif
72.     }
74.     // 反序列化方法，将字符串转换为请求对象
75.     bool Deserialize(const std::string &in)
76.     {
77. #ifdef MySelf
78.         // 使用简单的字符串拼接方式
79.         std::size_t left = in.find(blank_space_sep); // 查找第一个空格分隔符
80.         if (left == std::string::npos) return false; // 如果找不到分隔符，解析失败
81.         std::string part_x = in.substr(0, left); // 提取操作数x的字符串
83.         std::size_t right = in.rfind(blank_space_sep); // 查找最后一个空格分隔符
84.         if (right == std::string::npos) return false; // 如果找不到分隔符，解析失败
85.         std::string part_y = in.substr(right + 1); // 提取操作数y的字符串
87.         if (left + 2 != right) return false; // 如果分隔符之间的长度不符合预期，解析失败
88.         op = in[left + 1]; // 提取操作符
89.         x = std::stoi(part_x); // 将操作数x的字符串转换为数字
90.         y = std::stoi(part_y); // 将操作数y的字符串转换为数字
91.         return true; // 返回成功
92. #else
93.         // 使用JSON格式
94.         Json::Value root;
95.         Json::Reader r;
96.         if (!r.parse(in, root)) return false; // 解析JSON字符串，如果失败则返回
98.         x = root["x"].asInt(); // 提取操作数x
99.         y = root["y"].asInt(); // 提取操作数y
100.         op = root["op"].asInt(); // 提取操作符
101.         return true; // 返回成功
102. #endif
103.     }
105.     // 调试方法，打印请求对象的内容
106.     void DebugPrint()
107.     {
108.         std::cout << "新请求构建完成:  " << x << op << y << "=?" << std::endl; // 打印操作数和操作符
109.     }
111. public:
112.     // 请求的数据成员
113.     int x; // 操作数x
114.     int y; // 操作数y
115.     char op; // 操作符，可以是 + - * / %
116. };
118. // 响应数据结构
119. class Response
120. {
121. public:
122.     // 构造函数，初始化响应的参数
123.     Response(int res, int c) : result(res), code(c) {}
124.     // 默认构造函数
125.     Response() {}
127. public:
128.     // 序列化方法，将响应对象转换为字符串
129.     bool Serialize(std::string *out)
130.     {
131. #ifdef MySelf
132.         // 使用简单的字符串拼接方式
133.         std::string s = std::to_string(result); // 将结果转换为字符串
134.         s += blank_space_sep; // 添加空格分隔符
135.         s += std::to_string(code); // 将错误代码转换为字符串
136.         *out = s; // 将拼接后的字符串赋值给输出参数
137.         return true; // 返回成功
138. #else
139.         // 使用JSON格式
140.         Json::Value root; // 创建JSON值对象
141.         root["result"] = result; // 添加结果
142.         root["code"] = code; // 添加错误代码
143.         Json::StyledWriter w; // 创建JSON格式化写入器
144.         *out = w.write(root); // 将JSON对象转换为格式化的字符串
145.         return true; // 返回成功
146. #endif
147.     }
149.     // 反序列化方法，将字符串转换为响应对象
150.     bool Deserialize(const std::string &in)
151.     {
152. #ifdef MySelf
153.         // 使用简单的字符串拼接方式
154.         std::size_t pos = in.find(blank_space_sep); // 查找空格分隔符
155.         if (pos == std::string::npos) return false; // 如果找不到分隔符，解析失败
156.         std::string part_left = in.substr(0, pos); // 提取结果字符串
157.         std::string part_right = in.substr(pos + 1); // 提取错误代码字符串
159.         result = std::stoi(part_left); // 将结果字符串转换为数字
160.         code = std::stoi(part_right); // 将错误代码字符串转换为数字
161.         return true; // 返回成功
162. #else
163.         // 使用JSON格式
164.         Json::Value root;
165.         Json::Reader r;
166.         if (!r.parse(in, root)) return false; // 解析JSON字符串，如果失败则返回
168.         result = root["result"].asInt(); // 提取结果
169.         code = root["code"].asInt(); // 提取错误代码
170.         return true; // 返回成功
171. #endif
172.     }
174.     // 调试方法，打印响应对象的内容
175.     void DebugPrint()
176.     {
177.         std::cout << "结果响应完成, result: " << result << ", code: " << code << std::endl; // 打印结果和错误代码
178.     }
180. public:
181.     int result; // 计算结果
182.     int code; // 错误代码，0表示成功，非0表示错误
183. };

复制代码

四、服务端模块

✅ServerCal.hpp

1. // 预处理指令，确保头文件只被包含一次
2. #pragma once
4. // 引入必要的头文件
5. #include <iostream>
6. // 引入自定义的协议头文件
7. #include "Protocol.hpp"
9. // 定义枚举类型，用于表示不同类型的操作和错误
10. enum
11. {
12.     Div_Zero = 1, // 除数为零的错误代码
13.     Mod_Zero,    // 模数为零的错误代码
14.     Other_Oper     // 其他操作或者错误
15. };
17. // 声明ServerCal类，用于处理客户端的计算请求
18. class ServerCal
19. {
20. public:
21.     // 构造函数
22.     ServerCal()
23.     {
24.     }
26.     // 计算助手函数，根据请求计算结果并返回响应对象
27.     Response CalculatorHelper(const Request &req)
28.     {
29.         Response resp(0, 0); // 创建一个响应对象，初始化结果和错误代码为0
30.         // 根据请求中的操作符进行计算
31.         switch (req.op) // 检查操作符
32.         {
33.             case '+': // 加法
34.                 resp.result = req.x + req.y;
35.                 break;
36.             case '-': // 减法
37.                 resp.result = req.x - req.y;
38.                 break;
39.             case '*': // 乘法
40.                 resp.result = req.x * req.y;
41.                 break;
42.             case '/': // 除法
43.             {
44.                 if (req.y == 0) // 如果除数为0，设置错误代码
45.                     resp.code = Div_Zero;
46.                 else // 否则进行除法运算
47.                     resp.result = req.x / req.y;
48.             }
49.             break;
50.             case '%':
51.             {
52.                 if (req.y == 0) // 如果模数为0，设置错误代码
53.                     resp.code = Mod_Zero;
54.                 else // 否则进行模运算
55.                     resp.result = req.x % req.y;
56.             }
57.             break;
58.             default: // 如果操作符不是预定义的几种
59.                 resp.code = Other_Oper; // 设置错误代码为其他操作
60.                 break;
61.         }
63.         return resp; // 返回计算结果和错误代码
64.     }
66.     // 计算函数，解析请求字符串，并返回计算结果
67.     std::string Calculator(std::string &package)
68.     {
69.         std::string content; // 用于存储解码后的内容
70.         // 解析请求包的长度和内容
71.         bool r = Decode(package, &content);
72.         if (!r)
73.             return ""; // 如果解码失败，返回空字符串
75.         // 从解码后的内容中反序列化请求对象
76.         Request req;
77.         r = req.Deserialize(content);
78.         if (!r)
79.             return ""; // 如果反序列化失败，返回空字符串
81.         // 清空content，准备存储响应内容
82.         content = "";
83.         // 调用助手函数进行计算
84.         Response resp = CalculatorHelper(req);
85.         // 将计算结果和错误代码序列化到content
86.         resp.Serialize(&content);
87.         // 编码响应内容，添加长度前缀
88.         content = Encode(content);
90.         return content; // 返回响应字符串
91.     }
93.     // 析构函数
94.     ~ServerCal()
95.     {
96.     }
97. };

复制代码

✅Socket.hpp

1. // 预处理指令，确保头文件只被包含一次
2. #pragma once
4. // 引入必要的头文件
5. #include <iostream> // 标准输入输出流
6. #include <string>   // 字符串类
7. #include <unistd.h>  // UNIX标准函数，如sleep等
8. #include <cstring>   // C字符串处理函数
9. #include <sys/types.h> // 系统类型定义
10. #include <sys/stat.h> // 文件状态信息
11. #include <sys/socket.h> // 套接字相关函数和结构定义
12. #include <arpa/inet.h> // 网络地址转换
13. #include <netinet/in.h> // 网络接口定义
14. #include "Log.hpp"  // 自定义的日志库
16. // 定义枚举类型，用于表示不同的错误代码
17. enum
18. {
19.     SocketErr = 2, // 套接字创建错误
20.     BindErr,     // 套接字绑定错误
21.     ListenErr    // 套接字监听错误
22. };
24. // 定义backlog常量，用于listen函数的参数
25. const int backlog = 10;
27. // Sock类声明，封装了套接字操作的一系列方法
28. class Sock
29. {
30. public:
31.     // 构造函数
32.     Sock()
33.     {
34.     }
35.     // 析构函数
36.     ~Sock()
37.     {
38.     }
40.     // 创建套接字的方法
41.     void Socket()
42.     {
43.         // 使用socket函数创建一个流式套接字，地址族为IPv4，类型为TCP
44.         sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
45.         // 如果套接字创建失败，记录错误日志并退出程序
46.         if (sockfd_ < 0)
47.         {
48.             lg(Fatal, "socket error, %s: %d", strerror(errno), errno);
49.             exit(SocketErr);
50.         }
51.     }
52.     // 绑定套接字到指定端口的方法
53.     void Bind(uint16_t port)
54.     {
55.         // 创建一个sockaddr_in结构体，用于绑定操作
56.         struct sockaddr_in local;
57.         memset(&local, 0, sizeof(local)); // 清零结构体
58.         local.sin_family = AF_INET;       // 设置地址族为IPv4
59.         local.sin_port = htons(port);     // 设置端口号，使用网络字节序
60.         local.sin_addr.s_addr = INADDR_ANY; // 允许绑定到所有可用网络接口
62.         // 使用bind函数将套接字绑定到指定端口，如果失败记录错误日志并退出程序
63.         if (bind(sockfd_, (struct sockaddr *)&local, sizeof(local)) < 0)
64.         {
65.             lg(Fatal, "bind error, %s: %d", strerror(errno), errno);
66.             exit(BindErr);
67.         }
68.     }
69.     // 使套接字监听传入连接的方法
70.     void Listen()
71.     {
72.         // 使用listen函数使套接字监听传入连接，backlog参数指定最大的连接请求队列长度
73.         if (listen(sockfd_, backlog) < 0)
74.         {
75.             lg(Fatal, "listen error, %s: %d", strerror(errno), errno);
76.             exit(ListenErr);
77.         }
78.     }
79.     // 接受传入连接的方法
80.     int Accept(std::string *clientip, uint16_t *clientport)
81.     {
82.         // 创建一个sockaddr_in结构体，用于存储客户端的地址信息
83.         struct sockaddr_in peer;
84.         socklen_t len = sizeof(peer);
85.         // 使用accept函数接受一个传入连接，返回一个新的套接字描述符
86.         int newfd = accept(sockfd_, (struct sockaddr*)&peer, &len);
87.         // 如果接受连接失败，记录警告日志并返回-1
88.         if(newfd < 0)
89.         {
90.             lg(Warning, "accept error, %s: %d", strerror(errno), errno);
91.             return -1;
92.         }
93.         // 将客户端的IP地址和端口号转换为可读格式
94.         char ipstr[64];
95.         inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));
96.         *clientip = ipstr;
97.         *clientport = ntohs(peer.sin_port); // 转换端口号为主机字节序
99.         return newfd; // 返回新的套接字描述符
100.     }
101.     // 连接到指定的IP地址和端口号的方法
102.     bool Connect(const std::string &ip, const uint16_t &port)
103.     {
104.         // 创建一个sockaddr_in结构体，用于存储目标地址信息
105.         struct sockaddr_in peer;
106.         memset(&peer, 0, sizeof(peer)); // 清零结构体
107.         peer.sin_family = AF_INET;     // 设置地址族为IPv4
108.         peer.sin_port = htons(port);     // 设置端口号，使用网络字节序
109.         inet_pton(AF_INET, ip.c_str(), &(peer.sin_addr)); // 将IP地址转换为网络字节序
111.         // 使用connect函数尝试连接到目标地址，如果失败则记录错误并返回false
112.         int n = connect(sockfd_, (struct sockaddr*)&peer, sizeof(peer));
113.         if(n == -1)
114.         {
115.             std::cerr << "connect to " << ip << ":" << port << " error" << std::endl;
116.             return false;
117.         }
118.         return true; // 连接成功返回true
119.     }
120.     // 关闭套接字的方法
121.     void Close()
122.     {
123.         close(sockfd_); // 使用close函数关闭套接字
124.     }
125.     // 获取套接字文件描述符的方法
126.     int Fd()
127.     {
128.         return sockfd_; // 返回套接字文件描述符
129.     }
131. private:
132.     int sockfd_; // 套接字文件描述符
133. };

复制代码

✅TcpServer.hpp

1. // 预处理指令，确保头文件只被包含一次
2. #pragma once
4. // 引入必要的头文件
5. #include <functional> // 用于支持 std::function
6. #include <string>     // 用于支持 std::string
7. #include <signal.h>   // 用于处理信号
8. #include "Log.hpp"     // 自定义的日志头文件
9. #include "Socket.hpp"  // 自定义的套接字头文件
11. // 定义一个类型别名，用于简化函数参数
12. using func_t = std::function<std::string(std::string &package)>;
14. // 声明TcpServer类，用于创建和运行TCP服务器
15. class TcpServer
16. {
17. public:
18.     // 构造函数，初始化服务器的端口号和回调函数
19.     TcpServer(uint16_t port, func_t callback) : port_(port), callback_(callback)
20.     {
21.     }
22.    
23.     // 初始化服务器的函数，创建套接字，绑定端口，开始监听
24.     bool InitServer()
25.     {
26.         // 创建监听套接字
27.         listensock_.Socket();
28.         // 绑定端口到套接字
29.         listensock_.Bind(port_);
30.         // 开始监听连接请求
31.         listensock_.Listen();
32.         // 记录服务器初始化信息
33.         lg(Info, "init server .... done");
34.         return true;
35.     }
37.     // 启动服务器的主函数，处理客户端连接请求
38.     void Start()
39.     {
40.         // 忽略子进程退出和管道信号
41.         signal(SIGCHLD, SIG_IGN);
42.         signal(SIGPIPE, SIG_IGN);
43.         // 循环处理连接请求
44.         while (true)
45.         {
46.             // 接受客户端的连接请求，获取客户端的IP地址和端口号
47.             std::string clientip;
48.             uint16_t clientport;
49.             int sockfd = listensock_.Accept(&clientip, &clientport);
50.             // 如果接受连接失败，则继续下一次循环
51.             if (sockfd < 0)
52.                 continue;
53.             // 记录客户端连接信息
54.             lg(Info, "accept a new link, sockfd: %d, clientip: %s, clientport: %d", sockfd, clientip.c_str(), clientport);
55.             // 处理客户端请求，创建子进程提供服务
56.             if (fork() == 0)
57.             {
58.                 // 关闭监听套接字
59.                 listensock_.Close();
60.                 std::string inbuffer_stream;
61.                 // 循环读取客户端发送的数据
62.                 while (true)
63.                 {
64.                     // 读取数据到缓冲区
65.                     char buffer[1280];
66.                     ssize_t n = read(sockfd, buffer, sizeof(buffer));
67.                     // 如果读取到数据
68.                     if (n > 0)
69.                     {
70.                         // 将读取的数据添加到输入缓冲区
71.                         buffer[n] = 0;
72.                         inbuffer_stream += buffer;
73.                         // 记录调试信息
74.                         lg(Debug, "debug:\n%s", inbuffer_stream.c_str());
75.                         // 循环处理输入缓冲区中的数据
76.                         while (true)
77.                         {
78.                             // 调用回调函数处理数据，并获取响应信息
79.                             std::string info = callback_(inbuffer_stream);
80.                             // 如果没有响应信息，则跳出循环
81.                             if (info.empty())
82.                                 break;
83.                             // 记录调试信息
84.                             lg(Debug, "debug, response:\n%s", info.c_str());
85.                             // 记录调试信息
86.                             lg(Debug, "debug:\n%s", inbuffer_stream.c_str());
87.                             // 将响应信息发送回客户端
88.                             write(sockfd, info.c_str(), info.size());
89.                         }
90.                     }
91.                     // 如果客户端关闭连接，则跳出循环
92.                     else if (n == 0)
93.                         break;
94.                     // 如果读取失败，则跳出循环
95.                     else
96.                         break;
97.                 }
98.                 // 子进程服务结束后退出
99.                 exit(0);
100.             }
101.             // 关闭客户端套接字
102.             close(sockfd);
103.         }
104.     }
106.     // 析构函数
107.     ~TcpServer()
108.     {
109.     }
111. private:
112.     // 服务器的端口号
113.     uint16_t port_;
114.     // 监听套接字
115.     Sock listensock_;
116.     // 回调函数，用于处理客户端请求
117.     func_t callback_;
118. };

复制代码

✅ServerCal.cpp

1. // 引入必要的头文件
2. #include "TcpServer.hpp" // 引入自定义的TCP服务器头文件
3. #include "ServerCal.hpp"  // 引入自定义的计算器逻辑头文件
4. #include <unistd.h>      // 引入UNIX标准函数库，用于系统调用如sleep等
5. // #include "Daemon.hpp" // 引入自定义的守护进程头文件（当前被注释）
7. // 定义Usage函数，用于输出程序的使用方法
8. static void Usage(const std::string &proc)
9. {
10.     std::cout << "\nUsage: " << proc << " port\n" << std::endl; // 输出程序的使用方法
11. }
13. // 主函数，程序的入口点
14. int main(int argc, char *argv[])
15. {
16.     // 检查命令行参数数量是否正确
17.     if(argc != 2)
18.     {
19.         Usage(argv[0]); // 如果参数不正确，输出使用方法并退出程序
20.         exit(0);
21.     }
22.     // 将命令行参数转换为端口号
23.     uint16_t port = std::stoi(argv[1]);
24.     // 创建计算器逻辑对象
25.     ServerCal cal;
26.     // 创建TCP服务器对象，绑定端口号和计算器逻辑对象的Calculator方法
27.     TcpServer *tsvp = new TcpServer(port, std::bind(&ServerCal::Calculator, &cal, std::placeholders::_1));
28.     // 初始化服务器
29.     tsvp->InitServer();
30.     // 调用守护进程相关函数，将程序转为守护进程运行（当前被注释）
31.     // Daemon();
32.     daemon(0, 0); // 调用守护进程函数，参数设置为0表示不进行标准输出和错误输出的重定向
33.     // 启动服务器，开始监听和处理客户端请求
34.     tsvp->Start();
35.     return 0; // 程序正常结束
36. }

复制代码

五、客户端模块

✅ClientCal.cpp

1. // 引入所需的头文件
2. #include <iostream> // 用于输入输出流
3. #include <string>   // 用于字符串类
4. #include <ctime>    // 用于时间相关函数
5. #include <cassert>   // 用于断言检查
6. #include <unistd.h>  // 用于UNIX标准函数，如sleep
7. #include "Socket.hpp" // 自定义的套接字操作库
8. #include "Protocol.hpp" // 自定义的通信协议库
10. // 定义Usage函数，用于输出程序的使用方法
11. static void Usage(const std::string &proc)
12. {
13.     std::cout << "\nUsage: " << proc << " serverip serverport\n"
14.               << std::endl;
15. }
17. // 主函数，程序的入口点
18. int main(int argc, char *argv[])
19. {
20.     // 检查命令行参数数量是否正确
21.     if (argc != 3)
22.     {
23.         Usage(argv[0]);
24.         exit(0);
25.     }
26.     // 从命令行参数获取服务器的IP地址和端口号
27.     std::string serverip = argv[1];
28.     uint16_t serverport = std::stoi(argv[2]);
30.     // 创建套接字对象
31.     Sock sockfd;
32.     // 创建套接字
33.     sockfd.Socket();
34.     // 尝试连接到服务器
35.     bool r = sockfd.Connect(serverip, serverport);
36.     if(!r) return 1; // 如果连接失败，则退出程序
38.     // 初始化随机数生成器
39.     srand(time(nullptr) ^ getpid());
40.     // 定义测试次数
41.     int cnt = 1;
42.     // 定义操作符字符串
43.     const std::string opers = "+-*/%=-=&^";
45.     // 定义输入缓冲区流
46.     std::string inbuffer_stream;
47.     // 循环发送请求并接收响应，直到发送了10次
48.     while(cnt <= 10)
49.     {
50.         // 输出测试次数信息
51.         std::cout << "===============第" << cnt << "次测试....., " << "===============" << std::endl;
52.         // 生成随机数作为请求的参数
53.         int x = rand() % 100 + 1;
54.         usleep(1234); // 微秒级的暂停
55.         int y = rand() % 100;
56.         usleep(4321); // 微秒级的暂停
57.         // 随机选择一个操作符
58.         char oper = opers[rand() % opers.size()];
59.         // 创建请求对象
60.         Request req(x, y, oper);
61.         // 打印请求的详细信息（调试用）
62.         req.DebugPrint();
64.         // 序列化请求对象到字符串
65.         std::string package;
66.         req.Serialize(&package);
68.         // 将请求字符串编码为网络字节流
69.         package = Encode(package);
71.         // 通过套接字发送请求
72.         write(sockfd.Fd(), package.c_str(), package.size());
73.         // 读取服务器的响应
74.         char buffer[128];
75.         ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer)); // 读取响应到缓冲区
76.         if(n > 0)
77.         {
78.             // 确保读取的字符串以空字符结尾
79.             buffer[n] = 0;
80.             // 将读取的内容添加到输入缓冲区流
81.             inbuffer_stream += buffer;
82.             // 输出接收到的完整响应
83.             std::cout << inbuffer_stream << std::endl;
84.             // 从输入缓冲区流中解码出响应内容
85.             std::string content;
86.             bool r = Decode(inbuffer_stream, &content); // 解码响应内容
87.             assert(r); // 断言解码成功
89.             // 反序列化响应内容到Response对象
90.             Response resp;
91.             r = resp.Deserialize(content);
92.             assert(r); // 断言反序列化成功
94.             // 打印响应的详细信息（调试用）
95.             resp.DebugPrint();
96.         }
98.         // 输出测试分隔线
99.         std::cout << "=================================================" << std::endl;
100.         // 暂停一秒
101.         sleep(1);
103.         // 增加测试次数
104.         cnt++;
105.     }
107.     // 关闭套接字
108.     sockfd.Close();
109.     // 程序正常退出
110.     return 0;
111. }

复制代码

六、计划方案总结

• 模块化：代码被分为差别的模块，每个模块负责一个特定的功能。这种计划使得代码易于明白和维护。
  
• 日志记录：通过Log类，服务器和客户端可以记录操作信息和错误信息，有助于调试和监控。
  
• 自界说协议：通过Protocol类，界说了一个简朴的文本协议来传输请求和响应。协议的计划简朴明了，易于明白和实现。
  
• 错误处理：服务器和客户端都实现了根本的错误处理逻辑，能够处理一些常见的错误情况。
  
• 多进程模型：TcpServer类利用多进程模型来处理并发毗连，每个客户端毗连都在自己的进程中运行。
  
• 安全性：固然代码中没有明白提到安全性措施，但在实际部署时，应该考虑利用加密通讯、身份验证等安全措施来掩护数据。
  
• 性能优化：在生产情况中，可能需要进一步优化服务器的性能，比如利用多线程或异步I/O代替多进程模型，或者利用专门的高性能网络库。
  
• 可扩展性：代码计划允许未来添加新的功能，比如支持更多的操作符或增加新的操作类型。
  

通过上述计划方案，我们可以得到一个根本的TCP服务器和客户端，它们可以根据自界说协议处理客户端请求，并支持根本的算术运算。这个系统可以作为“跨网络盘算器”的根本，通过界说合适的回调函数和协议格式来实现盘算器的功能。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。