【Linux】应用层自界说协议与序列化

目录
应用层
再谈协议
 网络版计算器
序列化与反序列化
重新明确read/write/recv/send以及tcp为什么支持全双工
代码实现

---

应用层

现实上，我们在网络部分写的所有代码都属于应用层，应用层必要协议，之前我们约定过双发发过来的都是字符串、单词、聊天系统、命令行等都是提前约定好的协议。
再谈协议

协议的本质就是一种约定，之前我们在利用socket读写数据时，都是按字符串的方式发送和接收，如果我们想传一些“结构化的数据”该怎么办呢？
   实在，协议就是双方约定好的结构化的数据。
   网络版计算器

例如，我们想要实现一个网络版的计算器，客户端必要把要计算的两个数发到服务器，然后由服务器去计算，最后把计算效果返回给客户端。
我们创建Protocol.hpp这个文件，里面界说好这两个结构体：

1. //struct request req = {10, 20, '+'}
2. struct request
3. {
4.     int x;
5.     int y;
6.     char oper; // + - * / %
7. };
9. struct response
10. {
11.     int result;
12.     int code; // 0:success 1:div zero 2:非法操作
13. };

复制代码

struct request是客户端发送过来的数据，reponse是服务器给客户端返回的计算效果。将来让客户端和服务器都包罗这个文件，那它们就认识这两个结构体了。

• 发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时候再按照雷同的规则把字符串转化回结构体。这个过程叫做序列化与反序列化。
  

为什么肯定要对发送数据举行序列化呢？直接把结构体传过去，然后用结构体接收不可以吗？缘故原由有以下几点：

• 将来可能是不同的OS平台举行通信，比如linux和windows，安卓ios和linux等，对同一个结构体可能存在内存对齐不划一、大小不一样的题目。也有可能服务器利用C++写的，而客户端可能是python、Java写的，它们界说结构体时范例大小可能都不一样。
  
• 即便我们之前在技术上克服了上面的题目，应用层的协议可能不断变革，一旦发生变革，跨平台等题目标处置惩罚要重新测试验证。这样带来的题目是可扩展性非常不好。
  

所以，我们严重不推荐直接发结构体等数据。
序列化与反序列化

现实上我们在聊天的时候，一条消息由多行构成，包括消息内容、发送时间、用户名等。在发送消息时，为了便于发送，必要举行序列化，把信息由多变一，酿成一行字符串，方便网络发送。然后通过网络，将这一行字符串推动到服务器，然后在客户端把一行字符串按照协议反序列化为结构化的数据，在上层就可以拿到message里的每一个内容。
在网络层，无论利用tcp/udp，它们都不关心发过来的是什么，只知道这是一个个字节构成的字节省就行了，解释工作由上层来做。
重新明确read/write/recv/send以及tcp为什么支持全双工

在客户端和服务端通信的时候，双方都要有套接字。当我们创建套接字时，tcp里会给我们创建两段缓冲区，即发送缓冲区和接收缓冲区。之前写tcp时，会accept新毗连，一个文件形貌符fd就代表一个毗连，一个毗连，对应两个缓冲区。我们之前用的write/send，本质是把数据拷贝到TCP的发送缓冲区，同样地，read/recv读数据，本质上是把缓冲区内部的数据拷贝到应用层。

• 所以，read、write、recv、send本质都是拷贝函数！
  
• 发数据的本质是从发送方的发送缓冲区的内容经过协议栈和网络拷贝给接收方的接收缓冲区。
  
• 由于TCP有两个缓冲区，可以同时对缓冲区分别举行读写，这就是TCP支持全双工通信的缘故原由。
  

当缓冲区没数据时，系统调用read函数会阻塞，进程被挂起等候，由R状态设为S，等有数据时再把进程唤醒。
那缓冲区里的数据什么时候发，发多少，出错了怎么办？这实在是由TCP协议自主来决定，这也就是TCP协议叫做传输控制协议的缘故原由！发送数据的本质就相称于文件缓冲区的数据革新到磁盘，只不外从前外设是磁盘，今天外设是网络。由于传输层和网络层属于OS，那缓冲区里的数据什么时候发，发多少，出错了怎么办这些题目本质也是由OS主动去处置惩罚的，换句话说，用户只是把数据交给OS，剩下的工作由OS自主完成。这未免和文件操作很相似。
这种有人把数据放入到缓冲区，有人把数据从缓冲区里拿出来，这实在是生产者消费者模子！

• 为什么IO函数要阻塞？本质就是在维护同步关系！这是从系统角度明确网络。
  

下面是一个完整的从用户层到数据链路层的通信模子： 

TCP是面向字节省的，客户端发的，不肯定全部是服务器收的（类似发送自来水，你接自来水可能用杯子、用碗盆接。对方发了一次，你可能要接好多次，对方发了好多次，你一次就接完了）。
所以，怎么包管服务器从接收缓冲区读到的是一个完整的请求呢？必要分割完整的报文。
代码实现

学到这里，我们为了之后创建套接字方便，必要对创建套接字举行封装，利用模版模式方法。模板方法模式的焦点思想是在一个父类中界说一个算法的框架，而将算法中的某些步调延迟到子类中实现。模板方法模式的主要内容是：
   1.创建一个抽象基类，里面包罗一个或多个纯虚函数（这些函数在子类中实现），以及一个或多个具体实现的函数（这些函数将调用纯虚函数，形成算法的框架）。
  2.在子类中实现抽象基类中的纯虚函数，从而提供算法中不同步调的具体实现。
  3.在客户端代码中，通过抽象基类的指针或引用来调用算法框架，实现多态性。

1. enum
2. {
3.     SOCKTE_ERROR = 1,
4.     BIND_ERROR,
5.     LISTEN_ERROR
6. };
8. const static int gbcklog = 8;
10. namespace socket_ns
11. {
12.     using SockSPtr = std::shared_ptr<Socket>;
13.     //模版模式方法
14.     class Socket
15.     {
16.     public:
17.         virtual void CreateSocketOrDie() = 0;
18.         virtual void CreateBindOrDie(uint16_t port) = 0;
19.         virtual void CreateListenOrDie(int gbcklog = gbcklog) = 0;
20.         virtual SockSPtr Accepter(InetAddr* cliaddr) = 0;
21.         virtual bool Connector(const std::string& peerip, uint16_t peerport) = 0;
22.     public:
23.         void BuildClientSocket(const std::string& peerip, uint16_t peerport)
24.         {
25.             CreateSocketOrDie();
26.             Connector(peerip, peerport);
27.         }
28.         void BuildListenSocket(uint16_t port)
29.         {
30.             CreateSocketOrDie();
31.             CreateBindOrDie(port);
32.             CreateListenOrDie();   
33.         }
34.     };
37.     class TcpSocket : public Socket
38.     {   
39.     public:
40.         TcpSocket()
41.         {
43.         }
44.         TcpSocket(int sockfd):_sockfd(sockfd)
45.         {
47.         }
48.         void CreateSocketOrDie() override
49.         {
50.             //1.创建socket
51.             _sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
52.             if(_sockfd < 0)
53.             {
54.                 LOG(FATAL, "socket create error\0");
55.                 exit(SOCKTE_ERROR);
56.             }
57.             LOG(INFO,"socket create success, sockfd:%d\n", _sockfd);
58.         }
59.         void CreateBindOrDie(uint16_t port) override
60.         {
61.             struct sockaddr_in local;
62.             memset(&local, 0, sizeof(local));
63.             local.sin_family = AF_INET;
64.             local.sin_port = htons(port);
65.             local.sin_addr.s_addr = INADDR_ANY;
66.             //2.bind sockfd 和sockaddr
67.             if(::bind(_sockfd, (struct sockaddr *)&local, sizeof(local)) < 0)
68.             {
69.                 LOG(FATAL, "bind error\n");
70.                 exit(BIND_ERROR);
71.             }
72.             LOG(INFO, "bind success, sockfd:%d\n",_sockfd);
73.         }
74.         void CreateListenOrDie(int gbcklog = gbcklog)override
75.         {
76.             //3.因为tcp是面向连接的，tcp需要未来不断能够获取到连接
77.             if(::listen(_sockfd, gbcklog) < 0)
78.             {
79.                 LOG(FATAL, "listen error\n");
80.                 exit(LISTEN_ERROR);
81.             }
82.             LOG(INFO, "listen success\n");
83.         }
84.         SockSPtr Accepter(InetAddr* cliaddr) override
85.         {
86.             struct sockaddr_in client;
87.             socklen_t len = sizeof(client);
88.             //4.获取新连接
89.             int sockfd = ::accept(_sockfd, (struct sockaddr*)&client, &len);
90.             if(sockfd < 0)
91.             {
92.                 LOG(WARNING, "accept error\n");
93.                 return nullptr;
94.             }
95.             *cliaddr = InetAddr(client);
96.             LOG(INFO, "get a new link, client info: %s, sockfd is %d\n", cliaddr->AddrStr().c_str(), sockfd);
97.             return std::make_shared<TcpSocket>(sockfd);
98.         }
99.         bool Connector(const std::string& peerip, uint16_t peerport) override
100.         {
101.             struct sockaddr_in server;
102.             memset(&server,0, sizeof(server));
103.             server.sin_family = AF_INET;
104.             server.sin_port = htons(peerport);
105.             ::inet_pton(AF_INET, peerip.c_str(), &server.sin_addr);
107.             int n = ::connect(_sockfd, (struct sockaddr*)&server, sizeof(server));
108.             if(n < 0)
109.             {
110.                 return false;
111.             }
112.             return true;
114.         }
115.     private:
116.         int _sockfd; //可以是监听套接字，也可以是普通套接字
117.     };
118. }

复制代码

首先我们先计划一个Socket基类，里面有多少个虚函数，并且计划了计划了建立监听套接字和客户端套接字函数，对这些虚函数举行了封装。
在Protocol.hpp中，我们要界说好协议：

1. //struct request req = {10, 20, '+'}
2. struct request
3. {
4.     int x;
5.     int y;
6.     char oper; // + - * / %
7. };
9. struct response
10. {
11.     int result;
12.     int code; // 0:success 1:div zero 2:非法操作
13. };

复制代码

在Request中，客户端将来要将请求发给别人，因此要序列化。服务器也要读到请求，因此要反序列化。在Response中，服务器要发相应给客户端，因此要序列化。客户端要读到相应，因此要反序列化。
序列化的目标是将结构化的字段转化为字符串，反序列化的目标是将字符串转化为结构化的字段。要把结构化的字段转化为字符串，既可以手动，也可以利用现成的工具。我们选择jsoncpp库来实现序列化和反序列化，主要缘故原由是简单并且效果可视。
接下来，我们先来看一下序列化的效果：

这种{"oper":43,"x":111,"y":222}的字符串，我们称之为json串。
别的，我们还可以再json中套json，比如：

我们再来看看怎样反序列化：

在做完Request的序列化和反序列化后，我们可以类似做一些Response的序列化和反序列化：

1. class Response
2. {
3. public:
4.     Response()
5.     {
6.     }
7.     bool Serialize(std::string* out)
8.     {
9.         Json::Value root;
10.         root["result"] = _result;
11.         root["code"] = _code;
12.         root["_desc"] = _desc;
14.         Json::FastWriter writer;
15.         std::string s = writer.write(root); // 把结构化的字段root转换为字符串
16.         *out = s;
17.         return true;
18.     }
19.      bool Deserialize(const std::string& in)
20.     {
21.         Json::Value root;
22.         Json::Reader reader;
23.         bool res = reader.parse(in, root);
24.         if(!res) return false;
26.         _result = root["result"].asInt();
27.         _code = root["code"].asInt();
28.         _desc = root["desc"].asString();
29.         return true;
30.     }
31.     ~Response()
32.     {
33.     }
35. private:
36.     int _result;
37.     int _code; // 0:success 1:div zero 2:非法操作
38.     std::string _desc;
39. };

复制代码

可是，我们怎么包管读到的是一个完整的报文呢？如果是不完整的报文怎么办？所以，我们要继续计划一下协媾和报文的完整格式：

1. "len"\r\n"{json}"\r\n -- 完整的报文

复制代码

此中，len是一个报文有效载荷的长度（json串的长度），我们可以先根据\r\n的位置读到"len"，知道有效载荷的长度之后，就知道接下来必要读取多少字节了。如果后面的json串不完整（长度小于len），就不处置惩罚，等客户端再发一点再处置惩罚。第一个\r\n是为了区分len和json串，第二个\r\n临时没有其他用处，是为了打印方便，便于debug。
为了统一成这样的格式，我们首先要对json串举行处置惩罚：

1. std::string Encode(const std::string& jsonstr)
2. {
3.     int len = jsonstr.size();
4.     std::string lenstr = std::to_string(len);
5.     return lenstr + sep + jsonstr + sep;
6. }

复制代码

然后必要对字符串举行解码，然而传过来的字符串可能会出现如下环境：

1. // "le
2. // "len"
3. // "len"\r\n"{json}"\r\n
4. // "len"\r\n"{j
5. // "len"\r\n"{json}"\r\n// "len"\r\n"{js
6. // "len"\r\n"{json}"\r\n// "len"\r\n"{json}"\r\n
7. // "len"\r\n"{json}"\r\n// "len"\r\n"{json}"\r\n// "len"\r\n"{json}"\r\n// "len"\r\n"{json}"\r\

复制代码

如果传过来的字符串有完整的，就提取完整的，否则什么都不做，继续去读，对字符串举行读取：

1. std::string Decode(std::string& packagestream)
2. {
3.     auto pos = packagestream.find(sep);
4.     if(pos == std::string::npos) return std::string();
5.     std::string lenstr = packagestream.substr(0, pos);
6.     int len = std::stoi(lenstr);
7.     //计算一个完整的报文应该是多长
8.     int total = lenstr.size() + len + 2 * sep.size();
9.     if(packagestream.size() < total) return std::string();
10.     std::string jsonstr = packagestream.substr(pos+sep.size(), len);
11.     packagestream.erase(total);//这就是Decode参数不能带const的原因，当提取完一个报文之后，要删掉
12.     return jsonstr;
13. }

复制代码

如果返回字符串，那肯定是一个完整的json串，否则返回空字符串。
对应的IOService如下：

1. using process_t = std::function<std::shared_ptr<Response>(std::shared_ptr<Request>)>;
3. class IOService
4. {
5. public:
6.     IOService(process_t process):_process(process)
7.     {}
8.     void IOExcute(SockSPtr sock, InetAddr& addr)
9.     {
10.         std::string packagestreamqueue;
11.         while(true)
12.         {
13.             //1.负责读取
14.             ssize_t n = sock->Recv(&packagestreamqueue);
15.             if(n <= 0)
16.             {
17.                 LOG(INFO, "client %s quit or recv error\n", addr.AddrStr().c_str());
18.                 break;
19.             }
20.             //我们能保证读到的是一个完整的报文吗？不能！
21.             //2.报文解析，提取报头和有效载荷
22.             std::string package = Decode(packagestreamqueue);
23.             if(package.empty()) continue;
24.             //我们能保证读到的是一个完整的报文吗？能！
25.             auto req = Factory::BuildRequestDafault();
26.             //3.反序列化
27.             req->Deserialize(package);
28.             //4.业务处理
29.             auto resp = _process(req); // 通过请求，得到应答
30.             //5.序列化应答
31.             std::string respjson;
32.             resp->Serialize(&respjson);
33.             //6.添加len长度报头
34.             respjson = Encode(respjson);
35.             //7.发送回去
36.             sock->Send(respjson);
38.         }
39.     }
40.     ~IOService()
41.     {}
43. private:
44.     process_t _process;
45. };

复制代码

 _process用于处置惩罚业务，我们这里是一个计算器。为此，我们要实现一个计算器NetCal.hpp：

1. #pragma once
3. #include "Protocol.hpp"
4. #include <memory>
6. class NetCal
7. {
8. public:
9.     NetCal()
10.     {
11.     }
12.     ~NetCal()
13.     {
14.     }
15.     std::shared_ptr<Response> Calculator(std::shared_ptr<Request> req)
16.     {
17.         auto resp = Factory::BuildResponseDafault();
18.         switch (req->Oper())
19.         {
20.         case '+':
21.             resp->_result = req->X() + req->Y();
22.             break;
23.         case '-':
24.             resp->_result = req->X() - req->Y();
25.             break;
26.         case '*':
27.             resp->_result = req->X() * req->Y();
28.             break;
29.         case '/':
30.         {
31.             if (req->Y() == 0)
32.             {
33.                 resp->_code = 1;
34.                 resp->_desc = "div zero";
35.             }
36.             else
37.             {
38.                 resp->_result = req->X() / req->Y();
39.             }
40.         }
42.         break;
43.         case '%':
44.         {
45.             if (req->Y() == 0)
46.             {
47.                 resp->_code = 2;  
48.                 resp->_desc = "mod zero";
49.             }
50.             else
51.             {
52.                 resp->_result = req->X() / req->Y();
53.             }
54.         }
55.         break;
56.         default:
57.         {
58.             resp->_code = 3;
59.             resp->_desc = "illegal operation";
60.         }
61.         break;
62.         }
63.         return resp;
64.     }
65. };

复制代码

在main函数中：

1. int main(int argc, char* argv[])
2. {
3.     if(argc != 2)
4.     {
5.         std::cerr << "Usage: " << argv[0] << " local-port" << std::endl;
6.         exit(0);
7.     }
8.     uint16_t port = std::stoi(argv[1]);
10.     NetCal cal;
11.     IOService service(std::bind(&NetCal::Calculator, &cal, std::placeholders::_1));
12.      
13.     std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(std::bind(&IOService::IOExcute, &service, std::placeholders::_1,std::placeholders::_2),port);
14.     tsvr->Loop();
16.     return 0;
17. }

复制代码

在我们的代码中，手动划分了三层，为什么可以清晰地划分成三层呢？实在这对应OSI七层模子里的会话层、表示层、应用层。
在客户端主函数数实现中，我们这样做：

1. int main(int argc, char *argv[])
2. {
3.     if (argc != 3)
4.     {
5.         std::cerr << "Usage: " << argv[0] << "server_ip server_port" << std::endl;
6.         exit(0);
7.     }
9.     std::string server_ip = argv[1];
10.     uint16_t server_port = std::stoi(argv[2]);
12.     SockSPtr sock = std::make_shared<TcpSocket>();
13.     if (!sock->BuildClientSocket(server_ip, server_port))
14.     {
15.         std::cerr << "connect error" << std::endl;
16.         exit(1);
17.     }
19.     srand(time(nullptr) ^ getpid());
20.     const static std::string opers = "+-*/%?!";
22.     std::string packagestringstream;
23.     while (true)
24.     {
25.         int x = rand() % 10;
26.         usleep(x * 1000);
27.         int y = rand() % 10;
28.         usleep(x * y * 1000);
29.         char oper = opers[y % opers.size()];
31.         // 构建请求
32.         auto req = Factory::BuildRequestDafault();
33.         req->SetValue(x, y, oper);
35.         // 1.序列化
36.         std::string jsonstr;
37.         req->Serialize(&jsonstr);
38.         // 2.添加长度报头字段
39.         std::string reqstr = Encode(jsonstr);
40.         std::cout << "request string :\n" << reqstr << std::endl;
41.         // 3.发送数据
42.         sock->Send(reqstr);
43.         while (true)
44.         {
45.             // 4.读取应答
46.             ssize_t n = sock->Recv(&packagestringstream);
47.             if (n < 0)
48.             {
49.                 break;
50.             }
51.             //5.报文解析，提取报头和有效载荷
52.             std::string package = Decode(packagestringstream);
53.             if (package.empty())
54.             {
55.                 continue;
56.             }
57.             //6.反序列化
58.             auto resp = Factory::BuildResponseDafault();
59.             resp->Deserialize(package);
61.             //7.打印结果
62.             resp->PrintResult();
63.             break;
64.         }
65.         sleep(1);
66.     }
68.     sock->Close();
70.     return 0;
71. }

复制代码

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

继续阅读请点击广告