【Linux】深入理解网络编程：应用层自定义协议、序列化、TCP粘包题目与Sock ...

目次
1.应用层
1.1.再谈应用层
1.2.再谈“协议”
2.初识序列化与反序列化
2.1.基本概念
为什么要转换成字符串在发送呢？
2.2.重新理解 read、write、recv、send 和 tcp 为什么支持全双工
我们的read大概recv为什么会壅闭？
2.3.如何办理粘包题目
2.3.1编码操作：
2.3.2.解码操作
2.4.如何使用Json举行序列化和反序列化
2.4.1.序列化
2.4.2.反序列化
3.封装socket类
3.1.封装头脑
3.2.基本框架
3.3.代码实现

1.应用层

1.1.再谈应用层

我们程序员写的一个个办理我们现实题目, 满意我们日常需求的网络程序, 都是在应用层。
1.2.再谈“协议”

根据前面的知识我们知道了协议是一种 "约定"。
socket api 的接口, 在读写数据时, 都是按 "字符串" 的方式来发送接收的。 假如我们要传输一些 "结构化的数据" 怎么办呢？
协议的真正概念：
其实，协议就是双方约定好的结构化的数据！
2.初识序列化与反序列化

2.1.基本概念

• 序列化：把信息由多变一，方便网络发送。
  
• 反序列化：把信息由一变多，方便上层处理。
  

举个例子：
例如, 我们需要实现一个服务器版的加法器. 我们需要客户端把要盘算的两个加数发过去, 然后由服务器举行盘算, 最后再把结果返回给客户端。
约定方案：

• 定义结构体来表示我们需要交互的信息;
  
• 发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时间再按照相同的规则把字符串转化回结构体;
  

这就是序列化和反序列化！
为什么要转换成字符串在发送呢？

向上通过反序列化读取消息，向下通过序列化包装消息。而TCP/UDP不关心发送的是什么，都按照字符串举行传输！
2.2.重新理解 read、write、recv、send 和 tcp 为什么支持全双工

• 在任何一台主机上，TCP 毗连既有发送缓冲区，又有接受缓冲区，以是，在内核中，可以在发消息的同时，也可以收消息，即全双工
  
• 这就是为什么一个 tcp sockfd 读写都是它的缘故原由
  
• 现实数据什么时间发，发多少，出错了怎么办，由 TCP 控制，以是 TCP 叫做传输控制协议。这就体现控制！传输层的题目都是由OS自主来决定的！
  

tcp能接受全双工的本质缘故原由是因为TCP毗连各有一对发送缓冲区和接受缓冲区。
tcp发送数据的本质：将自己的发送缓冲区拷贝到接收方的接受缓冲区中！
通信的本质就是拷贝！！！
read、write、recv、send本质是拷贝函数！
我们的read大概recv为什么会壅闭？

因为缓冲区中没有数据，壅闭的本质就是用户层在同步！
Tcp设计也是符合生产者消费者模子！因为发送缓冲区和接收缓冲区都是属于操作系统的，以是肯定是临界资源！会有多个生产者，多个消费者！而IO发生壅闭也就是为了维护同步关系，保证缓冲区的正确使用！
接受的时间，我们还需要办理一个题目，保证我们拿到的是一个完整请求！
举个例子：
对方的接收缓冲区写满了，对方不停不读，那么我们的发送缓冲区就积存了许多同样的请求，假如一次性革新过去，对方就读取到多条信息；又大概只发送了一条请求的一半过去，那么接受方读取就读取一半了，就不可能举行反序列化！这个过程就叫面向字节流！！！
以是怎么保证读取的是一个完整的请求呢？？？
这就是经典的TCP的粘包题目了！
2.3.如何办理粘包题目

需要我们自定义协议出马了！（协议的再理解）
   我们自己规定协议如下：
  报文 = 报头+有用载荷
  "有用载荷的长度"\r\n"有用载荷"\r\n 
  "len"\r\n"_x _op _y"\r\n  -> len: 有用载荷的长度，约定\r\n是分隔符，不参与统计
  2.3.1编码操作：

我们自己利用自定义协议将报文封装起来，方便解码判断是否是一个完整的报文。
编码后的报文：
有用载荷的长度 + 分隔符 + 有用载荷 + 分隔符

1.     const std::string SEP = "\r\n";
3.     // 我们把tcp中读到的报文，可能读到半个，也可能读到1个半个， TCP 粘报问题
4.     // 解决TCP的粘报问题
5.     std::string Encode(const std::string &json_str)
6.     {
7.         int json_str_len = json_str.size();
8.         std::string proto_str = std::to_string(json_str_len);
9.         proto_str += SEP;
10.         proto_str += json_str;
11.         proto_str += SEP;
12.         return proto_str;
13.     }

复制代码

2.3.2.解码操作

根据我们自己定义的协议，分离报头，分隔符后，看是否是一个完整的报头。
假如输入流还有内容，我们只需要从输入流中提取出一个完整的请求，剩余留着下一次处理！

1.     std::string Decode(std::string &inbuffer)
2.     {
3.         auto pos = inbuffer.find(SEP);
4.         if (pos == std::string::npos)
5.             return std::string();
6.         std::string len_str = inbuffer.substr(0, pos);
7.         if (len_str.empty())
8.             return std::string();
9.         int packlen = std::stoi(len_str);
11.         int total = packlen + len_str.size() + 2 * SEP.size();
12.         if (inbuffer.size() < total)
13.             return std::string();
15.         std::string package = inbuffer.substr(pos + SEP.size(), packlen);
16.         inbuffer.erase(0, total);
17.         return package;
18.     }

复制代码

2.4.如何使用Json举行序列化和反序列化

下面重要是重要代码
2.4.1.序列化

1.         bool Serialize(std::string *out)
2.         {
3.             // 转换成为字符串
4.             Json::Value root;
5.             root["result"] = _result;
6.             root["code"] = _code;
8.             Json::FastWriter writer;
9.             // Json::StyledWriter writer;
10.             *out = writer.write(root);
11.             return true;
12.         }

复制代码

2.4.2.反序列化

1.         bool Deserialize(const std::string &in)
2.         {
3.             Json::Value root;
4.             Json::Reader reader;
5.             bool res = reader.parse(in, root);
6.             if (!res)
7.                 return false;
9.             _result = root["result"].asInt();
10.             _code = root["code"].asInt();
11.             return true;
12.         }

复制代码

3.封装socket类

3.1.封装头脑

将socket系列操作分类封装,设计为基类，派生出Tcp和Udp两种具体的Socket！基类都需要举行创建socket文件 、举行绑定、 进入listen 、获取链接、 申请链接…由于两种类的操作方式不一致，以是基类只需要举行一个声明就可以，具体实现在派生类中完成！
以后直接调用相应接口即可，非常优雅！TcpSocket继承Socket类 成员变量 sockfd
3.2.基本框架

通过这些操作的组合，可以举行建立监听链接 ，建立客户端毗连等操作，十分方便！这种设计模式是模版方法设计模式！！！

3.3.代码实现

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <functional>
6. #include <sys/types.h> /* See NOTES */
7. #include <sys/socket.h>
8. #include <netinet/in.h>
9. #include <arpa/inet.h>
10. #include <unistd.h>
11. #include <cstring>
12. #include <pthread.h>
13. #include <sys/types.h>
14. #include <memory>
15. #include "InetAddr.hpp"
16. #include "Log.hpp"
18. // 模版方法模式
19. namespace socket_ns
20. {
21.     class Socket;
22.     const static int gbacklog = 8;
23.     using socket_sptr = std::shared_ptr<Socket>;
25.     enum
26.     {
27.         SOCKET_ERROR = 1,
28.         BIND_ERROR,
29.         LISTEN_ERROR,
30.         USAGE_ERROR
31.     };
33.     // std::unique_ptr<Socket> listensock = std::make_unique<TcpSocket>();
34.     // listensock->BuildListenSocket();
36.     // std::unique_ptr<Socket> clientsock = std::make_unique<TcpSocket>();
37.     // clientsock->BuildClientSocket();
39.     // clientsock->send();
40.     // clientsock->Recv();
42.     class Socket
43.     {
44.     public:
45.         virtual void CreateSocketOrDie() = 0;
46.         virtual void BindSocketOrDie(InetAddr &addr) = 0;
47.         virtual void ListenSocketOrDie() = 0;
48.         virtual socket_sptr Accepter(InetAddr *addr) = 0;
49.         virtual bool Connetcor(InetAddr &addr) = 0;
50.         virtual void SetSocketAddrReuse() = 0;
51.         virtual int SockFd() = 0;
52.         virtual int Recv(std::string *out) = 0;
53.         virtual int Send(const std::string &in) = 0;
54.         virtual void Close() = 0;
56.         // virtual void Recv() = 0;
57.         // virtual void Send() = 0;
58.         // virtual void other() = 0;
60.     public:
61.         void BuildListenSocket(InetAddr &addr)
62.         {
63.             CreateSocketOrDie();
64.             SetSocketAddrReuse();
65.             BindSocketOrDie(addr);
66.             ListenSocketOrDie();
67.         }
68.         bool BuildClientSocket(InetAddr &addr)
69.         {
70.             CreateSocketOrDie();
71.             return Connetcor(addr);
72.         }
73.         // void BuildUdpSocket()
74.         // {
75.         //     CreateSocketOrDie();
76.         //     BindSocketOrDie();
77.         // }
78.     };
80.     class TcpSocket : public Socket
81.     {
82.     public:
83.         TcpSocket(int fd = -1) : _sockfd(fd)
84.         {
85.         }
86.         void CreateSocketOrDie() override
87.         {
88.             // 1. 创建流式套接字
89.             _sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
90.             if (_sockfd < 0)
91.             {
92.                 LOG(FATAL, "socket error");
93.                 exit(SOCKET_ERROR);
94.             }
95.             LOG(DEBUG, "socket create success, sockfd is : %d\n", _sockfd);
96.         }
97.         void BindSocketOrDie(InetAddr &addr) override
98.         {
99.             // 2. bind
100.             struct sockaddr_in local;
101.             memset(&local, 0, sizeof(local));
102.             local.sin_family = AF_INET;
103.             local.sin_port = htons(addr.Port());
104.             local.sin_addr.s_addr = inet_addr(addr.Ip().c_str());
106.             int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
107.             if (n < 0)
108.             {
109.                 LOG(FATAL, "bind error\n");
110.                 exit(BIND_ERROR);
111.             }
112.             LOG(DEBUG, "bind success, sockfd is : %d\n", _sockfd);
113.         }
114.         void ListenSocketOrDie() override
115.         {
116.             int n = ::listen(_sockfd, gbacklog);
117.             if (n < 0)
118.             {
119.                 LOG(FATAL, "listen error\n");
120.                 exit(LISTEN_ERROR);
121.             }
122.             LOG(DEBUG, "listen success, sockfd is : %d\n", _sockfd);
123.         }
124.         socket_sptr Accepter(InetAddr *addr) override
125.         {
126.             struct sockaddr_in peer;
127.             socklen_t len = sizeof(peer);
128.             int sockfd = ::accept(_sockfd, (struct sockaddr *)&peer, &len);
129.             if (sockfd < 0)
130.             {
131.                 LOG(WARNING, "accept error\n");
132.                 return nullptr;
133.             }
134.             *addr = peer;
135.             socket_sptr sock = std::make_shared<TcpSocket>(sockfd);
136.             return sock;
137.         }
138.         virtual bool Connetcor(InetAddr &addr)
139.         {
140.             // tcp client 要bind，不要显示的bind.
141.             struct sockaddr_in server;
142.             // 构建目标主机的socket信息
143.             memset(&server, 0, sizeof(server));
144.             server.sin_family = AF_INET;
145.             server.sin_port = htons(addr.Port());
146.             server.sin_addr.s_addr = inet_addr(addr.Ip().c_str());
148.             int n = connect(_sockfd, (struct sockaddr *)&server, sizeof(server));
149.             if (n < 0)
150.             {
151.                 std::cerr << "connect error" << std::endl;
152.                 return false;
153.             }
154.             return true;
155.         }
156.         void SetSocketAddrReuse() override
157.         {
158.             int opt = 1;
159.             ::setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
160.         }
161.         int Recv(std::string *out) override
162.         {
163.             char inbuffer[4096];
164.             ssize_t n = ::recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
165.             if (n > 0)
166.             {
167.                 inbuffer[n] = 0;
168.                 *out = inbuffer; // ??? +=
169.             }
170.             return n;
171.         }
172.         int Send(const std::string &in) override
173.         {
174.             int n = ::send(_sockfd, in.c_str(), in.size(), 0);
175.             return n;
176.         }
177.         int SockFd() override
178.         {
179.             return _sockfd;
180.         }
181.         void Close() override
182.         {
183.             if (_sockfd > -1)
184.                 ::close(_sockfd);
185.         }
187.     private:
188.         int _sockfd;
189.     };
191.     // class SocketFactor
192.     // {
193.     // public:
194.     //     void Build
195.     // }
196. } // namespace socket_ns

复制代码

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