• 应用层协议 —— HTTP（一）

    目录

    一、协议

    二、序列化与反序列化 

    三、网络版的计算器

    1. 约定协议

    2. 计算器客户端

    3. 计算器服务端

    一、协议

             协议是一种 "约定". socket api的接口, 在读写数据时, 都是按 "字符串" 的方式来发送接收的. 如果我们要传输一些 "结构化的数据" 怎么办呢?我们就需要对结构化的数据进行打包，然后通过网络发生至对端主机，再进行解包，进而对端主机接收到结构化的数据；我们将打包数据和解包数据的过程称为 序列化 和 反序列化 的过程。

    二、序列化与反序列化 

    序列化：将结构化的数据转换为字节序列（可以理解为是长的‘字符串’）发生到网络；

    反序列化：将网络中的字节序列（可以理解为是长的‘字符串’）转化为结构化的数据； 

            我们可以想象一下，张三在中午的某一时刻想要给李四发一个消息：“吃饭了吗”；本质上是肯定包含上图结构化数据中的内容的；一般来说讲这种结构化的数据发送给李四，是需要经过特殊处理的，那就是序列化，转变为一个长字符串；通过网络传输之后，再次经过反序列化的过程，填入李四的结构化数据相应的位置。至此李四就收到了张三发来的信息；

    序列化与反序列化有何好处：

    • 结构化的数据不便于网络传输；
    • 序列化为了应用层网络通信的方便；
    • 反序列化为了方便上层使用数据；
    • 序列化和反序列化本质就是将应用和网络进行了解耦；

    三、网络版的计算器

            我们通过网络版的计算器这个案例来感受一下序列化与反序列化的过程。这里我们介绍一个序列和反序列化的组件：jsoncpp，它是一个第三方库，需要我们通过yum安装：yum install jsoncpp-devel

    1. #include 
    2. #include 
    3. #include                                                                                                                                                                                                                                   
    4.  
    5. using namespace std;
    6.  
    7. typedef struct request
    8. {
    9.     int x;
    10.     int y;
    11.     char op;
    12. }request_t;
    13.  
    14. int main()
    15. {
    16.     // 序列化的过程
    17.     request_t req = {10, 20, '*'};
    18.     Json::Value root;// 这个对象可以承装任何对象，json是一种kv式序列化的方案
    19.     root["datax"] = req.x;
    20.     root["datay"] = req.y;
    21.     root["operator"] = req.op;
    22.  
    23.     // FastWriter 和 StyledWriter
    24.     //Json::StyledWriter writer; //方法1
    25.     Json::FastWriter writer;     //方法2
    26.     string json_string = writer.write(root); //将结构化的数据转换为字符串形式
    27.     cout << endl << json_string << endl;
    28.  
    29.  
    30.     // 反序列化的过程
    31.  
    32.     string json_string = R"({"datax":10, "datay":20, "operator":42})";//原始字符串
    33.     Json::Reader reader;
    34.     Json::Value root;
    35.  
    36.     reader.parse(json_string, root); 
    37.     request_t req;
    38.     req.x = root["datax"].asInt();
    39.     req.y = root["datay"].asInt();
    40.     req.op = (char)root["operator"].asInt();
    41.  
    42.     cout << req.x << req.op << req.y << endl;
    43.     return 0;
    44. }

    1. 约定协议

            定义协议的过程，就是定制结构化数据的过程；这是我们自己定义的协议，client && server 都必须遵守! 这就叫做自定义协议。

    1. #pragma once 
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. using namespace std;
    7.  
    8. // 请求格式
    9. typedef struct request
    10. {
    11.      int x;
    12.      int y;
    13.      char op;//支持"+-*/%"
    14. }request_t;
    15.  
    16. // 响应格式
    17. typedef struct response
    18. {
    19.      int code;    //表示server运算完毕的计算状态：code(0：success)，code(-1：除0了) 
    20.      int result;  //表示计算结果，能否区分是正常计算结果，还是异常的退出结果
    21. }response_t;
    22.  
    23. // 加入序列化与反序列化
    24.  
    25. // 序列化 ：将request_t 序列化为 string 
    26. string SerializeRequest(const request_t& req)
    27. {
    28.      Json::Value root;// 这个对象可以承装任何对象，json是一种kv式序列化的方案
    29.      root["datax"] = req.x;
    30.      root["datay"] = req.y;
    31.      root["operator"] = req.op;
    32.  
    33.      // FastWriter 和 StyledWriter
    34.      //Json::StyledWriter writer;
    35.      Json::FastWriter writer;
    36.      string json_string = writer.write(root);
    37.      return json_string;
    38. }
    39.  
    40. // 反序列化 ：将string 反序列化为 request_t
    41. void DeserializeRequest(const string &json_string, request_t& out)
    42. {
    43.      Json::Reader reader;
    44.      Json::Value root;
    45.  
    46.      reader.parse(json_string, root);
    47.      out.x = root["datax"].asInt();
    48.      out.y = root["datay"].asInt();
    49.      out.op = (char)root["operator"].asInt();
    50. }
    51.  
    52. // 序列化 ：将response_t 序列化为 string 
    53. string SerializeResponse(const response_t& resp)
    54. {
    55.      Json::Value root;// 这个对象可以承装任何对象，json是一种kv式序列化的方案
    56.      root["code"] = resp.code;
    57.      root["result"] = resp.result;
    58.  
    59.      Json::FastWriter writer;
    60.      string res = writer.write(root);
    61.      return res;
    62. }
    63.  
    64. // 反序列化 ：将string 反序列化为 response_t
    65. void DeserializeResponse(const string &json_string, response_t& out)
    66. {
    67.      Json::Reader reader;
    68.      Json::Value root;
    69.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
    70.      reader.parse(json_string, root);
    71.      out.code = root["code"].asInt();
    72.      out.result = root["result"].asInt();
    73. }

    2. 计算器客户端

    首先我们将套接字的接口函数做一下封装 

    1. #pragma once 
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. using namespace std;
    13.  
    14. class Sock
    15. {
    16. public:
    17.      static int Socket()
    18.      {
    19.          int sock = socket(AF_INET, SOCK_STREAM, 0);
    20.          if(sock < 0)
    21.          {
    22.              cerr << "socket error" << endl;
    23.              exit(2);
    24.          }
    25.          return sock;
    26.      }
    27.  
    28.      static void Bind(int sock, uint16_t port)
    29.      {
    30.          struct sockaddr_in local;
    31.          memset(&local, 0, sizeof(local));
    32.          local.sin_family = AF_INET;
    33.          local.sin_port = htons(port);
    34.          local.sin_addr.s_addr = INADDR_ANY;
    35.  
    36.          if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    37.          {
    38.              cerr << "bind error!" << endl;
    39.              exit(3);
    40.          }
    41.      }
    42.  
    43.      static void Listen(int sock)
    44.      {
    45.          if(listen(sock, 5) < 0)
    46.          {
    47.              cerr << "listen error!" << endl;
    48.              exit(4);
    49.          }
    50.      }
    51.  
    52.      static int Accept(int sock)
    53.      {
    54.          struct sockaddr_in peer;
    55.          socklen_t len = sizeof(peer);
    56.          int fd = accept(sock, (struct sockaddr*)&peer, &len);
    57.          if(fd >= 0)
    58.          {
    59.              return fd;
    60.          }
    61.          return -1;
    62.      }
    63.  
    64.      static void Connect(int sock, string ip, uint16_t port)
    65.      {
    66.          struct sockaddr_in server;
    67.          memset(&server, 0, sizeof(server));
    68.          server.sin_family = AF_INET;
    69.          server.sin_port = htons(port);
    70.          server.sin_addr.s_addr = inet_addr(ip.c_str());
    71.  
    72.          if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
    73.          {
    74.              cout << "Connect Success!" << endl;
    75.          }
    76.          else
    77.          {
    78.              cout << "Connect failed!" << endl;
    79.              exit(5);
    80.          }
    81.      }
    82.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
    83. };

     编写如下的代码：

    1. #include "protocol.hpp"
    2. #include "sock.hpp"
    3.  
    4. void Usage(string proc)
    5. {
    6.      cout << "Usage: " << proc << " server_ip server_port" << endl;
    7. }
    8.  
    9. // ./cal_client server_ip server_port
    10. int main(int argc, char* argv[])
    11. {
    12.      if(argc != 3)
    13.      {
    14.          Usage(argv[0]);
    15.          exit(1);
    16.      }
    17.  
    18.      while(true)
    19.      {
    20.          int sock = Sock::Socket();
    21.          Sock::Connect(sock, argv[1], atoi(argv[2]));
    22.  
    23.          // 业务逻辑
    24.          request_t req;
    25.          memset(&req, 0, sizeof(req));
    26.          cout << "Please Enter Data One：";
    27.          cin >> req.x;
    28.          cout << "Please Enter Data Tow：";
    29.          cin >> req.y;
    30.          cout << "Please Enter operator：";
    31.          cin >> req.op;
    32.  
    33.          string json_string = SerializeRequest(req);
    34.          ssize_t s = write(sock, json_string.c_str(), json_string.size());
    35.  
    36.          char buffer[1024];
    37.          s = read(sock, buffer, sizeof(buffer) - 1);
    38.          if(s > 0)
    39.          {
    40.              response_t resp;
    41.              buffer[s] = 0;
    42.              string str = buffer;
    43.              DeserializeResponse(str, resp);
    44.              cout << "code[0: success]: " << resp.code << endl;
    45.              cout << "result: " << resp.result << endl;
    46.          }
    47.  
    48.      }
    49.      return 0;
    50. }

    3. 计算器服务端

    1.  #include "protocol.hpp"
    2. #include "sock.hpp"
    3. #include 
    4.  
    5. static void Usage(string proc)
    6. {
    7.      cout << "Usage: " << proc << " port" << endl;
    8.      exit(1);
    9. }
    10.  
    11. void* HandlerRequest(void* args)
    12. {
    13.      int sock = *(int*)args;
    14.      delete (int*)args;
    15.      pthread_detach(pthread_self());
    16.  
    17.      // 发起request -> 分析出了 -> 构建response -> sent(response) -> close(sock)
    18.      while(true)
    19.      {
    20.          // 1.读取请求
    21.          char buffer[1024];
    22.          request_t req;
    23.          ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    24.          if(s > 0)
    25.          {
    26.              buffer[s] = 0;
    27.              cout << "get a new request: " << buffer << endl;
    28.              string str = buffer;
    29.              DeserializeRequest(str, req);
    30.  
    31.              //request_t req;
    32.              //ssize_t s = read(sock, &req, sizeof(req));
    33.  
    34.              // 2.分析请求 && 3.计算结果
    35.              response_t resp = {0, 0};
    36.              switch(req.op)
    37.              {
    38.                  case '+':
    39.                      resp.result = req.x + req.y;
    40.                      break;
    41.  
    42.                  case '-':
    43.                       resp.result = req.x - req.y;
    44.                      break;
    45.  
    46.                  case '*':
    47.                      resp.result = req.x * req.y;
    48.                      break;
    49.  
    50.                  case '/':
    51.                      if(req.y == 0)
    52.                          resp.code = -1; //代表除0
    53.                      else
    54.                          resp.result = req.x / req.y;
    55.                      break;
    56.  
    57.                  case '%':
    58.                      if(req.y == 0)
    59.                          resp.code = -2; //代表模0
    60.                      else
    61.                          resp.result = req.x % req.y;
    62.                      break;
    63.  
    64.                  default:
    65.                      resp.code = -3; //代表请求方法异常
    66.                      break;
    67.  
    68.              }
    69.              // 4.构建响应，并进行返回
    70.              cout << "request: " << req.x << req.op << req.y << endl;
    71.              //write(sock, &resp, sizeof(resp));
    72.              string send_string = SerializeResponse(resp);//序列化之后的字符串
    73.              write(sock, send_string.c_str(), send_string.size());
    74.  
    75.              cout << "服务结束" << send_string << endl;
    76.          }
    77.          // 5.关闭链接
    78.          close(sock);
    79.      }
    80.      return 0;
    81. }
    82.  
    83. int main(int argc, char* argv[])
    84. {
    85.      if(argc != 2)
    86.      {
    87.          Usage(argv[0]);
    88.      }
    89.  
    90.      uint16_t port = atoi(argv[1]);
    91.      int listen_sock = Sock::Socket();
    92.      Sock::Bind(listen_sock, port);
    93.      Sock::Listen(listen_sock);
    94.  
    95.      for( ; ; )
    96.      {
    97.          int sock = Sock::Accept(listen_sock);
    98.          if(sock >= 0)
    99.          {
    100.              cout << "get a new link..." << endl;
    101.              int* pram = new int(sock);
    102.              pthread_t tid;
    103.              pthread_create(&tid, nullptr, HandlerRequest, pram);
    104.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
    105.          }
    106.      }
    107.  
    108.      return 0;
    109. }

            虽然我们说, 应用层协议是我们程序猿自己定的。但实际上, 已经有大佬们定义了一些现成的, 又非常好用的应用层协议, 供我们直接参考使用。HTTP(超文本传输协议)就是其中之一。
  • 相关阅读:
    Linux线程1
    CentOS上升级glibc2.17至glibc2.31
    数字图标的使用（阁瑞钛伦特软件-九耶实训）
    Alook获取站点cookie详细教程
    消息队列 RabbitMQ 遇上可观测--业务链路可视化
    百位上的数字（蓝桥杯真题）
    Java实现一个简单的GitHub仓库信息爬取
    计算机毕业设计 基于协同推荐的白酒销售管理系统的设计与实现 Java实战项目 附源码+文档+视频讲解
    Linux系统调试篇——GDBSERVER远程调试
    “2022锦江行”，维也纳国际酒店、丽柏酒店惊艳同台，中高端酒店再出标杆示范
  • 原文地址：https://blog.csdn.net/sjsjnsjnn/article/details/127102673