目录

1. 理解协议

1.1 结构化数据的传输

序列化与反序列化

代码感知：

Request 类

1. 构造函数

2. 序列化函数：Serialize()

3. 反序列化函数：DeSerialize()

补充

4. 成员变量

Response 类

1. 构造函数

2. 序列化函数：Serialize()

3. 反序列化函数：DeSerialize()

4. 成员变量

总结

2. 实验：网络版计算器

2.1 定义请求和响应协议

2.2 TCP 服务端设计

2.3 业务处理逻辑

3. TCP 客户端实现

4. 序列化与反序列化的重要性

在网络编程中，协议是一个关键概念。协议本质上是一种“约定”，规定了两方在通信时如何格式化和处理数据。本文将深入探讨如何通过协议进行结构化数据的传输，并且通过一个具体的网络版计算器（ TCP服务器-客户端）示例，展示序列化与反序列化的实现。

学习导图：

1. 理解协议

协议，简单来说，就是通信双方都遵守的规则。在前面的例子中，我们使用了父亲和儿子通过电话沟通的场景。父亲告诉儿子会在特定时间打电话，这就是一种约定——协议。

1.1 结构化数据的传输

在网络通信中，数据通常以字节流的形式发送和接收。当我们需要传输的是结构化数据时，例如在QQ群聊中，除了文字消息外，还包含头像、时间和昵称。这些信息都需要以某种方式发送给对方。如果我们逐个发送这些数据，不仅麻烦，接收方也难以处理，因此需要对这些数据进行打包。

为什么要把字符串转成结构化数据呢？未来这个结构化的数据一定是一个对象，然后使用它的时候，直接对象.url 、对象.time 拿到。

而这里的结构体如message就是传说中的业务协议。

因为它规定了我们聊天时网络通信的数据。

序列化与反序列化

为了简化结构化数据的传输，我们通常将多个独立的信息合并为一个报文。这就是序列化的过程：将数据打包成一个字符串或字节流，再通过网络发送。接收方收到数据后，需要通过反序列化，将收到的数据解析回原来的结构化数据。

代码感知：

这段代码的核心功能是实现请求（<code>Request）和响应（Response）的序列化与反序列化。序列化的作用是将类中的成员变量转换成字符串格式，方便在网络中传输；反序列化的作用是将字符串解析回类的成员变量，恢复为结构化数据。以下是对该代码的详细解释：

Request 类

class Request

{

public:

// 定义常量字符串分隔符和其长度

static const char SPACE = ' ';

static const int SPACE_LEN = 1;

这个类表示客户端发送给服务器的计算请求，包含两个操作数（_x 和 _y）以及一个操作符（_op）。它提供了序列化和反序列化的能力。

1. 构造函数

Request()

{}

这个是默认构造函数，不进行任何初始化操作，只是声明了 Request 对象。

Request(int x, int y, int op)

: _x(x), _y(y), _op(op)

{}

这是一个带参数的构造函数，它接受两个整数操作数 x、y 和一个字符操作符 op，并将它们赋值给类中的成员变量 _x、_y、_op。

2. 序列化函数：Serialize()

std::string Serialize()

{

std::string str;

str = std::to_string(_x);

str += SPACE;

str += _op;

str += SPACE;

str += std::to_string(_y);

return str;

}

功能：将 Request 对象中的数据成员 _x、_op 和 _y 组合成一个字符串。返回组合好的字符串。最终结果类似 "1 + 2" 的格式。

3. 反序列化函数：DeSerialize()

bool DeSerialize(const std::string &str)

{

size_t left = str.find(SPACE);

if(left == std::string::npos)

{

return false;

}

size_t right = str.rfind(SPACE);

if (right == std::string::npos)

{

return false;

}

_x = atoi(str.substr(0, left).c_str());

_y = atoi(str.substr(right + SPACE_LEN).c_str());

if(left + SPACE_LEN < str.size())

{

_op = str[left + SPACE_LEN];

return true;

}

else

{

return false;

}

}

功能：从输入的字符串中提取出操作数 _x 和 _y 以及操作符 _op，并将它们存储到 Request 对象的成员变量中。步骤：

str.find(SPACE)：在字符串 str 中查找第一个空格的位置，用作分隔符。如果找不到，返回 false。str.rfind(SPACE)：查找最后一个空格的位置，表示第二个操作数的开头。如果找不到，返回 false。使用 atoi 函数从字符串中提取整数操作数 _x 和 _y。substr(0, left) 获取左侧字符串，即第一个操作数，substr(right + SPACE_LEN) 获取右侧字符串，即第二个操作数。从字符串 str 中获取操作符 _op，位于第一个空格后的位置。如果解析成功，返回 true；否则返回 false。

设计思路：

补充

上面代码中的atoi是怎么使用的，介绍一下atoi接口是如何从字符串 str 中获取操作符 _op

<code>atoi 函数的使用：

atoi 是 C++ 标准库函数之一，它位于 <cstdlib> 头文件中。该函数的作用是将一个字符串（以空字符结尾的字符数组）转换为 int 类型的整数。其原型如下：

int atoi(const char *str);

参数 str 是指向要转换的以空字符结尾的字符串的指针。atoi 会从字符串的开头开始转换，直到遇到第一个非数字字符或到达字符串的结尾。如果字符串以数字开头，atoi 会返回这些数字对应的整数值。如果字符串不是以数字开头，或者字符串为空，atoi 会返回 0。

以下是一些使用 atoi 的例子：

#include <cstdlib>

#include <iostream>

int main() {

const char *str1 = "123";

const char *str2 = "12abc34";

const char *str3 = "abc123";

int num1 = atoi(str1); // num1 will be 123

int num2 = atoi(str2); // num2 will be 12

int num3 = atoi(str3); // num3 will be 0 (no digits at the start)

std::cout << "num1: " << num1 << std::endl;

std::cout << "num2: " << num2 << std::endl;

std::cout << "num3: " << num3 << std::endl;

return 0;

}

需要注意的是，<code>atoi 不进行错误检查，如果字符串不能完全转换为数字，那么未转换的部分将被忽略。此外，atoi 无法处理整数溢出，如果转换的数字超出了 int 的表示范围，结果是不确定的。

🎢2. 从字符串 str 中获取操作符 _op：

在 Request 类的 DeSerialize 方法中，以下是获取操作符 _op 的代码片段：

if(left + SPACE_LEN < str.size())

{

_op = str[left + SPACE_LEN];

return true;

}

else

{

return false;

}

这里的 left 是 str 中第一个空格字符的位置，SPACE_LEN 是空格字符的长度，通常为 1。所以 left + SPACE_LEN 是第一个空格字符之后的位置，即操作符 _op 应该出现的位置。str[left + SPACE_LEN] 获取该位置的字符并将其赋值给 _op。

4. 成员变量

public:

int _x;

int _y;

char _op;

};

Response 类

Response 类表示服务器的响应，包含两个数据成员：计算结果 _ret 和状态码 _code。

1. 构造函数

Response()

{}

这是默认构造函数，不初始化任何成员。

Response(int ret, int code)

: _code(code), _ret(ret)

{}

这是一个带参数的构造函数，用来初始化响应结果 ret 和状态码 code。

2. 序列化函数：Serialize()

std::string Serialize()

{

std::string str = std::to_string(_code);

str += SPACE;

str += std::to_string(_ret);

return str;

}

功能：将 Response 对象的两个成员变量 _code 和 _ret 组合成字符串。

3. 反序列化函数：DeSerialize()

bool DeSerialize(std::string &str)

{

size_t pos = str.find(SPACE);

if(pos == std::string::npos)

{

return false;

}

_code = atoi(str.substr(0, pos).c_str());

_ret = atoi(str.substr(pos + SPACE_LEN).c_str());

return true;

}

功能：从输入的字符串中解析出状态码 _code 和计算结果 _ret，并存入 Response 对象。

4. 成员变量

int _ret; // 计算结果

int _code; // 状态码

Response 类包含两个成员变量：

_ret：存储服务器的计算结果（例如：加法、减法的结果）。_code：存储状态码，0 表示成功，非 0 表示错误（例如：除以 0 错误时 _code 可能为 1）。

总结

class Request

{

public:

Request()

{}

Request(int x, int y, int op)

: _x(x), _y(y), _op(op)

{}

~Request()

{}

// _x _op _y

std::string Serialize()

{

std::string str;

str = std::to_string(_x);

str += SPACE;

str += _op;

str += SPACE;

str += std::to_string(_y);

return str;

}

bool DeSerialize(const std::string &str)

{

size_t left = str.find(SPACE);

if(left == std::string::npos)

{

return false;

}

size_t right = str.rfind(SPACE);

if (right == std::string::npos)

{

return false;

}

_x = atoi(str.substr(0, left).c_str());

_y = atoi(str.substr(right + SPACE_LEN).c_str());

if(left + SPACE_LEN < str.size())

{

_op = str[left + SPACE_LEN];

return true;

}

else

{

return false;

}

}

public:

int _x;

int _y;

char _op;

};

class Response

{

public:

Response()

{}

Response(int ret, int code)

: _code(code)

, _ret(ret)

{}

~Response()

{}

// _code _ret

std::string Serialize()

{

std::string str = std::to_string(_code);

str += SPACE;

str += std::to_string(_ret);

return str;

}

bool DeSerialize(std::string &str)

{

size_t pos = str.find(SPACE);

if(pos == std::string::npos)

{

return false;

}

_code = atoi(str.substr(0, pos).c_str());

_ret = atoi(str.substr(pos + SPACE_LEN).c_str());

return true;

}

public:

int _ret; // 计算结果

int _code; // 计算结果的状态码

};

代码展示了如何将 Request 和 Response 对象进行序列化和反序列化，以便在网络中传输结构化数据。序列化将对象转换为字符串进行网络传输，反序列化将接收到的字符串重新解析为对象，方便在应用程序中处理。

Request 主要表示操作请求，包括两个操作数和一个操作符。Response 表示服务器的响应，包括计算结果和状态码。序列化与反序列化是网络编程中常用的技术，能有效将复杂的结构化数据转化为适合网络传输的简单格式。

2. 实验：网络版计算器

为了加深理解，我们通过实现一个简单的TCP服务端来展示协议、序列化和反序列化的运作过程。这个服务端会处理简单的数学运算请求，客户端发送请求，服务端进行计算并返回结果。

2.1 定义请求和响应协议

我们定义了一个 Request 类来表示计算请求，包含两个操作数和一个操作符。同时，我们定义了 Response 类来表示响应结果，包含计算结果和状态码。

class Request {

public:

Request(int x, int y, char op) : _x(x), _y(y), _op(op) {}

// 序列化：将请求转换为字符串格式

bool serialize(string *out) {

*out = to_string(_x) + " " + _op + " " + to_string(_y);

return true;

}

// 反序列化：从字符串解析出请求内容

bool deserialize(const string &in) {

auto left = in.find(' ');

auto right = in.rfind(' ');

if (left == string::npos || right == string::npos || left == right)

return false;

_x = stoi(in.substr(0, left));

_op = in[left + 1];

_y = stoi(in.substr(right + 1));

return true;

}

public:

int _x; // 操作数1

int _y; // 操作数2

char _op; // 操作符

};

class Response {

public:

Response(int exitcode, int result) : _exitcode(exitcode), _result(result) {}

// 序列化：将响应转换为字符串格式

bool serialize(string *out) {

*out = to_string(_exitcode) + " " + to_string(_result);

return true;

}

// 反序列化：从字符串解析出响应内容

bool deserialize(const string &in) {

auto pos = in.find(' ');

if (pos == string::npos) return false;

_exitcode = stoi(in.substr(0, pos));

_result = stoi(in.substr(pos + 1));

return true;

}

public:

int _exitcode; // 状态码

int _result; // 计算结果

};

2.2 TCP 服务端设计

我们设计了一个简单的TCP服务器 CalServer，用于处理客户端的请求并返回响应。

handlerEntry 函数：负责处理单个客户端连接。接收请求、反序列化、执行计算、序列化响应并发送回客户端。CalServer 类：负责监听端口并处理多个客户端连接。

class CalServer {

public:

CalServer(const uint16_t port) : _port(port), _listensock(-1) {}

void initServer() {

_listensock = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in local;

local.sin_family = AF_INET;

local.sin_port = htons(_port);

local.sin_addr.s_addr = INADDR_ANY;

bind(_listensock, (struct sockaddr*)&local, sizeof(local));

listen(_listensock, 5);

}

void start(func_t func) {

signal(SIGCHLD, SIG_IGN);

while (true) {

int sock = accept(_listensock, nullptr, nullptr);

if (fork() == 0) {

handlerEntry(sock, func);

close(sock);

exit(0);

}

close(sock);

}

}

};

2.3 业务处理逻辑

处理请求的逻辑被封装在 Cal 函数中。它根据请求中的操作符计算结果并填充响应：

void Cal(const Request &req, Response &resp) {

switch (req._op) {

case '+': resp._result = req._x + req._y; break;

case '-': resp._result = req._x - req._y; break;

case '*': resp._result = req._x * req._y; break;

case '/': if (req._y == 0) resp._exitcode = 1; else resp._result = req._x / req._y; break;

default: resp._exitcode = 2; break;

}

}

3. TCP 客户端实现

客户端通过发送序列化后的请求并接收响应。

class CalClient {

public:

CalClient(const string &ip, const uint16_t &port) : _serverip(ip), _serverport(port), _sockfd(-1) {}

void initClient() {

_sockfd = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in server;

server.sin_family = AF_INET;

server.sin_port = htons(_serverport);

server.sin_addr.s_addr = inet_addr(_serverip.c_str());

connect(_sockfd, (struct sockaddr*)&server, sizeof(server));

}

void run() {

while (true) {

string msg;

cout << "Enter calculation: ";

getline(cin, msg);

Request req = parseInput(msg);

string req_str;

req.serialize(&req_str);

send(_sockfd, req_str.c_str(), req_str.size(), 0);

char buffer[1024];

recv(_sockfd, buffer, sizeof(buffer), 0);

Response resp;

resp.deserialize(buffer);

cout << "Result: " << resp._result << endl;

}

}

private:

string _serverip;

uint16_t _serverport;

int _sockfd;

};

4. 序列化与反序列化的重要性

序列化：将结构化的数据（如对象）转换为字节流或字符串，以便传输。反序列化：将字节流或字符串重新解析为结构化数据，供应用程序使用。

通过序列化与反序列化，应用程序与网络通信得到了有效解耦。这种设计使得复杂的数据可以轻松地在网络中传输，并且为上层应用提供了灵活的操作方式。

对于网络版计算器所有部分的完整代码，之后将上传 gitee，下篇文章将对于设计思路和一些坑点继续讲解~