• 网络协议定制

    目录

    一、协议定制

    1.再谈协议

    2.认识序列化与反序列化

    二、网络计算器

    1.序列化与反序列化头文件

    2.服务端

    3.客户端

    4.makefile

    5.运行结果

    三、json序列化与反序列化

    1.常用序列化与反序列化库

    2.安装

    3.使用

    （1）Request的序列化

    （2）Request的反序列化

    一、协议定制

    1.再谈协议

    协议本质是一种“约定”，在前面的TCP和UDP网络通信中，读写数据的时候都是按照"字符串"的形式发送和接收的，那我们如果不发送字符串，而是要传送一些结构化的数据怎么办呢？

    比如说，我们观察QQ或微信的聊天窗口，屏幕上的信息包括头像(url)、时间、昵称、消息等。

    用户发送的消息虽然大部分是字符串，但是经过用户层(QQ或微信软件)处理后，还需要增加头像，时间，昵称等信息。如果我们将这几个信息看做多个字符串，那么就可以将这多个字符串形成一个结构化的数据，比如下面示例的struct message。

    此时网络中发送的就不再只是一个字符串，而是像类变量这样的复杂结构。

    1. struct message
    2. {
    3.     string url;
    4.     string time;
    5.     string nickname;
    6.     string msg;
    7. };

    2.认识序列化与反序列化

    序列化：将任意类型的数据或者数据结构转换成一个字符串。

    由于系统调用接口的限制，在发送这样的结构体之前，必须将结构化的数据序列化，然后才能通过socket发送到网络中。

    比如用户用微信A向用户B发送信息，微信就创建了一个上面的message结构体。序列化可将所有成员合并成一个字符串报文，网络再将序列化后的数据发送给用户B。

    反序列化：将一个字符串中不同信息类型的字串提取出来，并且还原回结构化类型的数据。

    用户B接收到一个字符串报文，然后用户B的应用层(微信软件)将接收到的报文反序列化，还原回原来结构化的message结构体，此时微信就能将对应数据显示在不同位置，用户B就可以看到这些信息。

    对于面向字节流的TCP协议，业务结构数据在发送到网络中的时候，需要先序列化。接收方收到的是序列化后的字节流，要先进行反序列化才能使用。

    由于UDP协议面向数据报，所以无需进行序列化以及反序列化。

    在微信聊天的过程中，用户A发送的与用户B接受的都是同一种数据结构，所以用户A构建的message是按照特定的成员顺序组成的，用户B就必须按照这样的成员顺序去使用它接收到的message。

    所以我们可以说，这样的通信“约定”就是一个用户层的协议，者个协议的载体就是message结构体。

    二、网络计算器

    我们使用之前写过的tcp通信客户端和服务端的多进程版本实现这个网络计算器。

    数据的处理与流转过程大致如下：

    用户输入计算式（比如：1+1）->构造一个Request变量->序列化为字符串"a op b"

    ->添加报头转化为报文"content_len"\r\n"a op b"\r\n->将报文发给服务端

    服务端接收报文->去掉报头得到正文"a op b"->反序列化为Request变量->服务端使用计算函数处理Request变量得到Response变量->Response变量序列化为字符串"exitcode result"->添加报头转化为报文"content_len"\r\n"exitcode result"\r\n->将报文发给客户端

    客户端接收报文->去掉报头得到正文"exitcode result"->反序列化为Response变量->打印Response变量的内容。

    下面的代码中有详细的注释介绍

    1.序列化与反序列化头文件

    protocol.hpp

    1. #pragma once
    2. #define MYSELF
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define SEP " "
    11. #define SEP_LEN strlen(SEP) //使用sizeof()多了一个\0
    12. #define LINE_SEP "\r\n"
    13. #define LINE_SEP_LEN strlen(LINE_SEP) //使用sizeof()多了一个\0
    14.  
    15. enum
    16. {
    17.     OK = 0,
    18.     DIV_ZERO,
    19.     MOD_ZERO,
    20.     OP_ERROR
    21. };
    22.  
    23. //"content" 转化为 "content_len"\r\n"content"\r\n
    24. //加上报头
    25. std::string enlength(const std::string &text)
    26. {
    27.     //按"content_len"\r\n"content"\r\n拼接字符串
    28.     std::string send_string = std::to_string(text.size());
    29.     send_string += LINE_SEP;
    30.     send_string += text;
    31.     send_string += LINE_SEP;
    32.     return send_string;
    33. }
    34.  
    35. //"content_len"\r\n"content"\r\n 转化为 "content"
    36. //去掉报头
    37. bool delength(const std::string &package, std::string *text)
    38. {
    39.     //查找左侧的\r\n
    40.     auto pos = package.find(LINE_SEP);
    41.     if (pos == std::string::npos)
    42.         return false;//没找到表明数据有问题
    43.     //截取正文长度的字符串并转为整形
    44.     std::string text_len_string = package.substr(0, pos);
    45.     int text_len = std::stoi(text_len_string);
    46.     //截取正文放入储存正文的string里
    47.     *text = package.substr(pos + LINE_SEP_LEN, text_len);
    48.     return true;
    49. }
    50.  
    51. class Request
    52. {
    53. public:
    54.     Request()
    55.         :_a(0)
    56.         ,_b(0)
    57.         ,_op(0)
    58.     {}
    59.  
    60.     Request(int a, int b, char op)
    61.         :_a(a)
    62.         ,_b(b)
    63.         ,_op(op)
    64.     {}
    65.     
    66.     //Request序列化
    67.     //Request结构体转化为字符串"a op b"
    68.     bool serialize(std::string *out)
    69.     {
    70.         out->clear();//清空
    71.         
    72.         //将变量转为字符串
    73.         std::string a_string = std::to_string(_a);
    74.         std::string b_string = std::to_string(_b);
    75.  
    76.         *out = a_string;
    77.         *out += SEP;
    78.         *out += _op;
    79.         *out += SEP;
    80.         *out += b_string;
    81.         return true;
    82.     }
    83.  
    84.     //Request反序列化
    85.     //字符串"a op b"转化为Request结构体
    86.     bool deserialize(const std::string &in)
    87.     {
    88.         auto left = in.find(SEP);//查找左侧的SEP
    89.         auto right = in.rfind(SEP);//查找右侧的SEP
    90.         if (left == std::string::npos || right == std::string::npos)
    91.             return false;//找不到，数据有问题
    92.         if (left == right)
    93.             return false;//只有一个SEP，数据有问题
    94.         if ((right - 1) != (left + SEP_LEN))//在字符串"a op b"中，right - 1和left + SEP_LEN都指向op
    95.             return false;//指向的不是一个位置，数据有问题
    96.  
    97.         //按左闭右开的方式构造两个数字
    98.         std::string a_string = in.substr(0, left);
    99.         std::string b_string = in.substr(right + SEP_LEN);
    100.  
    101.         //读取到的数字不能为空
    102.         if (a_string.empty() || b_string.empty())
    103.             return false;
    104.  
    105.         //填入数据
    106.         _a = std::stoi(a_string);
    107.         _b = std::stoi(b_string);
    108.         _op = in[left + SEP_LEN];
    109.         return true;
    110.     }
    111.  
    112. public:
    113.     int _a;
    114.     int _b;
    115.     char _op;
    116. };
    117.  
    118. class Response
    119. {
    120. public:
    121.     Response()
    122.         :_exitcode(0)
    123.         ,_result(0)
    124.     {}
    125.     
    126.     Response(int exitcode, int result)
    127.         :_exitcode(exitcode)
    128.         ,_result(result)
    129.     {}
    130.  
    131.     //Response序列化
    132.     //Response结构体转化为字符串"exitcode result"
    133.     bool serialize(std::string *out)
    134.     {
    135.         out->clear();//清空
    136.  
    137.         //将变量转为字符串
    138.         std::string ec_string = std::to_string(_exitcode);
    139.         std::string res_string = std::to_string(_result);
    140.  
    141.         //拼接字符串
    142.         *out = ec_string;
    143.         *out += SEP;
    144.         *out += res_string;
    145.  
    146.         return true;
    147.     }
    148.  
    149.     //Response反序列化
    150.     //字符串"exitcode result"转化为Response结构体
    151.     bool deserialize(const std::string &in)
    152.     {
    153.         auto mid = in.find(SEP);//查找中间的SEP
    154.         if (mid == std::string::npos)
    155.             return false;//找不到，出错
    156.  
    157.         //按左闭右开的方式构造两个数字
    158.         std::string ec_string = in.substr(0, mid);
    159.         std::string res_string = in.substr(mid + SEP_LEN);
    160.  
    161.         //读取到的退出码和计算结果不能为空
    162.         if (ec_string.empty() || res_string.empty())
    163.             return false;
    164.  
    165.         //填入数据
    166.         _exitcode = std::stoi(ec_string);
    167.         _result = std::stoi(res_string);
    168.  
    169.         return true;
    170.     }
    171.  
    172. public:
    173.     int _exitcode; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
    174.     int _result;   // 计算结果
    175. };
    176.  
    177. //接收的数据："content_len"\r\n"a op b"\r\n ......
    178. bool recvpackage(int sock, std::string &inbuffer, std::string *text)
    179. {
    180.     char buffer[1024];//接收网络数据的字符串
    181.     while (true)
    182.     {
    183.         ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);//接收数据
    184.         if (n > 0)//读到了数据
    185.         {
    186.             buffer[n] = 0;
    187.             inbuffer += buffer;//以追加的方式放入缓冲区ibuffer
    188.             auto pos = inbuffer.find(LINE_SEP);//查找LINE_SEP，就是\r\n
    189.             if (pos == std::string::npos)
    190.                 //如果没有找到LINE_SEP，就说明报文"content_len"的部分可能没有读全
    191.                 continue;//接着到最开始读数据直到读全
    192.             
    193.             //执行至此时，报文"content_len"\r\n这部分一定读全了
    194.             //可以将"content_len"的部分取出来并转化为整形
    195.             std::string text_len_string = inbuffer.substr(0, pos);
    196.             int text_len = std::stoi(text_len_string);
    197.  
    198.             //我们现在知道了报文中正文部分的长度，所以就能确定我们读到的是否是一个完整的报文
    199.             //一个报文的组成为：text_len_string + "\r\n" + text + "\r\n"
    200.             //所以，只要缓冲区ibuffer的内容多于一个报文的字符个数，我们就必定保证ibuffer中已经存在了一个完整的报头;
    201.             int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
    202.             std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;
    203.             if (inbuffer.size() < total_len)
    204.             {
    205.                 std::cout << "输入的消息没有遵守协议，正在等待后续内容" << std::endl;
    206.                 continue;//报文没读全继续到上面读取
    207.             }
    208.  
    209.             //此时缓冲区中就至少有一个完整的报文
    210.             *text = inbuffer.substr(0, total_len);//将一个完整报文构建子串放入输出参数中
    211.             inbuffer.erase(0, total_len);//删除缓冲区中的完整报文
    212.             std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;
    213.             break;//准备处理报文，跳出循环
    214.         }
    215.         else//没读到数据
    216.             return false;
    217.     }
    218.     return true;
    219. }

    2.服务端

    server.hpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13. #include"log.hpp"
    14. #include"protocol.hpp"
    15.  
    16. using namespace std;
    17.  
    18. enum errorcode
    19. {
    20.     USAGE_ERROR = 1,
    21.     SOCKET_ERROR,
    22.     BIND_ERROR,
    23.     LISTEN_ERROR
    24. };
    25.  
    26. static const uint16_t given_port = 8080;
    27. static const int given_backlog = 5;
    28. typedef function<bool(const Request&, Response&)> func_t;
    29.  
    30. void handler_enter(func_t func, int sock)
    31. {
    32.     std::string inbuffer;//缓冲区
    33.     while (true)
    34.     {
    35.        //第一步，读取一个完整的"content_len"\r\n"a op b"\r\n字符串请求
    36.         std::string req_text;//原数据
    37.         std::string req_str;//正文
    38.         //使用recvPackage接收数据并将一个完整的请求放入req_text
    39.         if (!recvpackage(sock, inbuffer, &req_text))
    40.             return;//函数执行错误，退出
    41.         //打印该请求，让我们看到执行流程
    42.         std::cout << "未去掉报头的请求:\n" << req_text << std::endl;
    43.         //将字符串转化为格式化数据保存在req_text内
    44.         if (!delength(req_text, &req_str))
    45.             return;//函数执行错误，退出
    46.         //打印，让我们看到执行流程
    47.         std::cout << "已去掉报头的正文:\n" << req_str << std::endl;
    48.  
    49.         //第二步，对Request进行反序列化
    50.         Request req;
    51.         if (!req.deserialize(req_str))//将正文信息填入req内
    52.             return;//函数执行错误，退出
    53.  
    54.         //第三步，利用func函数处理请求结构体
    55.         Response resp;
    56.         func(req, resp);//将req的处理结果放入resp
    57.  
    58.         //第四步，对Response进行序列化
    59.         std::string resp_str;
    60.         resp.serialize(&resp_str);//将序列化后的结构题放入resp_str
    61.         std::cout << "计算完成, 序列化后的信息为:\n" <<  resp_str << std::endl;
    62.  
    63.         //将序列化的Response加上报头并发回客户端
    64.         std::string send_string = enlength(resp_str);//加报头
    65.         std::cout << "构建完成完整的响应\n" <<  send_string << std::endl;//打印加上报头后的信息
    66.         send(sock, send_string.c_str(), send_string.size(), 0);//发回
    67.     }
    68. }
    69.  
    70. class tcpserver
    71. {
    72. public:
    73.     //构造函数
    74.     tcpserver(const uint16_t& port = given_port)
    75.         :_port(port)
    76.         ,_listensock(-1)
    77.     {}
    78.  
    79.     //初始化服务端进程
    80.     void initserver()
    81.     {
    82.         _listensock = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    83.         if(_listensock < 0)//创建套接字失败打印错误原因
    84.         {
    85.             logmessage(FATAL, "create socket error");//socket失败属于最严重的错误
    86.             exit(SOCKET_ERROR);//退出
    87.         }
    88.         logmessage(NORMAL, "create socket success:%d", _listensock);//创建套接字成功，打印让用户观察到
    89.  
    90.         struct sockaddr_in local;//储存本地网络信息
    91.         local.sin_family = AF_INET;//通信方式为网络通信
    92.         local.sin_port = htons(_port);//将网络字节序的端口号填入
    93.         local.sin_addr.s_addr = INADDR_ANY;//INADDR_ANY就是ip地址0.0.0.0的宏
    94.         if(bind(_listensock, (struct sockaddr*)&local, sizeof(local)) < 0)//绑定IP，不成功打印信息
    95.         {
    96.             logmessage(FATAL, "bind socket error");//bind失败也属于最严重的错误
    97.             exit(BIND_ERROR);//退出
    98.         }
    99.         logmessage(NORMAL, "bind socket success");//绑定IP成功，打印让用户观察到
    100.  
    101.         //_listensock用于监听，不是用于通信的端口号
    102.         //listen函数可设置socket为监听模式
    103.         if(listen(_listensock, given_backlog) < 0) // 第二个参数backlog后面在填这个坑
    104.         {
    105.             logmessage(FATAL, "listen socket error");
    106.             exit(LISTEN_ERROR);
    107.         }
    108.         logmessage(NORMAL, "listen socket success");
    109.     }
    110.  
    111.     //启动服务端进程，多进程版本
    112.     void start(func_t func)
    113.     {
    114.         while(1)
    115.         {
    116.             struct sockaddr_in peer;//储存本地网络信息
    117.             socklen_t len = sizeof(peer);
    118.             int sock = accept(_listensock, (struct sockaddr*)&peer, &len);
    119.             //如果没有客户端连接服务端，则accept会阻塞等待新连接
    120.             //如果有客户端需要连接服务端，则返回一个用于网络通信的描述符sock
    121.             if(sock < 0)
    122.             {
    123.                 logmessage(ERROR, "accept fail");//接收新文件描述符失败
    124.                 continue;//重新回到头接收
    125.             }
    126.             logmessage(NORMAL, "accept a new link");//接收新文件描述符成功
    127.             
    128.             //创建子进程
    129.             pid_t id = fork();
    130.             if(id == 0)
    131.             {
    132.                 //由于子进程也继承了父进程的监听套接字，而监听套接字只需要一个，所以需要关闭
    133.                 close(_listensock);
    134.                 if(fork() > 0)
    135.                 {
    136.                     //子进程再次创建子进程，fork对父进程（当前是服务器的子进程）返回子进程pid，对子进程（当前是服务器的孙子进程）返回0
    137.                     exit(0);//服务器子进程退出
    138.                 }
    139.                 //服务器的孙子进程执行IO处理
    140.                 //不断处理IO任务
    141.                 handler_enter(func, sock);
    142.                 //退出该函数时，客户端已经退出，需要将进行网络传输的文件描述符释放，否则会引起资源泄露
    143.                 close(sock);
    144.                 //退出孙子进程，由于它是孤儿进程，所以会被操作系统自行回收
    145.                 exit(0);
    146.             }
    147.         }
    148.     }
    149.  
    150.     ~tcpserver()
    151.     {}
    152. private:
    153.     uint16_t _port;//服务端进程的端口号
    154.     int _listensock;//监听文件描述符
    155. };

    server.cc

    1. #include"server.hpp"
    2. #include
    3. #include
    4. #include
    5.  
    6. //计算器函数
    7. const string ops = "+-*/%";
    8. bool calculate(const Request &req, Response &resp)
    9. {
    10.     // req已经有结构化完成的数据啦，你可以直接使用
    11.     resp._exitcode = OK;
    12.     resp._result = 0;
    13.     switch (req._op)
    14.     {
    15.     case '+':
    16.         resp._result = req._a + req._b;
    17.         break;
    18.     case '-':
    19.         resp._result = req._a - req._b;
    20.         break;
    21.     case '*':
    22.         resp._result = req._a * req._b;
    23.         break;
    24.     case '/':
    25.     {
    26.         if (req._b == 0)
    27.             resp._exitcode = DIV_ZERO;
    28.         else
    29.             resp._result = req._a / req._b;
    30.     }
    31.     break;
    32.     case '%':
    33.     {
    34.         if (req._b == 0)
    35.             resp._exitcode = MOD_ZERO;
    36.         else
    37.             resp._result = req._a % req._b;
    38.     }
    39.     break;
    40.     default:
    41.         resp._exitcode = OP_ERROR;
    42.         break;
    43.     }
    44.     return true;
    45. }
    46.  
    47. static void Usage(string proc)
    48. {
    49.     printf("\nUsage:\n\t%s local_port\n\n",proc.c_str());
    50. }
    51. int main(int argc, char* argv[])
    52. {
    53.     if(argc != 2)//如果没输入端口号，argc保存的命令参数只有一个，进程出错
    54.     {
    55.         Usage(argv[0]);
    56.         exit(USAGE_ERROR);
    57.     }
    58.  
    59.     uint16_t port = atoi(argv[1]);
    60.     unique_ptr p(new tcpserver(port));
    61.  
    62.     p->initserver();
    63.  
    64.     p->start(calculate);
    65.  
    66.     return 0;
    67. }

    3.客户端

    client.hpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13. #include
    14. #include
    15. #include"log.hpp"
    16. #include"protocol.hpp"
    17.  
    18. #define NUM 1024
    19. enum errorcode
    20. {
    21.     USAGE_ERROR = 1,
    22.     SOCKET_ERROR,
    23.     BIND_ERROR,
    24.     CONNECT_ERROR
    25. };
    26.  
    27. Request ParseLine(const std::string &line);
    28.  
    29. class tcpclient
    30. {
    31. public:
    32.     //构造函数
    33.     tcpclient(const std::string& ip, const uint16_t& port)
    34.         :_ip(ip)
    35.         ,_port(port)
    36.         ,_sock(-1)
    37.     {}
    38.  
    39.     void initclient()
    40.     {
    41.         //创建套接字，创建失败打印错误原因
    42.         _sock = socket(AF_INET, SOCK_STREAM, 0);
    43.         if(_sock == -1)
    44.         {
    45.             logmessage(FATAL, "create socket error");//socket失败属于最严重的错误
    46.             exit(SOCKET_ERROR);//退出
    47.         }
    48.         logmessage(NORMAL, "create socket success:%d", _sock);//创建套接字成功，打印让用户观察到
    49.         //客户端不需要显式绑定，该工作交给操作系统完成
    50.     }
    51.  
    52.     //启动客户端进程
    53.     void run()
    54.     {
    55.         struct sockaddr_in local;
    56.         local.sin_family = AF_INET;//通信方式为网络通信
    57.         local.sin_port = htons(_port);//将网络字节序的端口号填入
    58.         local.sin_addr.s_addr = inet_addr(_ip.c_str());//填充结构体
    59.  
    60.         //客户端连接服务器
    61.         if(connect(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)//客户端与服务器进行连接
    62.         {
    63.             logmessage(FATAL, "connect error");//connect失败属于最严重的错误
    64.         }
    65.         else
    66.         {
    67.             std::string line;
    68.             std::string inbuffer;
    69.             while (true)
    70.             {
    71.                 std::cout << "mycal>>> ";
    72.                 std::getline(std::cin, line);  // 1+1
    73.                 Request req = ParseLine(line); // "1+1"
    74.                 std::string content;
    75.                 req.serialize(&content);
    76.                 std::string send_string = enlength(content);
    77.                 std::cout << "sendstring:\n" << send_string << std::endl;
    78.                 send(_sock, send_string.c_str(), send_string.size(), 0); // bug?? 不管
    79.  
    80.                 std::string package, text;
    81.                 //  "content_len"\r\n"exitcode result"\r\n
    82.                 if (!recvpackage(_sock, inbuffer, &package))
    83.                     continue;
    84.                 if (!delength(package, &text))
    85.                     continue;
    86.                 // "exitcode result"
    87.                 Response resp;
    88.                 resp.deserialize(text);
    89.                 std::cout << "exitCode: " << resp._exitcode << std::endl;
    90.                 std::cout << "result: " << resp._result << std::endl;
    91.             }
    92.         }
    93.     }
    94.  
    95.     Request ParseLine(const std::string &line)
    96.     {
    97.         // 建议版本的状态机！
    98.         //"1+1" "123*456" "12/0"
    99.         int status = 0; // 0:操作符之前，1:碰到了操作符 2:操作符之后
    100.         int i = 0;
    101.         int cnt = line.size();
    102.         std::string left, right;
    103.         char op;
    104.         while (i < cnt)
    105.         {
    106.             switch (status)
    107.             {
    108.             case 0:
    109.             {
    110.                 if(!isdigit(line[i]))
    111.                 {
    112.                     op = line[i];
    113.                     status = 1;
    114.                 }
    115.                 else left.push_back(line[i++]);
    116.             }
    117.             break;
    118.             case 1:
    119.                 i++;
    120.                 status = 2;
    121.                 break;
    122.             case 2:
    123.                 right.push_back(line[i++]);
    124.                 break;
    125.             }
    126.         }
    127.         std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
    128.         return Request(std::stoi(left), std::stoi(right), op);
    129.     }
    130.     
    131.     //析构函数要释放不使用的文件描述符
    132.     ~tcpclient()
    133.     {
    134.         if( _sock >= 0)
    135.             close(_sock);
    136.     }
    137. private:
    138.     int _sock;//套接字文件描述符
    139.     std::string _ip;//服务器IP地址
    140.     uint16_t _port;//服务器的端口号
    141. };

    client.cc

    1. #include"client.hpp"
    2.  
    3. using namespace std;
    4.  
    5. static void Usage(string proc)
    6. {
    7.     printf("\nUsage:\n\t%s server_ip server_port\n\n", proc.c_str());
    8. }
    9. int main(int argc, char* argv[])
    10. {
    11.     if(argc != 3)//如果没输入端口号和目的IP，argc保存的命令参数就不是三个，进程出错
    12.     {
    13.         Usage(argv[0]);
    14.         exit(USAGE_ERROR);
    15.     }
    16.  
    17.     uint16_t port = atoi(argv[2]);
    18.     string ip = argv[1];
    19.     
    20.     unique_ptr p(new tcpclient(ip, port));
    21.  
    22.     p->initclient();
    23.     p->run();
    24.  
    25.     return 0;
    26. }

    4.makefile

    1. .PHONY:
    2. all:server client
    3. server:server.cc
    4.     g++ server.cc -o server -std=c++11 -ljsoncpp 
    5. client:client.cc
    6.     g++ client.cc -o client -std=c++11 -ljsoncpp 
    7. .PHONY:
    8. clean:
    9.     rm -f server client

    5.运行结果

    对于正确的计算式，也能返回0作为退出码，指示结果有效。

    对于不正确的计算式，也能返回非0退出码，指示结果无效。

    三、json序列化与反序列化

    1.常用序列化与反序列化库

    上面的序列化和反序列化都是我们自己通过处理字符串实现的。其实这部分的工作早就有人写好了现成的库，我们直接使用它们对数据进行序列化和反序列化即可。我们以后代码中的序列化和反序列化，绝对不要自己写。

    常见的有以下三个：

    json——使用简单。

    protobuf——比较复杂，局域网或者本地网络通信使用较多。

    xml——适合在其他编程语言中使用(如Java等)。

    这里只介绍使用最简单也最广泛的json的使用，学有余力可以去了解下protobuf。

    所以，都说到这里了，序列化反序列化与协议又有和关系呢？

    序列化与反序列化可以理解为，为了传输结构体这样的结构将原数据转化为字符串方便传输。

    而协议是网络通信双方约定以某种数据结构或者机制进行数据的解读和包装。

    二者并不相同，协议可以自己定制，序列化一般使用别人写好的库。二者也都是组成程序的重要部分。

    2.安装

    在使用json之前，需要先在Linux机器上使用yum安装json工具

    语句：sudo yum install -y jsoncpp-devel

    如上图所示就是安装成功了。（我直接以root身份安装的，不用sudo）

    json安装后，它的头文件json.h所在路径为/usr/include/jsoncpp/json/。而由于编译器查找头文件的目录仅限usr/include，所以在包含头文件需要加路径jsoncpp/json/json.h。

    json是一个动态库，它所在路径为/lib64/，完整的名字为libjsoncpp.sp。在使用的时候，编译器会自动到/lib64路径下查找所用的库，但编译需要指定库名，也需要加上-ljonscpp。

    还可以在makefile中增加一个宏-DMYSELF，实现条件编译，做到对序列化与反序列化的自我实现函数和json库实现的切换。

    3.使用

    Json数据的格式是采用键值对的形式，key为字符串，value为需要存储的变量如：

    "first" : a、"second" : b、"oper" : op、"exitcode" : exitcode、"result" : result

    序列化就是将这些键值对拼接在一起形成一个字符串。

    反序列化就是将多个字符串拆开，用户根据键值对的对应关系可以找到绑定的变量。

    当然这仅仅是一个很粗糙的理解，它内部的实现很复杂，我们只需要知道如何使用Json这个工具即可。

    我们使用Json对Request和Response进行序列化和反序列化写出一个新的版本，并利用条件编译实现其切换。

    我以Request的序列化和反序列化为例：

    （1）Request的序列化

    Json::Value root创建的Value类型对象root可以看作一个万能对象。

    使用root["字符串"] = 变量;的形式将不同类型的变量和字符串绑定形成键值对。

    然后创建一个Json::FastWriter类型的对象writer，使用write函数对root进行序列化，返回的结果为string类型，赋值给*out。

    （2）Request的反序列化

    首先，依旧要创建一个万能对象root，然后再创建一个Json::Reader类型的对象reader。

    调用对象reader的成员函数parse()将字符串in反序列化并将得到的键值对再放入到万能对象root中。

    根据键值对中的key值（"first"等字符串）使用[]就能找到value。由于反序列化后的value依旧为字符串，所以需要使用asInt()转化成int类型，此时才算彻底完成了反序列化。

    再使用Json对Response进行序列化和反序列化的过程除了成员变量的数目和属性不同之外，其他并没有什么不同，代码就都放在下面了。

    1. #pragma once
    2. #define MYSELF
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define SEP " "
    11. #define SEP_LEN strlen(SEP) //使用sizeof()多了一个\0
    12. #define LINE_SEP "\r\n"
    13. #define LINE_SEP_LEN strlen(LINE_SEP) //使用sizeof()多了一个\0
    14.  
    15. enum
    16. {
    17.     OK = 0,
    18.     DIV_ZERO,
    19.     MOD_ZERO,
    20.     OP_ERROR
    21. };
    22.  
    23. //"content" 转化为 "content_len"\r\n"content"\r\n
    24. //加上报头
    25. std::string enlength(const std::string &text)
    26. {
    27.     //按"content_len"\r\n"content"\r\n拼接字符串
    28.     std::string send_string = std::to_string(text.size());
    29.     send_string += LINE_SEP;
    30.     send_string += text;
    31.     send_string += LINE_SEP;
    32.     return send_string;
    33. }
    34.  
    35. //"content_len"\r\n"content"\r\n 转化为 "content"
    36. //去掉报头
    37. bool delength(const std::string &package, std::string *text)
    38. {
    39.     //查找左侧的\r\n
    40.     auto pos = package.find(LINE_SEP);
    41.     if (pos == std::string::npos)
    42.         return false;//没找到表明数据有问题
    43.     //截取正文长度的字符串并转为整形
    44.     std::string text_len_string = package.substr(0, pos);
    45.     int text_len = std::stoi(text_len_string);
    46.     //截取正文放入储存正文的string里
    47.     *text = package.substr(pos + LINE_SEP_LEN, text_len);
    48.     return true;
    49. }
    50.  
    51. class Request
    52. {
    53. public:
    54.     Request()
    55.         :_a(0)
    56.         ,_b(0)
    57.         ,_op(0)
    58.     {}
    59.  
    60.     Request(int a, int b, char op)
    61.         :_a(a)
    62.         ,_b(b)
    63.         ,_op(op)
    64.     {}
    65.     
    66.     //Request序列化
    67.     //Request结构体转化为字符串"a op b"
    68.     bool serialize(std::string *out)
    69.     {
    70. #ifdef MYSELF
    71.         out->clear();//清空
    72.         
    73.         //将变量转为字符串
    74.         std::string a_string = std::to_string(_a);
    75.         std::string b_string = std::to_string(_b);
    76.  
    77.         *out = a_string;
    78.         *out += SEP;
    79.         *out += _op;
    80.         *out += SEP;
    81.         *out += b_string;
    82. #else
    83.         Json::Value root;
    84.         root["first"] = _a;
    85.         root["second"] = _b;
    86.         root["oper"] = _op;
    87.  
    88.         Json::FastWriter writer;
    89.         // Json::StyledWriter writer;
    90.         *out = writer.write(root);
    91. #endif
    92.         return true;
    93.     }
    94.  
    95.     //Request反序列化
    96.     //字符串"a op b"转化为Request结构体
    97.     bool deserialize(const std::string &in)
    98.     {
    99. #ifdef MYSELF
    100.         auto left = in.find(SEP);//查找左侧的SEP
    101.         auto right = in.rfind(SEP);//查找右侧的SEP
    102.         if (left == std::string::npos || right == std::string::npos)
    103.             return false;//找不到，数据有问题
    104.         if (left == right)
    105.             return false;//只有一个SEP，数据有问题
    106.         if ((right - 1) != (left + SEP_LEN))//在字符串"a op b"中，right - 1和left + SEP_LEN都指向op
    107.             return false;//指向的不是一个位置，数据有问题
    108.  
    109.         //按左闭右开的方式构造两个数字
    110.         std::string a_string = in.substr(0, left);
    111.         std::string b_string = in.substr(right + SEP_LEN);
    112.  
    113.         //读取到的数字不能为空
    114.         if (a_string.empty() || b_string.empty())
    115.             return false;
    116.  
    117.         //填入数据
    118.         _a = std::stoi(a_string);
    119.         _b = std::stoi(b_string);
    120.         _op = in[left + SEP_LEN];
    121. #else
    122.         Json::Value root;
    123.         Json::Reader reader;
    124.         reader.parse(in, root);
    125.  
    126.         _a = root["first"].asInt();
    127.         _b = root["second"].asInt();
    128.         _op = root["oper"].asInt();
    129. #endif
    130.         return true;
    131.     }
    132.  
    133. public:
    134.     int _a;
    135.     int _b;
    136.     char _op;
    137. };
    138.  
    139. class Response
    140. {
    141. public:
    142.     Response()
    143.         :_exitcode(0)
    144.         ,_result(0)
    145.     {}
    146.     
    147.     Response(int exitcode, int result)
    148.         :_exitcode(exitcode)
    149.         ,_result(result)
    150.     {}
    151.  
    152.     //Response序列化
    153.     //Response结构体转化为字符串"exitcode result"
    154.     bool serialize(std::string *out)
    155.     {
    156. #ifdef MYSELF
    157.         out->clear();//清空
    158.  
    159.         //将变量转为字符串
    160.         std::string ec_string = std::to_string(_exitcode);
    161.         std::string res_string = std::to_string(_result);
    162.  
    163.         //拼接字符串
    164.         *out = ec_string;
    165.         *out += SEP;
    166.         *out += res_string;
    167. #else
    168.         Json::Value root;
    169.         root["exitcode"] = _exitcode;
    170.         root["result"] = _result;
    171.  
    172.         Json::FastWriter writer;
    173.         *out = writer.write(root);
    174. #endif
    175.         return true;
    176.     }
    177.  
    178.     //Response反序列化
    179.     //字符串"exitcode result"转化为Response结构体
    180.     bool deserialize(const std::string &in)
    181.     {
    182. #ifdef MYSELF
    183.         auto mid = in.find(SEP);//查找中间的SEP
    184.         if (mid == std::string::npos)
    185.             return false;//找不到，出错
    186.  
    187.         //按左闭右开的方式构造两个数字
    188.         std::string ec_string = in.substr(0, mid);
    189.         std::string res_string = in.substr(mid + SEP_LEN);
    190.  
    191.         //读取到的退出码和计算结果不能为空
    192.         if (ec_string.empty() || res_string.empty())
    193.             return false;
    194.  
    195.         //填入数据
    196.         _exitcode = std::stoi(ec_string);
    197.         _result = std::stoi(res_string);
    198. #else
    199.         Json::Value root;
    200.         Json::Reader reader;
    201.         reader.parse(in, root);
    202.         
    203.         _exitcode = root["exitcode"].asInt();
    204.         _result = root["result"].asInt();
    205. #endif
    206.         return true;
    207.     }
    208.  
    209. public:
    210.     int _exitcode; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
    211.     int _result;   // 计算结果
    212. };
    213.  
    214. //接收的数据："content_len"\r\n"a op b"\r\n ......
    215. bool recvpackage(int sock, std::string &inbuffer, std::string *text)
    216. {
    217.     char buffer[1024];//接收网络数据的字符串
    218.     while (true)
    219.     {
    220.         ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);//接收数据
    221.         if (n > 0)//读到了数据
    222.         {
    223.             buffer[n] = 0;
    224.             inbuffer += buffer;//以追加的方式放入缓冲区ibuffer
    225.             auto pos = inbuffer.find(LINE_SEP);//查找LINE_SEP，就是\r\n
    226.             if (pos == std::string::npos)
    227.                 //如果没有找到LINE_SEP，就说明报文"content_len"的部分可能没有读全
    228.                 continue;//接着到最开始读数据直到读全
    229.             
    230.             //执行至此时，报文"content_len"\r\n这部分一定读全了
    231.             //可以将"content_len"的部分取出来并转化为整形
    232.             std::string text_len_string = inbuffer.substr(0, pos);
    233.             int text_len = std::stoi(text_len_string);
    234.  
    235.             //我们现在知道了报文中正文部分的长度，所以就能确定我们读到的是否是一个完整的报文
    236.             //一个报文的组成为：text_len_string + "\r\n" + text + "\r\n"
    237.             //所以，只要缓冲区ibuffer的内容多于一个报文的字符个数，我们就必定保证ibuffer中已经存在了一个完整的报头;
    238.             int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
    239.             std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;
    240.             if (inbuffer.size() < total_len)
    241.             {
    242.                 std::cout << "输入的消息没有遵守协议，正在等待后续内容" << std::endl;
    243.                 continue;//报文没读全继续到上面读取
    244.             }
    245.  
    246.             //此时缓冲区中就至少有一个完整的报文
    247.             *text = inbuffer.substr(0, total_len);//将一个完整报文构建子串放入输出参数中
    248.             inbuffer.erase(0, total_len);//删除缓冲区中的完整报文
    249.             std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;
    250.             break;//准备处理报文，跳出循环
    251.         }
    252.         else//没读到数据
    253.             return false;
    254.     }
    255.     return true;
    256. }

    上面我们使用了条件编译，如果MYSELF被定义，就是用我们自己写的序列化和反序列化。

    如果MYSELF没被定义，就使用json库的定义。

  • 相关阅读:
    WEB开发技能树-JavaScript-BOM-Window对象
    部署elasticsearch集群
    向量范数及其Python代码
    面试 | Python 自动化测试技术面试真题
    redis实现未支付时间超时就删除订单，并给前端反应一个已过期
    python面向对象网络程序设计作业
    Docker基础（CentOS 7）
    【面向校招】Golang面试题合集
    电视访问群晖共享文件失败的设置方式，降低协议版本
    栈和队列知识点+例题
  • 原文地址：https://blog.csdn.net/qq_65285898/article/details/133250977