【Linux网络】再谈 “协议“

目录

再谈 "协议"

结构化数据的传输

序列化和反序列化

网络版计算器 

封装套接字操作 

服务端代码

服务进程执行例程

启动网络版服务端

协议定制

客户端代码

代码测试

使用JSON进行序列化与反序列化

我们程序员写的一个个解决我们实际问题，满足我们日常需求的网络程序，都是在应用层。

再谈 "协议"

我们之前讲过：协议是一种 "约定"。网络协议是通信计算机双方必须共同遵从的一组约定，只有通信计算机双方都遵守相同的协议，计算机之间才能互相通信交流。

结构化数据的传输

socket api的接口，在读写数据时，都是按 "字符串" 的方式来发送接收的。

  • 如果需要传输的数据是一个字符串，那么直接将这一个字符串发送到网络当中，此时对端也能从网络当中获取到这个字符串。
  • 但如果需要传输的是一些结构化的数据，此时就不能将这些数据一个个发送到网络当中。 

那么如果我们要传输一些"结构化的数据" 怎么办呢?

例如，我们需要实现一个服务器版的加法器。我们需要客户端把要计算的两个加数发过去，然后由服务器进行计算，最后再把结果返回给客户端。那么客户端每次给服务端发送的请求数据当中，就需要包括左操作数、右操作数以及对应需要进行的操作，此时客户端要发送的就不是一个简单的字符串，而是一组结构化的数据。

当客户端选择将结构化的数据逐一发送到网络中，服务端接收数据的过程也会相应地碎片化。每次从网络中接收到一部分数据，服务端都需要对这些离散的信息进行整理，尝试将它们重新组合成原始的结构化数据。这个过程既复杂又容易出错，因为数据可能在传输过程中出现丢失或顺序混乱的情况。

因此，为了简化数据传输和处理的流程，客户端通常会采取“打包”策略。打包意味着将多个相关的数据元素组合成一个整体，然后再进行传输。这样，服务端每次从网络中接收到的都是一个完整的数据包，其中包含了所有必要的信息。

客户端常见的“打包”方式主要有两种：

约定方案一:

  • 客户端发送一个形如"1+1"的字符串;
  • 这个字符串中有两个操作数, 都是整形;
  • 两个数字之间会有一个字符是运算符, 运算符只能是 + ;
  • 数字和运算符之间没有空格;

客户端能够将结构化的数据编排成一个字符串格式，并通过网络将其发送出去。当服务端从网络接收到这个字符串时，它会采用与客户端相同的解析方法，从而从这个字符串中提取出原始的结构化数据。这样的通信方式确保了数据的完整性和准确性在客户端和服务端之间的传输。

约定方案二:

  • 定义结构体来表示我们需要交互的信息;
  • 发送数据时将这个结构体按照一个规则转换成字符串，接收到数据的时候再按照相同的规则把字符串转化回结构体;
  • 这个过程叫做 "序列化" 和 “反序列化”

客户端可以设计一个特定的结构体，将需要交互的信息定义到这个结构体当中。在发送数据前，客户端会利用序列化技术将这个数据结构转换成一种统一的、可传输的字符串或字节流格式。当服务端接收到这些数据后，它会利用反序列化技术将这个字符串或字节流还原成原始的数据结构。通过这种方式，服务端可以轻松地提取出客户端发送的信息，并进行相应的处理。这种序列化和反序列化的过程确保了数据在不同系统间的兼容性和可交换性。 

序列化和反序列化

  • 序列化是将对象的状态信息转换为可以存储或传输的形式（字节序列）的过程。
  • 反序列化是把字节序列恢复为对象的过程。

OSI七层模型中的表示层的主要任务是将设备内部特有的数据格式，即应用层上的数据格式，转换为符合网络传输标准的格式。这种网络标准数据格式通常是通过序列化过程得到的，使得数据能够以一致和可理解的方式在网络中进行传输。

网络版计算器 

封装套接字操作 

由于服务端和客户端都需要创建套接字，以及使用套接字完成一些固定的操作，因此我们实现一个简单的TCP套接字（socket）类的实现，它封装了套接字的基本操作：包括创建、绑定、监听、接受连接和连接。这样服务端和客户端都可以直接调用这些函数。封装套接字操作可以使服务端和客户端代码更整洁、可重用，并减少重复代码。

Socket.hpp

#pragma once#include <iostream>
#include <string>
#include <unistd.h>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "Log.hpp"enum{SocketErr = 2,BindErr,ListenErr,AcceptErr
};#define backlog 10class Sock
{
public:Sock(){}~Sock(){}
public:void Socket(){sockfd_ = socket(AF_INET,SOCK_STREAM,0);if(sockfd_ < 0){lg(Fatal,"socker error, %s:%d",strerror(errno),errno);exit(SocketErr);}   }void Bind(uint16_t& port){struct sockaddr_in local;memset(&local,0,sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(port);local.sin_addr.s_addr = INADDR_ANY;if(bind(sockfd_,(struct sockaddr *)&local,sizeof(local)) < 0){lg(Fatal,"bind error, %s: %d", strerror(errno), errno);exit(BindErr);}}void Listen(){if(listen(sockfd_ , backlog) < 0){lg(Fatal,"listen error, %s: %d", strerror(errno), errno);exit(ListenErr);}}int Accept(std::string* clientip, std::uint16_t* clientport){struct sockaddr_in peer;socklen_t len = sizeof(peer);int newfd = accept(sockfd_,(struct sockaddr*)&peer,&len);if(newfd < 0){lg(Warning,"accept error, %s: %d", strerror(errno), errno);exit(AcceptErr);}char ipstr[64];inet_ntop(AF_INET,&(peer.sin_addr.s_addr),ipstr,sizeof(ipstr));*clientip = ipstr;*clientport = ntohs(peer.sin_port);return newfd;}bool Connect(const std::string &ip, const uint16_t &port){struct sockaddr_in peer;memset(&peer,0,sizeof(peer));peer.sin_family = AF_INET;peer.sin_port = htons(port);inet_pton(AF_INET,ip.c_str(),&(peer.sin_addr.s_addr));int n = connect(sockfd_,(struct sockaddr*)&peer,sizeof(peer));if(n == -1){std::cerr << "connect to " << ip << ":" << port << " error" << std::endl;return false;}return true;}void Close(){close(sockfd_);}int FD(){return sockfd_;}private:int sockfd_;
};

服务端代码

首先，我们需要初始化服务器，这包括三个关键步骤：

  1. 使用socket函数来创建一个新的套接字。
  2. 接着，通过bind函数，我们将这个套接字绑定到一个特定的端口号上，这样客户端就可以通过这个端口与服务器建立连接。
  3. 然后，通过调用listen函数，我们将套接字设置为监听状态，等待客户端的连接请求。

服务器初始化完成后，就可以启动它了。启动后，服务器的主要任务是不断地调用accept函数，从监听套接字中接收新的连接请求。每当成功接受到一个新连接时，服务器会创建一个新的进程。这个新进程将负责为该客户端提供计算服务，确保每个客户端都能得到及时且独立的响应。 

TcpServer.hpp 

#pragma once#include <iostream>
#include <signal.h>
#include <unistd.h>
#include <functional>
#include "Socket.hpp"//这允许我们为 TCP 服务器提供一个自定义的回调函数，该函数处理从客户端接收到的数据。
using func_t = std::function<std::string(std::string &package)>; //std::function对象，该对象接受一个 std::string 引用作为参数并返回一个 std::stringclass TcpServer
{
public:TcpServer(uint16_t port,func_t callback):port_(port),callback_(callback){}//初始化tcp服务器bool InitServer(){listensock_.Socket();listensock_.Bind(port_);listensock_.Listen();lg(Info,"init server .... done");return true;}//启动服务器void Start(){   signal(SIGCHLD, SIG_IGN);//忽略了 SIGCHLD 和 SIGPIPE 信号，当子进程终止或管道写入失败时，服务器不会接收到这些信号。signal(SIGPIPE, SIG_IGN);//无限循环，在该循环中，它尝试接受新的客户端连接。对于每个新的连接，它创建一个子进程来处理该连接。//并使用之前提供的回调函数来处理这些数据。如果回调函数返回一个非空字符串，那么该字符串将被发送回客户端。while (true){std::string clientip;uint16_t clientport;int sockfd = listensock_.Accept(&clientip,&clientport);if(sockfd < 0)continue;// 返回继续监听       lg(Info,"accept a new link, sockfd: %d, clientip: %s, clientport: %d",sockfd, clientip, clientport);// 提供服务if(fork() == 0)//{listensock_.Close();//在子进程中，服务器不再需要监听套接字，调用 listensock_.Close(); 关闭监听套接字，释放相关的系统资源。  std::string inbuffer_stream;//数据计算while (true){char buffer[1280];ssize_t n = read(sockfd,buffer,sizeof(buffer));if(n > 0)   {buffer[n] = 0;inbuffer_stream += buffer;while(true){std::string info = callback_(inbuffer_stream);if(info.empty())break;write(sockfd, info.c_str(), info.size());}}else if(n == 0)break;elsebreak;}   exit(0);//}close(sockfd);}   }~TcpServer(){}
private:uint16_t port_;Sock listensock_;func_t callback_;
};

说明一下： 

  • 当前服务器采用的是多进程的方案，对于每个新的连接，创建一个子进程来处理该连接。

  • 提供的回调函数来处理客户端发送过来的数据。如果回调函数返回一个非空字符串，那么该字符串将被发送回客户端。

服务进程执行例程

当服务端调用accept函数获取到新连接并创建新进程后，该线程就需要为该客户端提供计算服务，此时该进程需要先读取客户端发来的计算请求，然后进行对应的计算操作，如果客户端发来的计算请求存在除0、模0、非法运算等问题，就将响应结构体当中的状态字段对应设置为1、2、3即可。

ServerCal.hpp 

#pragma once
#include <iostream>
#include "Protocol.hpp"enum
{DivZero = 1,ModZero,Other_Oper
};class ServerCal
{
public:ServerCal(){}Response CalculatorHelper(const Request &req){Response resp(0, 0);switch (req.op){case '+':resp.result = req.x + req.y;break;case '-':resp.result = req.x - req.y;break;case '*':resp.result = req.x * req.y;break;case '/':{if (req.y != 0)resp.result = req.x / req.y;elseresp.code = DivZero;}break;case '%':{if (req.y != 0)resp.result = req.x % req.y;elseresp.code = ModZero;}break;default:resp.code = Other_Oper;break;}return resp;}// "len"\n"10 + 20"\nstd::string Calculator(std::string &package){std::string content;bool r = Decode(package, &content); // "len"\n"10 + 20"\nif (!r)return "";// "10 + 20"Request req;r = req.Deserialize(content); // 反序列化完req中的变量就拿到值了if (!r)return "";content = "";                          //清空Response resp = CalculatorHelper(req); // result=30 code=0;// 计算完进行序列化resp.Serialize(&content);content = Encode(content);return content;}~ServerCal(){}
};

启动网络版服务端

ServerCal.cpp

前面我们在TcpServer.hpp封装了服务器初始化和启动服务器函数的类，以及ServerCal类实现网络版计算器的类执行例程。下面我们实现一个ServerCal.cpp来启动网络版服务器，只有要调用前面两个类实现的接口即可。

  • 从命令行参数获取端口号
  • 创建ServerCal实例
  • 绑定ServerCal的Calculator方法
  • 创建TcpServer实例，并将绑定的Calculator方法和端口号作为参数传递给它。
  • 调用InitServer方法初始化服务器
  • 最后调用Start方法启动服务器。
#include "TcpServer.hpp"
#include "ServerCal.hpp"void Usage(const std::string &proc)
{std::cout << "\nUsage: " << proc << " port\n" << std::endl; 
}int main(int argc, char *argv[])
{if(argc != 2){Usage(argv[0]);exit(0);}uint16_t port = std::stoi(argv[1]);ServerCal cal;//std::bind是C++标准库中的一个函数模板，它可以将一个可调用对象（如函数、lambda函数或成员函数指针）与其参数绑定，生成一个新的可调用对象。//&ServerCal::Calculator是ServerCal类中的Calculator成员函数的指针。//&cal是ServerCal类的一个实例的地址，该实例用于调用Calculator成员函数。//std::placeholders::_1是一个占位符，它表示bind生成的新可调用对象接受的第一个参数将传递给Calculator成员函数作为它的第一个参数。TcpServer *tsvp = new TcpServer(port,std::bind(&ServerCal::Calculator,&cal,std::placeholders::_1));tsvp->InitServer();tsvp->Start();return 0;
}

协议定制

为了实现一个网络版的计算器，确保通信双方遵循共同的规则和约定是至关重要的。这就需要我们制定一套简明的协议。数据的交互通常涉及请求数据和响应数据，因此需要分别定义两者的结构。在实现层面，C++允许通过类来组织代码和数据，但同样也可以使用更简单的结构体来定义数据结构。考虑到简洁性和直接性，这里我们选择使用结构体来定义请求和响应的数据格式。

因此我们需要设计一个请求结构体，用于封装从客户端发送到服务器的计算请求信息，以及一个响应结构体，用于封装服务器处理完请求后返回给客户端的结果。通过这种方式，我们可以确保通信双方按照预定的格式发送和接收数据，从而实现网络计算器的功能。

  • 请求结构体中需要包括两个操作数，以及对应需要进行的操作。
  • 响应结构体中需要包括一个计算结果，除此之外，响应结构体中还需要包括一个状态字段，表示本次计算的状态，因为客户端发来的计算请求可能是无意义的。
  • 请求结构体和响应结构体当中都封装了序列化函数和反序列化函数。
  • 我们在类外设置了编码函数和解码函数
#pragma once#include <iostream>
#include <string>const std::string blank_space_sep = " ";
const std::string protocol_sep  = "\n";std::string Encode(std::string &content)
{std::string package = std::to_string(content.size());package += protocol_sep;package += content;package += protocol_sep;return package;
}// "len"\n"x op y"\nXXXXXX
// "protocolnumber"\n"len"\n"x op y"\nXXXXXX
bool Decode(std::string &package, std::string *content)
{size_t pos = package.find(protocol_sep);if(pos == std::string::npos) return false;std::string len_str = package.substr(0,pos);std::size_t len = std::stoi(len_str);std::size_t total_len = len_str.size() + len + 2;if(package.size() < total_len)  return false;//传入的序列化字符串没有达到报头提供的字符串长度*content = package.substr(pos+1,len);package.erase(0,total_len);//return true;
}class Request
{
public:Request(int data1,int data2,char oper):x(data1),y(data2),op(oper){}Request()//{}
public:bool Serialize(std::string *out){// 构建报文的有效载荷// struct => string, "x op y"std::string s = std::to_string(x);s += blank_space_sep;s += op;s += blank_space_sep;s += std::to_string(y);*out = s;return true;}bool Deserialize(const std::string &in)// "x op y"{std::size_t left = in.find(blank_space_sep);if(left == std::string::npos)return false;std::string part_x = in.substr(0,left);std::size_t right = in.rfind(blank_space_sep);if(right == std::string::npos)return false;std::string part_y = in.substr(right);if(left+2 != right)return false;op = in[left + 1];x = std::stoi(part_x);x = std::stoi(part_y);return true;}void DebugPrint(){std::cout << "新请求构建完成:  " << x << op << y << "=?" << std::endl;}public://x op yint x;int y;char op;//+ - * / %
};class Response
{
public:Response(int res,int c):result(res),code(c){}Response(){}
public:bool Serialize(std::string *out){// "result code"// 构建报文的有效载荷std::string s = std::to_string(result);s += blank_space_sep;s += std::to_string(code);*out = s;return true;}bool Deserialize(const std::string &in){std::size_t pos = in.find(blank_space_sep);if(pos == std::string::npos) return false;std::string part_left = in.substr(0,pos);std::string part_right = in.substr(pos+1);result = std::stoi(part_left);code = std::stoi(part_right);return true;}void DebugPrint(){std::cout << "结果响应完成, result: " << result << ", code: "<< code << std::endl;}public:int result;int code;//0表示结果是可信的；否则!0具体是几，表明对应的错误原因
};

请求结构体

  • 序列化函数用于构建报文的有效载荷，将 `Request` 对象转换为一个字符串。它首先将 `x` 和 `y` 转换为字符串，并使用空格和操作符 `op` 将它们连接在一起。例如，如果 `x` 是 5，`y` 是 3，并且 `op` 是 `+`，则生成的字符串将是 `"5 + 3"`
  • 反序列化函数尝试从一个字符串中恢复一个 `Request` 对象。它首先查找空格和操作符来分隔 `x`、`op` 和 `y`。然后，它将这些部分转换回它们的原始类型，并检查字符串的格式是否正确。如果一切正常，它将更新 `Request` 对象的 `x`、`y` 和 `op`。

响应结构体

  • Serialize 函数接受一个指向 std::string 的指针 out，并将 result 和 code 成员变量的值转换为字符串，然后用空格（blank_space_sep）分隔它们，并将结果字符串存储在 out 所指向的位置。函数总是返回 true，表示序列化操作总是成功的。
  • Deserialize 函数接受一个常量字符串引用 in，并尝试从中解析出 result 和 code 的值。它首先查找空格的位置，然后提取空格前后的两个子字符串，并将它们分别转换为整数来更新 result 和 code 的值。如果字符串中没有找到空格，函数返回 false，否则返回 true。

编码函数 Encode:

  • 函数接受一个字符串 content，并返回一个编码后的字符串 package。
  • 首先，将 `content` 的大小（长度）转换为字符串并添加到 `package`。  
  • 然后，添加一个换行符。  
  • 接着，添加原始的 `content`。  
  • 最后，再添加一个换行符。这样，编码后的字符串格式是：`"length\ncontent\n"`。

解码函数 Decode:

  • 这个函数尝试从给定的 package 字符串中解码出 content。它首先查找换行符来确定 content 的长度，并检查 package 是否包含足够的数据。如果成功，它会提取 content 并从 package 中删除已解码的部分。

注意：

  • 编码函数和解码函数是多个结构体或类都可能需要的共同操作，因此将它们放在类外作为独立的函数。这种做法不仅增强了代码的可重用性，还方便了协议的编码和解码逻辑的更换。通过将编码和解码逻辑与具体的数据结构分离，我们可以在不修改数据结构定义的情况下更换编码和解码的实现，从而实现了更好的模块化和可扩展性。

规定状态字段对应的含义：

  • 状态字段为0，表示计算成功。
  • 状态字段为1，表示出现除0错误。
  • 状态字段为2，表示出现模0错误。
  • 状态字段为3，表示非法计算。

此时我们就完成了协议的设计，但需要注意，只有当响应结构体当中的状态字段为0时，计算结果才是有意义的，否则计算结果无意义。 

客户端代码

客户端首先也需要进行初始化：

  • 调用socket函数，创建套接字。

客户端初始化完毕后需要调用connect函数连接服务端，当连接服务端成功后，客户端就可以向服务端发起计算请求了。这里可以让用户输入两个操作数和一个操作符构建一个计算请求，然后将该请求发送给服务端。而当服务端处理完该计算请求后，会对客户端进行响应，因此客户端发送完请求后还需要读取服务端发来的响应数据。

客户端在向服务端发送或接收数据时，可以使用write或read函数进行发送或接收（也可以使用send或recv函数对应进行发送或接收。）

  • 连接服务器

由于我们前面封装了TCP套接字（socket）类的实现，这里我们之间调用我们封装的接口即可，下面是客户端代码：

客户端代码：

#include <iostream>
#include <string>
#include <time.h>
#include <assert.h>
#include "Protocol.hpp"
#include"Socket.hpp"void Usage(const std::string &proc)
{std::cout << "\nUsage: " << proc << " serverip serverport\n" << std::endl;
}// ./clientcal ip port
int main(int argc, char *argv[])
{if (argc != 3){Usage(argv[0]);exit(0);}std::string serverip = argv[1];uint16_t serverport = std::stoi(argv[2]);//创建套接字Sock sockfd;sockfd.Socket();//链接服务器bool r = sockfd.Connect(serverip,serverport);if(!r) return 1;srand(time(nullptr)^getpid());int cnt = 1;const std::string opers = "+-*/%=-=&^";std::string inbuffer_stream;while(cnt <= 10){//准备数据std::cout << "===============第" << cnt << "次测试....., " << "===============" << std::endl;int x = rand() % 100 + 1;usleep(1000);int y = rand() % 100 + 1;usleep(1000);char op = opers[rand() % opers.size()];Request req(x,y,op);req.DebugPrint();//客户端发送请求std::string packge;req.Serialize(&packge);packge = Encode(packge);write(sockfd.FD(),packge.c_str(),packge.size());//接受请求响应char buffer[128];ssize_t n = read(sockfd.FD(),buffer,sizeof(buffer));// 我们也无法保证我们能读到一个完整的报文if(n > 0){buffer[n] = 0;inbuffer_stream += buffer;// "len"\n"result code"\nstd::cout << inbuffer_stream << std::endl;std::string content;bool r = Decode(inbuffer_stream,&content);// "result code"assert(r);Response resp;r = resp.Deserialize(content);assert(r);resp.DebugPrint();}std::cout << "=================================================" << std::endl;sleep(1);cnt++;}sockfd.Close();return 0;
}

代码测试

运行服务端后再让客户端连接服务端，此时服务端就会对客户端发来的计算请求进行处理，并会将计算后的结果响应给客户端。

我们看到如果客户端要进行除0、模0、非法运算，在服务端识别后就会按照约定对应将响应数据的状态码设置为1、2、3，此时响应状态码为非零，因此在客户端打印出来的计算结果就是没有意义的。

此时我们就以这样一种方式约定出了一套应用层的简单的网络计算器，这就叫做协议。 

使用JSON进行序列化与反序列化

上面我们进行序列化和反序列化是自己进行协议定制，其实我们也可以用JSON或者Protobuf进行数据的序列化和反序列化操作。

JSON (JavaScript Object Notation) 和 Protobuf (Protocol Buffers) 都是数据序列化格式，但它们在设计目标、性能、使用场景等方面有所不同。

下面我们主要来介绍一下使用JSON进行序列化和反序列化操作：

JSON

  • 设计目标：JSON 主要用于人类可读性和易于编写。它是基于 JavaScript 的子集，但不仅限于 JavaScript 使用。
  • 性能：JSON 的解析和序列化速度相对较慢，尤其是对于大型数据结构。
  • 使用场景：JSON 广泛用于 API 通信、配置文件、Web 存储等场景，因为它易于阅读和编写，并且跨语言、跨平台。
  • 在使用 JsonCpp 之前，你需要确保已经安装了这个库。
sudo yum install -y jsoncpp-devel
  • 安装完成后，项目中加入头文件#include <jsoncpp/json/json.h>
  • 编译命令后面加上-ljsoncpp

下面是一个简单的示例，展示了如何使用 JsonCpp 来解析和生成 JSON 数据：

#include <iostream>  
#include <jsoncpp/json/json.h>  
#include <unistd.h>int main() {  // 创建一个 JSON 对象  Json::Value root; // 将用于存储 JSON 数据的根对象  root["x"] = 40;  root["y"] = 30;  root["op"] = '+';  root["desc"] = "this is a + oper";  // 序列化：将 JSON 对象转换为字符串  Json::FastWriter writer;  //Json::StyledWriter writer;  //StyledWriter比Fastwriter多加了\n，可读性比较好std::string jsonString = writer.write(root);  // 输出 JSON 字符串  std::cout << "JSON string: " << jsonString << std::endl;  sleep(3);// 反序列化：从字符串解析 JSON  Json::Value v;  Json::Reader Reader;  Reader.parse(jsonString,v);// 访问 JSON 对象中的值  int x = v["x"].asInt();  int y = v["y"].asInt();  char op = v["op"].asInt();  std::string desc = v["desc"].asString();  // 输出解析后的值  std::cout << x <<std::endl;  std::cout << y <<std::endl;      std::cout << op <<std::endl;      std::cout << desc <<std::endl;     return 0;  
}

运行结果：

有了上面对JSON基本使用的理解后，下面我们在网络版计算器的协议定制的代码中增加JSON方式的序列化与反序列化：

我们根据是否定义了MySelf宏，来选择使用两种序列化方式：

#pragma once#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>// #define MySelf 1const std::string blank_space_sep = " ";
const std::string protocol_sep  = "\n";std::string Encode(std::string &content)
{std::string package = std::to_string(content.size());package += protocol_sep;package += content;package += protocol_sep;return package;
}// "len"\n"x op y"\nXXXXXX
// "protocolnumber"\n"len"\n"x op y"\nXXXXXX
bool Decode(std::string &package, std::string *content)
{size_t pos = package.find(protocol_sep);if(pos == std::string::npos) return false;std::string len_str = package.substr(0,pos);std::size_t len = std::stoi(len_str);std::size_t total_len = len_str.size() + len + 2;if(package.size() < total_len)  return false;//传入的序列化字符串没有达到报头提供的字符串长度*content = package.substr(pos+1,len);package.erase(0,total_len);//return true;
}// json, protobuf
class Request
{
public:Request(int data1,int data2,char oper):x(data1),y(data2),op(oper){}Request()//{}
public:bool Serialize(std::string *out){
#ifdef MySelf// 构建报文的有效载荷// struct => string, "x op y"std::string s = std::to_string(x);s += blank_space_sep;s += op;s += blank_space_sep;s += std::to_string(y);*out = s;return true;
#elseJson::Value root;root["x"] = x;root["y"] = y;root["op"] = op;// Json::FastWriter w;Json::StyledWriter w;*out = w.write(root);return true;
#endif}bool Deserialize(const std::string &in)// "x op y"{
#ifdef MySelfstd::size_t left = in.find(blank_space_sep);if(left == std::string::npos)return false;std::string part_x = in.substr(0,left);std::size_t right = in.rfind(blank_space_sep);if(right == std::string::npos)return false;std::string part_y = in.substr(right);if(left+2 != right)return false;op = in[left + 1];x = std::stoi(part_x);y = std::stoi(part_y);return true;
#elseJson::Value root;Json::Reader r;r.parse(in,root);x = root["x"].asInt();y = root["y"].asInt();char op = root["op"].asInt();return true;
#endif}void DebugPrint(){std::cout << "新请求构建完成:  " << x << op << y << "=?" << std::endl;}public://x op yint x;int y;char op;//+ - * / %
};class Response
{
public:Response(int res,int c):result(res),code(c){}Response(){}
public:bool Serialize(std::string *out){
#ifdef MySelf// "result code"// 构建报文的有效载荷std::string s = std::to_string(result);s += blank_space_sep;s += std::to_string(code);*out = s;return true;
#elseJson::Value root;root["result"] = result;root["code"] = code;// Json::FastWriter w;Json::StyledWriter w;*out = w.write(root);return true;
#endif}bool Deserialize(const std::string &in){
#ifdef MySelfstd::size_t pos = in.find(blank_space_sep);if(pos == std::string::npos) return false;std::string part_left = in.substr(0,pos);std::string part_right = in.substr(pos+1);result = std::stoi(part_left);code = std::stoi(part_right);return true;
#elseJson::Value root;Json::Reader r;r.parse(in,root);int result = root["result"].asInt();int code = root["code"].asInt();
#endif}void DebugPrint(){std::cout << "结果响应完成, result: " << result << ", code: "<< code << std::endl;}public:int result;int code;//0表示结果是可信的；否则!0具体是几，表明对应的错误原因
};

makefile文件：

编译时要加上-ljsoncpp选项，我们也可以在makefile文件中进行宏定义Myself

.PHONY:all
all:servercal clientcal# Flag= -DMySelf=1
Flag= #-DMySelf=1
Lib=-ljsoncppservercal:ServerCal.cppg++ -o $@ $^ -std=c++11 $(Lib) $(Flag)
clientcal:ClientCal.cppg++ -o $@ $^ -std=c++11 $(Lib) $(Flag).PHONY:clean
clean:rm -f servercal clientcal

代码测试：

以上我们就成功用Json实现了数据序列化和反序列化。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/722921.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

新品发布会媒体邀请，邀约记者现场报道

新品发布会媒体邀请，邀约记者现场报道

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 新品发布会媒体邀请及记者现场报道邀约流程&#xff1a; 一、策划准备 明确新品发布会时间、地点和主题。 制定媒体邀请计划&#xff0c;确定目标媒体。 二、邀请媒体 向目标媒体发送…
阅读更多...
CSS的三种定位，响应式web开发项目教程

CSS的三种定位，响应式web开发项目教程

标准文档流 文档流&#xff1a;指的是元素排版布局过程中 戳这里领取完整开源项目&#xff1a;【一线大厂前端面试题解析核心总结学习笔记Web真实项目实战最新讲解视频】 &#xff0c;元素会默认自动从左往右&#xff0c;从上往下的流式排列方式。并最终窗体自上而下分成一行行…
阅读更多...
12、电源管理入门之clock驱动

12、电源管理入门之clock驱动

目录 1. clock驱动构架 1.2 clock consumer介绍 2. Clock Provider 2.1 数据结构表示 2.2 clock provider注册初始化 2.3 DTS配置 2.4 clock驱动实现举例： 3. clock consumer 3.1 获取clock 3.2 操作clock 3.3 实例操作 4. SoC硬件中的使用 参考： 电源管理的两个…
阅读更多...
《 前端 vs. 后端：挑战与机遇的对决》

《 前端 vs. 后端：挑战与机遇的对决》

前言 前端开发和后端开发是构建网站、应用程序和其他软件的两个主要方面。它们各自负责不同的任务和功能。 前端开发： 定义：前端开发是指构建用户直接与之交互的网站或应用程序的过程。前端开发主要关注于用户界面和用户体验。技术栈：前端开发通常涉及使用 HTML、CSS 和 Ja…
阅读更多...
组基轨迹建模 GBTM的介绍与实现（Stata 或 R）

组基轨迹建模 GBTM的介绍与实现（Stata 或 R）

基本介绍 组基轨迹建模&#xff08;Group-Based Trajectory Modeling&#xff0c;GBTM&#xff09;&#xff08;旧名称&#xff1a;Semiparametric mixture model&#xff09; 历史&#xff1a;由DANIELS.NAGIN提出&#xff0c;发表文献《Analyzing Developmental Trajectori…
阅读更多...
7.1.3 Selenium的用法2

7.1.3 Selenium的用法2

目录 1. 切换 Frame 2. 前进后退 3. 对 Cookies 操作 4. 选项卡管理(了解) 5. 异常处理 6. 反屏蔽 7. 无头模式 1. 切换 Frame 我们知道网页中有一种节点叫作 iframe&#xff0c;也就是子 Frame&#xff0c;相当于页面的子页面&#xff0c;它的结构和外部网页的结构完全…
阅读更多...
android高级面试题及答案，已拿offer

android高级面试题及答案，已拿offer

一、java相关 java基础 1、java 中和 equals 和 hashCode 的区别 2、int、char、long 各占多少字节数 3、int 与 integer 的区别 4、谈谈对 java 多态的理解 5、String、StringBuffer、StringBuilder 区别 6、什么是内部类&#xff1f;内部类的作用 7、抽象类和接口区别 java高…
阅读更多...
SkyWalking链路追踪上下文TraceContext的traceId生成的实现原理剖析

SkyWalking链路追踪上下文TraceContext的traceId生成的实现原理剖析

结论先行 【结论】 SkyWalking通过字节码增强技术实现&#xff0c;结合依赖注入和控制反转思想&#xff0c;以SkyWalking方式将追踪身份traceId编织到链路追踪上下文TraceContext中。 是不是很有趣&#xff0c;很有意思&#xff01;&#xff01;&#xff01; 【收获】 skywal…
阅读更多...
【Mining Data】收集数据(使用 Python 挖掘 Twitter 数据)

【Mining Data】收集数据(使用 Python 挖掘 Twitter 数据)

@[TOC](【Mining Data】收集数据(使用 Python 挖掘 Twitter 数据)) 具体步骤 第一步是注册您的应用程序。特别是，您需要将浏览器指向 http://apps.twitter.com，登录 Twitter（如果您尚未登录）并注册新应用程序。您现在可以为您的应用程序选择名称和描述（例如“Mining Demo”…
阅读更多...
未来已来！AI大模型引领科技革命

未来已来！AI大模型引领科技革命

未来已来&#xff01;AI大模型正以惊人的速度引领着科技革命。随着科技的发展&#xff0c;人工智能在各个领域展现出了非凡的能力和潜力&#xff0c;大模型更是成为了科技领域的明星。从自然语言处理到图像识别&#xff0c;从智能推荐到语音识别&#xff0c;大模型的应用正在改…
阅读更多...
基于ZYNQ PS-SPI的Flash驱动开发

基于ZYNQ PS-SPI的Flash驱动开发

本文使用PS-SPI实现Flash读写&#xff0c;PS-SPI的基础资料参考Xilinx UG1085的文档说明&#xff0c;其基础使用方法是&#xff0c;配置SPI模式&#xff0c;控制TXFIFO/RXFIFO&#xff0c;ZYNQ的IP自动完成发送TXFIFO数据&#xff0c;接收数据到RXFIFO&#xff0c;FIFO深度为12…
阅读更多...
word转PDF的方法 简介快速

word转PDF的方法 简介快速

在现代办公环境中&#xff0c;文档格式转换已成为一项常见且重要的任务。其中&#xff0c;将Word文档转换为PDF格式的需求尤为突出&#xff0c;将Word文档转换为PDF格式具有多方面的优势和应用场景。无论是为了提高文档的可读性和稳定性、保障文档的安全性和保护机制、还是为了…
阅读更多...
IDEA运行大项目启动卡顿问题

IDEA运行大项目启动卡顿问题

我打开了很多项目&#xff0c;然后又启动了一个大型项目时&#xff0c;启动到一半&#xff0c;弹出一个窗口&#xff0c;告诉我idea内存不够&#xff0c;怎么解决这个问题&#xff1f; 1、先把多余的项目关掉&#xff0c;再启动这个大项目&#xff0c; 2、如果还是不行就去修改…
阅读更多...
一文帮助快速入门Django

一文帮助快速入门Django

文章目录 创建django项目应用app配置pycharm虚拟环境打包依赖 路由传统路由include路由分发namenamespace 视图中间件orm关系对象映射操作表数据库配置model常见字段及参数orm基本操作 cookie和sessiondemo 创建django项目 指定版本安装django&#xff1a;pip install django3.…
阅读更多...
Unity使用UnityWebRequest读取音频长度不对的解决方法

Unity使用UnityWebRequest读取音频长度不对的解决方法

在开发的过程中碰到这样一个问题&#xff0c;有的音频文件通过UnityWebRequest读取出来后&#xff0c;AudioClip的Length会不对&#xff0c;比如本身有7秒&#xff0c;读出来只有3秒。代码如下&#xff1a; IEnumerator TestEnumerator() {UnityWebRequest www UnityWebReque…
阅读更多...
gitlab的安装

gitlab的安装

1、下载rpm 安装包 (1)直接命令下载 wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/gitlab-ce-11.6.10-ce.0.el7.x86_64.rpm&#xff08;2&#xff09;直接去服务器上下载包 Index of /gitlab-ce/yum/el7/ | 清华大学开源软件镜像站 | Tsinghua Open Source…
阅读更多...
【图论】图的遍历 - 构建领接表（无向图）

【图论】图的遍历 - 构建领接表（无向图）

文章目录 例题&#xff1a;受限条件下可到达节点的数目题目描述代码与注释模板抽象 例题&#xff1a;受限条件下可到达节点的数目 题目链接&#xff1a;2368. 受限条件下可到达节点的数目 题目描述 代码与注释 func reachableNodes(n int, edges [][]int, restricted []int)…
阅读更多...
网络编程：select、poll

网络编程：select、poll

.1、select完成TCP并发服务器 程序代码&#xff1a; #include <myhead.h> #define SER_IP "192.168.125.234" //服务端IP #define SER_PORT 8888 //服务端端口号int main(int argc, const char *argv[]) {//1.创建用于连接的套接字int sfds…
阅读更多...
HTML实体字符列表，必看

HTML实体字符列表，必看

HTML、CSS、JS三大部分都起什么作用&#xff1f; HTML内容层&#xff0c;它的作用是表示一个HTML标签在页面里是个什么角色&#xff1b;CSS样式层&#xff0c;它的作用是表示一块内容以什么样的样式&#xff08;字体、大小、颜色、宽高等&#xff09;显示&#xff1b;JS行为层…
阅读更多...
基于QGIS的研究区域遥感影像裁切下载方法-以岳麓区为例

基于QGIS的研究区域遥感影像裁切下载方法-以岳麓区为例

目录 前言 一、数据说明 1、遥感影像 2、矢量范围 二、按矢量范围导出 1、第一步、导出影像 2、第二步、设置输出格式 3、设置裁切范围 4、设置分辨率 三、按矢量范围掩膜 1、第一步、打开裁剪工具 2、第二步、参数设置 ​编辑 3、执行掩膜 四、webgis支持 1、生成运行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023