0
0

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

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
标签： 服务器 运维 网络协议
本文转载自: https://blog.csdn.net/hanwangyyds/article/details/143640327
版权归原作者 可涵不会debug 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Linux】深入理解网络编程：应用层自定义协议、序列化、TCP粘包问题与Socket封装”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？