共计 6234 个字符，预计需要花费 16 分钟才能阅读完成。
唯有梦想才配让你不安，
唯有行动才能解除你的不安。
— 卢思浩 —
从零开始掌握序列化
- 1 知识回顾
- 2 序列化与编写协议
-
- 2.1 使用 Json 进行序列化
- 2.2 编写协议
- 3 封装 IOService
- 4 应用层 — 网络计算器
- 5 总结
1 知识回顾
上一篇文章我们讲解了协议的本质是双方能够看到的结构化数据。并通过传输层的底层理解了为什么 read 系列函数时全双工支持同时读写的：TCP 传输层有两个缓冲区，分别接收和发送。最重要的是我们将 TCP 通信的代码进行的重构：
- 我们将 Socket 通信单独封装为一个类，负责 Socket 套接字的创建，bind 绑定服务器端口号，进入监听模式…工作，基类 Socket 并不进行定义，只进行声明！具体实现由派生类 TcpServer 和 UdpServer 来进行
- TcpServer 继承 Socket 类的所有方法，然后进行具体的函数定义！
- 上层的 TcpServer 直接底层使用 TcpSocket 对象就可以完成 Socket 系列操作，十分方便！
接下来我们要实现是这样的一个结构：
通信过程整体分为三层
- 传输层 TcpServer: 负责从 Socket 文件中获取链接，传输层不需要进行 IO，获取到连接就让会话层通过连接获取数据！
- 会话层 Service: 根据传输层给的连接，从 Sockfd 文件中读取数据，解析出报文结构中的数据字符串，然后通过协议分离出结构化数据。该层只负责数据的解析，数据的处理交给应用层进行！
- 应用层 Process：应用层是具有的业务逻辑，根据会话层解析出的数据，进行数据处理！
这样是一个非常非常优雅的封装操作！！！
2 序列化与编写协议
2.1 使用 Json 进行序列化
协议是 IO 的基础，只有协议确定下来，才可以进行通信。
我们这里想要实现一个网络计算器的应用，所以协议分为了两个类：Request 和 Response。分别作为传入的数据和传出的数据：
- Request：两个数字和一个运算符
- Response：结果数字，错误码，退出信息
他们是作为结构化的数据进行传输，那么想要进行传输就来到了最重要的部分序列化与反序列化！序列化与反序列化可以使用第三方库也可以自己进行编写。这里我们先使用第三方的 Json 库进行实现：
Jsoncpp 是一个用于处理 JSON 数据的 C++ 库。它提供了将 JSON 数据序列化为字符串以及从字符串反序列化为 C++ 数据结构的功能。Jsoncpp 是开源的，广泛用于各种需要处理 JSON 数据的 C++ 项目中:
- 简单易用：Jsoncpp 提供了直观的 API，使得处理 JSON 数据变得简单。
- 高性能：Jsoncpp 的性能经过优化，能够高效地处理大量 JSON 数据。
- 全面支持：支持 JSON 标准中的所有数据类型，包括对象、数组、字符串、数字、布尔值和 null。
- 错误处理：在解析 JSON 数据时，Jsoncpp 提供了详细的错误信息和位置，方便开发者调试
在 Linux 中使用需要进行安装对应的 JSON 库：
ubuntu：sudo apt-get install libjsoncpp-dev
Centos: sudo yum install jsoncpp-devel
安装之后就可以进行使用了：
使用起来是十分方便的：
- Json::Value 是最重要的类，这是对 Json 数据结构进程操作和表示的关键类
- 建立好类 Json::Value 之后就可以通过
[]操作root["x"] = _x;, 像这样就可以进行赋值- 将 Json 数据结构转换为字符串依靠 Json::FastWriter 或 Json::StreamWriter 都可以转换成字符串
Json::StyledWriter writer; std::string s = writer.write(root)
- 通过 Json::Reader 可以快速将字符串反序列化得到 Json 结构！
bool parsingSuccessful = reader.parse(json_string,root); std::string name = root["name"].asString(); int age = root["age"].asInt(); std::string city = root["city"].asString();
通过这样就就可以简洁的完成序列化与反序列化的工作！
2.2 编写协议
根据我们的需求在加入 Json 操作我们就可以把协议写出来，代码虽然很长但是很好理解:
- Request 类中需要根据
int x , int y , char oper进行序列化生成字符串，也要能够通过字符串反序列化得到三个变量 - Response 类中需要根据
int res , int code , std::string desc进行序列化生成字符串，也要能够通过字符串反序列化得到三个变量
#pragma once
#include 看一下效果：
完成了基础的序列化和反序列化之后，我们就可以做到从 sockfd 流中读取数据了吗？？不可以！因为不知道 Json 字符串的长度，就不知道应该读取多少字节！这样可就做不到正确的从数据中获取 json 字符串！
所以我们还有做一步特殊处理：
- 需要对生成的 Json 字符串加入报头
len记录 json 字符串的长度，中间以sep分隔符分割！ - 需要对获得到的数据进行解析，去除报头得到一个 Json 字符串！
const std::string sep = "rn";
std::string Encode(const std::string &jsonstr)
{
int len = jsonstr.size();
std::string lenstr = std::to_string(len);
return lenstr + sep + jsonstr + sep;
}
std::string Decode(std::string &packagestream)
{
auto pos = packagestream.find(sep);
if (pos == std::string::npos)
return std::string();
std::string lenstr = packagestream.substr(0, pos);
int len = std::stoi(lenstr);
int total = lenstr.size() + len + 2 * sep.size();
if (total > packagestream.size())
return std::string();
std::string jsonstr = packagestream.substr(pos + sep.size(), len);
packagestream.erase(total);
return jsonstr;
}
经过这样的操作，可以保证：
- 上层想要发送数据时，可以将数据包装为 json 字符串，并加入报头形成完整报文！
- 上层获取数据进行反序列化时可以获取到完整的 json 字符串！并成功解析为数据
3 封装 IOService
将来我们的线程会执行将会执行这个回调函数方法，现在我们不再需要 TcpServer 来进行 IO 操作，TcpServer 只负责进行获取链接，获取到连接后通过 ThreadData 结构体将数据传到线程中的回调函数中：
class ThreadData
{
public:
SockSPtr _sockfd;
InetAddr _addr;
TcpServer *_this;
public:
ThreadData(SockSPtr sockfd, InetAddr addr, TcpServer *p) : _sockfd(sockfd),
_this(p),
_addr(addr)
{
}
};
在回调函数 Execute 中:
static void *Execute(void *args)
{
pthread_detach(pthread_self());
TcpServer::ThreadData *td = static_castTcpServer::ThreadData *>(args);
td->_this->_service(td->_sockfd, td->_addr);
td->_sockfd->Close();
delete td;
return nullptr;
}
就可以解析出来套接字文件描述符和客户端信息了！解析出信息之后就去执行会话层的回调函数进行 IO 操作：
- Service 内部只有一个成员变量，就是应用层的回调函数，Service 解析出来数据之后就可以传入到应用层中进行使用
- IO 中主要需要进行从 sockfd 文件中获取数据，然后通过协议进行解析，获取到真正的数据。再调用回调函数对数据进行操作！得到结果之后就可以进行序列化，加入报头，再发送给客户端！
- 应用层的操作逻辑，Service 并不关心，只要回调函数可以传回需要的结构体就可以！
class Service
{
public:
Service(process_t process) : _process(process)
{
}
void IOExecute(SockSPtr sock, InetAddr &addr)
{
LOG(INFO, "service start!!!n");
std::string message;
while (true)
{
ssize_t n = sock->Recv(&message);
if (n 0)
{
LOG(ERROR, "read error: %sn", addr.AddrStr().c_str());
break;
}
std::string str = Decode(message);
if (str.empty())
continue;
auto req = Factory::BuildRequestDefault();
req->Deserialize(str);
auto res = Factory::BuildResponseDefault();
res = _process(req);
std::string ret;
res->Serialize(&ret);
Encode(ret);
sock->Send(ret);
}
}
~Service()
{
}
private:
process_t _process;
};
4 应用层 — 网络计算器
应用层根据具体需要可以随时改变，我这里以网络计算器为例子进行书写：
#include "Protocol.hpp"
class NetCal
{
public:
NetCal() {}
std::shared_ptrResponse> Calculator(std::shared_ptrRequest> req)
{
std::shared_ptrResponse> res = Factory::BuildResponseDefault();
switch (req->Oper())
{
case '+':
res->_res = req->X() + req->Y();
res->_code = 0;
res->_desc = "success";
break;
case '-':
res->_res = req->X() - req->Y();
res->_code = 0;
res->_desc = "success";
break;
case '*':
res->_res = req->X() * req->Y();
res->_code = 0;
res->_desc = "success";
break;
case '/':
{
if (req->Y() == 0)
{
res->_code = 1;
res->_desc = "div zero";
}
res->_res = req->X() / req->Y();
res->_code = 0;
res->_desc = "success";
}
break;
case '%':
{
if (req->Y() == 0)
{
res->_code = 1;
res->_desc = "mod zero";
}
res->_res = req->X() % req->Y();
res->_code = 0;
res->_desc = "success";
}
break;
default:
res->_code = 2;
res->_desc = "illegal operations";
break;
}
return res;
}
~NetCal() {}
};
逻辑很简单不在多加赘述！
5 总结
现在我们的程序分为了三层结构：
我们做到了最大程度的解耦！
- 传输层只负责获取链接，我们应用层要进行什么工作，只要是进行网络通信传输层的工作就是唯一的！
- 会话层进行 IO 操作！只要传输层提供了链接，会话层就可以获取数据，然后根据具体的协议进行数据的解析工作。协议根据实际情况改变，但是会话层的工作逻辑是不变的！
- 应用层只管进行数据处理即可，什么但不不需要考虑！完成工作后返回给会话层数据即可！
这样的结构逻辑十分清晰，并且解耦的非常优雅，值得反复品味！！！
原文地址: 【计网】从零开始掌握序列化 — JSON 实现协议 设计 传输会话应用 三层结构
正文完
