模拟实现应用层协议

模拟实现应用层协议

文章目录

  • 模拟实现应用层协议
      • 应用层
        • 再谈协议
      • 序列化和反序列化
    • 网络版计算器
      • 自定义协议
      • 利用Json进行序列化和反序列化
        • json库的安装
        • 条件编译

应用层

image-20230829191153866

应用层（Application layer）是OSI模型的第七层。应用层直接和应用程序接口并提供常见的网络应用服务。应用层也向表示层发出请求。应用层是开放系统的最高层,是直接为应用进程提供服务的。其作用是在实现多个系统应用进程相互通信的同时,完成一系列业务处理所需的服务。我们程序员写的一个个解决我们实际问题, 满足我们日常需求的网络程序, 都是在应用层。

再谈协议

运输层为应用进程提供了端到端的通信服务，但不同的网络应用的应用进程之间，还需要有不同的通信规则，因此在运输层协议之上，还需要有应用层协议。协议作为一种”约定“，那么必须遵守一些准则。对应应用层协议一般要遵守：

  1. 应用进程交换的报文类型，如请求报文和响应报文。
  2. 各种报文类型的语法，如报文中的各个字段及其详细描述。
  3. 字段的语义，即包含在字段中的信息的含义。
  4. 进程何时，如何发送报文，以及对报文进行响应的规则

序列化和反序列化

官方定义：序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

序列化有两个用途：

  • 把对象的字节序列永久保存到硬盘上，通常存放在一个文件中（序列化对象）
  • 在网络上传送对象的字节序列（网络传输对象）

实际上就是将数据持久化，防止一直存储在内存当中，消耗内存资源。而且序列化后也能更好的便于网络运输何传播。

image-20230829223851219

例如在微信里你給对方发送一条消息，实际上会将头像、昵称、消息内容、发送时间等构建一个结构，然后将该结构进行序列化，即将该结构形成一个字节流报文，通过网络将该报文发送給对方，对方进行反序列化，将该报文转化为结构，然后重新拆解为头像、昵称、消息内容、发送时间等。

而序列化还解决了网络传输结构体由于大小端、内存对齐导致数据出错等问题

网络版计算器

现通过指定简单的协议，实现一个服务器版的计算器。我们需要在客户端把要计算的两个数和运算符发过去, 然后由服务器进行计算, 最 后再把结果返回给客户端。

对应网络计算器约定协议：

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

对应网络的序列化和反序列化：

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

在TCP协议中，如何保证接收方收到的是完整的报文呢？

image-20230829231938344

  • 我们调用的发送或接收函数，本质上是拷贝函数。

  • 应用层调用的发送或接收函数，并不是直接从网络中读取或发送数据。例如客户端在应用层调用发送函数发送数据时，是将数据从应用层的发送缓冲区拷贝一份到传输层的发送缓冲区。然后由传输层自主决定何时将数据发送至网络中，服务器的传输层再通过网络将数据读取到接收缓冲区，然后将数据拷贝一份到应用层的接收缓冲区。因此TCP协议是一种传输控制协议

  • 由于使用在TCP协议的双方都有发送缓冲区和接收缓冲区，即读取数据和发送数据不会互相干扰，可以同时双向传输数据，因此TCP协议是一种全双工的通信协议。

  • 由于TCP协议是一种全双工的通信协议，因此也会产生客户端发送数据的速度远远大于服务器读取数据的速度，此时会造成服务器的接收缓冲区内积攒大量的报文，这些报文是线性连接在一起的，那么如何将一条条报文完整的读取上来呢？**通过指定的协议，按照协议规定的方式读取上来。**协议定制的方式有：

    • 定长：规定该报文的长度
    • 间隔符号：规定报文之间存在间隔符号
    • 自描述方式：自定义协议

该网络版计算器对应的协议如下：

image-20230829235118910

  • 由于UDP协议发送和接收数据都是以数据报的形式，在传输过程中数据是完整的，因此并不需要通过序列和反序列化、对数据添加特殊内容的方式去界定报文边界；而TCP协议发送和接收数据是以字节流的方式，就必须使用相关协议手段去标识、保护报文。

自定义协议

protocol.hpp

#pragma once
#include<iostream>
#include<string>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstring>
using namespace std;#define SEP " "
#define SEP_LEN strlen(SEP)//strlen统计'\0'之前的字符个数，而sizeof统计的是所占内存的空间大小，使用sizeof会越界出问题
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP)enum {NONE=0,DIV_ZERO,MOD_ZERO,OP_ERR
};
//"x op y"->"text_len"\r\n"x op y"\r\n---給内容加上报头
std::string enLength(const std::string& text)//协议定制
{std::string send_str=to_string(text.size());send_str+=LINE_SEP;send_str+=text;send_str+=LINE_SEP;return send_str;
}
//"text_len"\r\n"x op y"\r\n -> "x op y"---去掉报头，取出里面的内容
bool deLength(const std::string& str,string* ret)//协议定制
{auto it=str.find(LINE_SEP);//找到报头if(it==std::string::npos) return false;//如果没找到则直接返回int len=stoi(str.substr(0,it));//取出字符串的长度*ret=str.substr(it+LINE_SEP_LEN,len);//取出数据return true;
}class Request
{
public:
Request():_x(0),_y(0),_op(0){}
Request(int x,int y,int op):_x(x),_y(y),_op(op){}bool Serialize(std::string* out)//序列化，将传入的x op y转化为字符串"x op y"
{*out="";*out+=to_string(_x);*out+=SEP;*out+=to_string(_op);*out+=SEP;*out+=to_string(_y);return true;
}bool Deserialize( const string& origin)//反序列化，将传过来的字符串拆出来传参給_x _op _y
{//"_xSEP_opSEP_y"-> _x,_op,_yauto leftit=origin.find(SEP);cout<<"Deserialize找到了leftSEP: "<<leftit<<endl;auto rightit=origin.rfind(SEP);cout<<"Deserialize找到了rightSEP: "<<rightit<<endl;if(leftit==string::npos|| rightit==string::npos) return false;if(leftit==rightit) return false;int opsize=rightit-leftit-1;cout<<"opsize: "<<opsize<<endl;
//1 43 1--leftit=1,rightit=4,opsize=rightit-leftit-1=4-1-1=2;
//1 3 1--leftit=1,right=3,opsize=rightit-leftit-1=3-1-1=1// if(rightit-(leftit+SEP_LEN)!=1) return false;if(rightit-(leftit+SEP_LEN)!=opsize) return false;//+号ASCII码是43，从char转int被解析成43即stringlen为两位,这里的运算rightit-(leftit+SEP_LEN)!=1就出问题
//4-(1+1)==2;3-(1+1)=1std::string origin_x=origin.substr(0,leftit);std::string origin_y=origin.substr(rightit+SEP_LEN);if(origin_x.empty()) return false;if(origin_y.empty()) return false;cout<<"origin_x: "<<origin_x<<" origin_y: "<<origin_y<<endl;_x=stoi(origin_x);int opf=stoi(origin.substr(leftit,rightit));_op=opf;cout<<"opf: "<<opf<<"_op: "<<_op<<endl;_y=stoi(origin_y);return true;}public:int _x;int _y;char _op;
};class Response
{
public:
Response():_exitcode(0),_result(0){}
Response(int exitcode,int result):_exitcode(exitcode),_result(result){}
bool Serialize(string*out)//序列化
{//_exitcode _result ->"_exitcodeSEP_result"
*out="";
*out+=to_string(_exitcode);
*out+=SEP;
*out+=to_string(_result);return true;
}bool Deserialize(const string& in)//反序列化
{//_exitcodeSEP_result"->_exitcode _resultauto pos=in.find(SEP);
if(pos==string::npos) return false;string excstr=in.substr(0,pos);
string resstr=in.substr(pos+SEP_LEN);
if(excstr.empty()||resstr.empty()) return false;_exitcode=stoi(excstr);
_result=stoi(resstr);return true;}public:
int _exitcode;//退出码
int _result;//结果
};//"text_len"\r\n"x op y"\r\n
bool recvPackage(int sock,string& inbuffer,string*out)
{
char buffer[1024];while(true)
{
ssize_t  s=recv(sock,buffer,sizeof(buffer)-1,0);
if(s>0)
{buffer[s]=0;inbuffer+=buffer;auto pos=inbuffer.find(LINE_SEP);if(pos==string::npos)continue;//没找到报头和有效载荷之间的分隔符---如果字节流式的报文没读全就继续读string text_len=inbuffer.substr(0,pos);//报头是有效载荷的长度int len=stoi(text_len);int totallen=text_len.size()+LINE_SEP_LEN*2+len;//整个报文的长度if(inbuffer.size()<totallen) {cout<<"输入的消息不完整,请继续输入.continue..."<<endl;continue;//报文没读完继续读}cout<<"处理前的inbuffer: \n"<<inbuffer<<endl;*out=inbuffer.substr(0,totallen);inbuffer.erase(0,totallen);cout<<"处理后的inbuffer: \n"<<inbuffer<<endl;break;
}
else return false;
}return true;}

介绍一下：

  • 在Request类内：
  1. 外部传参两个操作数和一个运算符进来构造Request对象，调用Serialize序列化函数构造字符串"_xSEP_opSEP_y",其中SEP是空格, _x是左操作数, _op是运算符, _y是右操作数
  2. 外部传参数字符串"_xSEP_opSEP_y"进来，调用Deserialize反序列化通过该字符串构造内嵌参数 _x, _op, _y。注意的是，运算符 _op在传入时会将符号转化成其对应的ASCII码。例如"+“会被转化成"43”，此时需要将字符串里的"43"取出来再转化成整形43，方便后续转化回"+"
  • 在Response类内：
  1. 外部传字符串"_exitcodeSEP_result"进来，调用Deserialize反序列化函数构造内嵌参数 _exitcode和 _result。其中 exitcode是退出码，当计算结果正确时退出码为NONE。计算时出现除零错误退出码为DIV_ZERO。计算时出现商零错误退出码为MOD_ZERO。传入参数时运算符传入错误，退出码为OP_ERR； _result是计算结果。
  2. 调用Serialize序列化函数利用内嵌参数 _exitcode和 _result构造字符串" _exitcodeSEP_result"

  • enLength协议定制函数，給传入的字符串加上"报头"，传入字符串"xSEPopSEPy"，加上"报头后字符串为"text_len"\r\n"xSEPopSEPy"\r\n。其中"xSEPopSEPy"为有效载荷，text_len为有效载荷的长度，SEP是空格。

  • deLength协议定制函数。函数作用是給传入的字符串str去"报头"，并把有效载荷通过ret传出去。传入的字符串是"text_len"\r\n"xSEPopSEPy"\r\n，去掉"报头"后，取出字符串 “xSEPopSEPy”。其中SEP是空格。

  • recvPackage函数是供服务器调用接收数据包的函数。服务器接收客户端发送来的报文，若报文不符合定义的协议形式或者没读上来的报文不是完整的则阻塞式读取，直到读上来完整的报文。然后通过输出型参数out将报文传出去。

calserver.cc


#include"calserver.hpp"
#include"log.hpp"
#include<iostream>
#include<stdlib.h>
#include<memory>
using namespace Server;
using namespace std;static void Usage(string proc)
{cout<<"\nUsage:\n\t"<<proc<<" local_port\n\n"<<endl;
}
//req是一个已经处理的完整的对象
bool cal(const Request& req,Response& rep)
//根据req填充rep 
{
switch(req._op)
{case '+':rep._result=req._x+req._y;break;case '-':rep._result=req._x-req._y;break;    case '*':rep._result=req._x*req._y;break;    case '/':{if(req._y==0) rep._exitcode=DIV_ZERO;elserep._result=req._x/req._y;}   break;    case '%':{if(req._y==0) rep._exitcode=MOD_ZERO;elserep._result=req._x%req._y;}break;default:rep._exitcode=OP_ERR;break;
}
return true;}int main(int argc,char* argv[])
{
if(argc!=2)
{Usage(argv[0]);exit(USAGE_ERR);
}uint16_t port=atoi(argv[1]);//将字符串转化为整数unique_ptr<calserver> ts(new calserver(port));
ts->initserver();
ts->start(cal);return 0;
}
  • cal是计算函数，传入Request对象和Response对象。Request对象中参数有两个操作数 _ x、_ y 和一个运算符 _ op，计算出结果放到Response对象的参数_result中，退出码放到 _exitcode。

calserver.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>
#include<functional>
#include"log.hpp"
#include"protocol.hpp"
#define NUM 1024using namespace std;
static const int gbacklog = 5;
namespace Server
{enum{USAGE_ERR=1,SOCK_ERR,BIND_ERR,LISTEN_ERR};typedef function<bool(const Request&req,Response& res)> func_t;void handlerentry(int sock,func_t func)
{string inbuffer;while(true){//1. 获取客户端发送来的数据报,确定数据报是带报头的数据报//"text_len"\r\n"x op y"\r\n string req_text,req_str;if(!recvPackage(sock,inbuffer,&req_text)) return;cout<<"带报头的请求（数据报）: "<<req_text<<endl;//2.对数据报进行反序列化//"text_len"\r\n"x op y"\r\n -> "x op y"---去掉报头，取出里面的内容if(!deLength(req_text,&req_str)) return;cout<<"去掉报头的请求（数据报）:"<<req_str<<endl;//走到这里再往下就卡主了，只打印到上面那条日志后面都没打印到！！！//3.获得一个结构化的请求对象Request req;if(!req.Deserialize(req_str)) return;//如果反序列化失败直接返回//4.对对象进行操作---进行服务器业务//4.1.获得一个结构化响应Response rep;func(req,rep);//5.对对象进行序列化//_exitcode _result ->"_exitcodeSEP_result"string rep_str;rep.Serialize(&rep_str);cout<<"计算完成后的响应： "<<rep_str<<endl;//6.給有效载荷加上报头//"exitcode result" -> "content_len"\r\n"exitcode result"\r\nstring rep_text=enLength(rep_str);cout<<"加上报头的完整响应（报文）: "<<rep_text<<endl;//7.把报文发送回給客户端send(sock,rep_text.c_str(),rep_text.size(),0);}}
typedef function<bool(const Request&req,Response& res)> func_t;
class calserver
{public:
calserver(const uint16_t& port):_port(port),_listensock(-1){}void initserver()
{
//1.创建套接字
_listensock=socket(AF_INET,SOCK_STREAM,0);
if(_listensock<0)
{logMessage(FATAL,"create listensocket error");exit(SOCK_ERR);
}logMessage(NORMAL, "create socket success: %d", _listensock);
//2.bind ip和port
struct sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(_port);
local.sin_addr.s_addr=INADDR_ANY;
if(bind(_listensock,(struct sockaddr*)&local,sizeof(local))<0)//绑定失败
{logMessage(FATAL,"bind error");exit(BIND_ERR);
}logMessage(NORMAL,"bind success");
//3.将套接字设置为监听模式
if(listen(_listensock,gbacklog)<0)
{logMessage(FATAL,"listen error");exit(LISTEN_ERR);
}
logMessage(NORMAL,"listen success");
}
void start(func_t fun)
{while(true){struct sockaddr_in cli;socklen_t len=sizeof(cli);bzero(&cli,len);int sock=accept(_listensock,(struct sockaddr*)&cli,&len);if(sock<0){logMessage(FATAL,"accept client error");continue;}logMessage(NORMAL,"accept client success");cout<<"accept sock: "<<sock<<endl;//多进程版---//一个客户端占用一个文件描述符，原因在于孙子进程执行IO任务需要占用独立的文件描述符,而文件描述符是继承父进程的，而每次客户端进来都要占用新的文件描述符//因此若接收多个客户端不退出的话文件描述符会越来越少。pid_t id=fork();//创建子进程if(id==0)//子进程进入{close(_listensock);//子进程不需要用于监听因此关闭该文件描述符handlerentry(sock,fun);close(sock);exit(0);}//父进程close(sock);pid_t ret=waitpid(id,nullptr,0);if(ret<0){cout << "waitsuccess: " << ret << endl;}}
}
~calserver(){}
private:
int _listensock;//用于监听服务器的sock文件描述符
uint16_t _port;//端口号
};}
  • handlerentry函数是供服务器调用的接收发送函数。传入参数为用于通信的文件描述符sock，调用的计算函数cal（cal在calserver.cc文件中)。服务器调用handlerentry函数，接收到客户端发送来的报文，形式形如"text_len"\r\n"x op y"\r\n；调用deLength函数去"报头"，转化后的字符串形如"x op y"；调用Request对象的反序列函数Deserialize，通过字符串"x op y"填充Request对象的 _ x、_ op、 _ y参数；调用func即cal函数利用Request对象内的参数计算得出结果并构造Response对象；调用Response对象的序列化函数将 参数_exitcode _result 转化为字符串" _exitcodeSEP_result";调用enLength函数加上报头，转化后的字符串形如"content_len"\r\n"exitcode result"\r\n；然后通过send函数将字符串发送給客户端。
  • 注意的是服务器是多进程版，即能够与多个客户端进行并行通信。

calclient.cc

#include<iostream>
#include<string>
#include<memory>
#include"calclient.hpp"
using namespace std;
using namespace client;
static void Usage(string proc)
{cout<<"\nUsage :\n\t"<<proc<<" serverip serverport\n"<<endl;
}
int main(int argc, char* argv[])
{if(argc!=3){Usage(argv[0]);exit(1);}string serverip=argv[1];
uint16_t serverport=atoi(argv[2]);unique_ptr<calclient> tc(new calclient(serverip,serverport));tc->initclient();
tc->start();return 0;
}

calclient.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <ctype.h>
#include"protocol.hpp"
using namespace std;
#define NUM 1024
namespace client
{class calclient
{public:
calclient(const string& ip,const uint16_t& port)
:_sock(-1)
,_port(port)
,_ip(ip)
{}void initclient()
{
//1.创建sockfd
_sock=socket(AF_INET,SOCK_STREAM,0);
if(_sock<0)
{cerr<<"socket create error"<<endl;exit(2);
}
//2.绑定 ip port，不显示绑定，OS自动绑定
}void start()
{
struct sockaddr_in ser;
bzero(&ser,sizeof(ser));
socklen_t len=sizeof(ser);
ser.sin_family=AF_INET;
ser.sin_port=htons(_port);
ser.sin_addr.s_addr=inet_addr(_ip.c_str());
if(connect(_sock,(struct sockaddr *)&ser,len)!=0)
{cerr<<"connect error"<<endl;
}else
{string line;string inbuffer;while(true){cout<<"mycal>>: ";//输入"xopy"getline(cin,line);Request req=ParseLine(line);//用"xopy"取出x op y构造Request对象string context;req.Serialize(&context);//序列化，用x op y构造字符串"xSEPopSEPy"string send_str=enLength(context);//定制协议---"x op y"->"text_len"\r\n"x op y"\r\n---給内容加上报头cout<<"calclient send str: "<<send_str<<endl;send(_sock,send_str.c_str(),send_str.size(),0);//客户端把报文发送給服务器string package;if(!recvPackage(_sock,inbuffer,&package)) continue;//服务器处理完数据，客户端接收服务器发送来的报文//  "content_len"\r\n"exitcode result"\r\nstring reser_len;if(!deLength(package,&reser_len)) continue;//去报头//  "content_len"\r\n"exitcode result"\r\n -> "exitcode result"Response rep;rep.Deserialize(reser_len);//反序列化：//_exitcodeSEP_result"->_exitcode _resultcout<<"_exitcode: "<<rep._exitcode<<endl;cout<<"_result: "<<rep._result<<endl;}
}
}~calclient()
{if(_sock>=0) close(_sock);
}Request ParseLine(const string& line)
{//"xopy"->取出来到x op y 上
int i=0;
int status=0;
int num=line.size();
string left,right;
char op;while(i<num)
{
switch(status)
{case 0:{if(!isdigit(line[i])){op=line[i];//取出运算符**status=1;}elseleft.push_back(line[i++]);//取出左操作数}break;case 1:i++;status=2;break;case 2:right.push_back(line[i++]);break;
}
}
cout<<"left: "<<stoi(left)<<" op: "<<op<<" right: "<<stoi(right)<<endl;
return Request(stoi(left),stoi(right),op);//返回Request对象}private:
int _sock;
uint16_t _port;
string _ip;};
}
  • ParseLine函数接收形如"1+1"的字符串，解析字符串后构造Request对象
  • 客户端调用start函数，接收命令行发送来的形如"1+1"的字符串，然后调用ParseLine函数构造Request对象。调用Request对象的序列化函数Serialize构造字符串"xSEPopSEPy"。调用协议定制函数enLength給字符串加上"报头"，转化后的字符串为"text_len"\r\n"x op y"\r\n；调用send函数将字符串发送給服务器；服务器计算完成后将结果发送回来，调用recvPackage函数接收服务器发送回来的字符串，字符串形如 “content_len”\r\n"exitcode result"\r\n;调用deLength函数去报头，转化后的字符串形如"exitcode result"；调用Response对象的反序列化函数Deserialize通过字符串获取参数_exitcode _result，并进行打印。

makefile

.PHONY:all
all:calclient calservercalclient:calclient.ccg++ -o $@ $^ -std=c++11calserver:calserver.ccg++ -o $@ $^ -std=c++11 .PHONY:clean
clean:rm -rf calserver calclient

image-20230830121135167

利用Json进行序列化和反序列化

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它以易于阅读和写作的文本形式表示结构化数据。JSON由两种结构构成：键值对（键值对集合）和值的有序列表。在这里以键值对的方式使用。

json库的安装

输入以下指令安装

sudo yum install -y jsoncpp-devel

安装完后可通过ls查询

image-20230830151558485

makefile

cc=g++
LD=-DMYPRO
.PHONY:all
all:calclient calservercalclient:calclient.cc$(cc) -o $@ $^ -std=c++11 -ljsoncpp #${LD}calserver:calserver.cc$(cc) -o $@ $^ -std=c++11 -ljsoncpp #${LD}.PHONY:clean
clean:rm -rf calserver calclient
  • 如果不使用Json序列化就注释掉第二行LD=-DMYPRO

protocol.hpp

#pragma once
#include<iostream>
#include<string>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstring>
#include <jsoncpp/json/json.h>
using namespace std;#define SEP " "
#define SEP_LEN strlen(SEP)//strlen统计'\0'之前的字符个数，而sizeof统计的是所占内存的空间大小，使用sizeof会越界出问题
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP)enum {NONE=0,DIV_ZERO,MOD_ZERO,OP_ERR
};
//"x op y"->"text_len"\r\n"x op y"\r\n---給内容加上报头
std::string enLength(const std::string& text)//协议定制
{std::string send_str=to_string(text.size());send_str+=LINE_SEP;send_str+=text;send_str+=LINE_SEP;return send_str;
}
//"text_len"\r\n"x op y"\r\n -> "x op y"---去掉报头，取出里面的内容
bool deLength(const std::string& str,string* ret)//协议定制
{auto it=str.find(LINE_SEP);//找到报头if(it==std::string::npos) return false;//如果没找到则直接返回int len=stoi(str.substr(0,it));//取出字符串的长度*ret=str.substr(it+LINE_SEP_LEN,len);//取出数据return true;
}class Request
{
public:
Request():_x(0),_y(0),_op(0){}
Request(int x,int y,int op):_x(x),_y(y),_op(op){}bool Serialize(std::string* out)//序列化，将传入的x op y转化为字符串"x op y"
{
#ifdef MYPRO*out="";*out+=to_string(_x);*out+=SEP;*out+=to_string(_op);*out+=SEP;*out+=to_string(_y);
#else
Json::Value root;//json的对象是键值对[key,value]
root["first"]=_x;//int类型被设置进json的键值对时自动转换为string类型
root["second"]=_y;
root["oper"]=_op;Json::FastWriter writer;*out=writer.write(root);//调用接口序列化返回值为字符串#endifreturn true;
}bool Deserialize( const string& origin)//反序列化，将传过来的字符串拆出来传参給_x _op _y
{//"_xSEP_opSEP_y"-> _x,_op,_y#ifdef MYPROauto leftit=origin.find(SEP);cout<<"Deserialize找到了leftSEP: "<<leftit<<endl;auto rightit=origin.rfind(SEP);cout<<"Deserialize找到了rightSEP: "<<rightit<<endl;if(leftit==string::npos|| rightit==string::npos) return false;if(leftit==rightit) return false;int opsize=rightit-leftit-1;cout<<"opsize: "<<opsize<<endl;
//1 43 1--leftit=1,rightit=4,opsize=rightit-leftit-1=4-1-1=2;
//1 3 1--leftit=1,right=3,opsize=rightit-leftit-1=3-1-1=1// if(rightit-(leftit+SEP_LEN)!=1) return false;if(rightit-(leftit+SEP_LEN)!=opsize) return false;//+号ASCII码是43，从char转int被解析成43即stringlen为两位,这里的运算rightit-(leftit+SEP_LEN)!=1就出问题
//4-(1+1)==2;3-(1+1)=1std::string origin_x=origin.substr(0,leftit);std::string origin_y=origin.substr(rightit+SEP_LEN);if(origin_x.empty()) return false;if(origin_y.empty()) return false;cout<<"origin_x: "<<origin_x<<" origin_y: "<<origin_y<<endl;_x=stoi(origin_x);int opf=stoi(origin.substr(leftit,rightit));_op=opf;cout<<"opf: "<<opf<<"_op: "<<_op<<endl;_y=stoi(origin_y);
#else
Json::Value root;
Json::Reader reader;
reader.parse(origin,root);//反序列化，将字符串中的协议字符串填进对象对应的元素中_x=root["first"].asInt();
_y=root["second"].asInt();
_op=root["oper"].asInt();
#endifreturn true;}public:int _x;int _y;char _op;
};class Response
{
public:
Response():_exitcode(0),_result(0){}
Response(int exitcode,int result):_exitcode(exitcode),_result(result){}
bool Serialize(string*out)//序列化
{//_exitcode _result ->"_exitcodeSEP_result"
#ifdef MYPRO
*out="";
*out+=to_string(_exitcode);
*out+=SEP;
*out+=to_string(_result);
#else
Json::Value root;
root["exitcode"]=_exitcode;
root["result"]=_result;Json::FastWriter writer;
*out= writer.write(root);
#endifreturn true;
}bool Deserialize(const string& in)//反序列化
{//_exitcodeSEP_result"->_exitcode _result#ifdef MYPRO
auto pos=in.find(SEP);
if(pos==string::npos) return false;string excstr=in.substr(0,pos);
string resstr=in.substr(pos+SEP_LEN);
if(excstr.empty()||resstr.empty()) return false;_exitcode=stoi(excstr);
_result=stoi(resstr);#else
Json::Value root;
Json::Reader reader;
reader.parse(in,root);
_exitcode=root["exitcode"].asInt();
_result=root["result"].asInt();
#endif
return true;}public:
int _exitcode;//退出码
int _result;//结果
};//"text_len"\r\n"x op y"\r\n
bool recvPackage(int sock,string& inbuffer,string*out)
{
char buffer[1024];while(true)
{
ssize_t  s=recv(sock,buffer,sizeof(buffer)-1,0);
if(s>0)
{buffer[s]=0;inbuffer+=buffer;auto pos=inbuffer.find(LINE_SEP);if(pos==string::npos)continue;//没找到报头和有效载荷之间的分隔符---如果字节流式的报文没读全就继续读string text_len=inbuffer.substr(0,pos);//报头是有效载荷的长度int len=stoi(text_len);int totallen=text_len.size()+LINE_SEP_LEN*2+len;//整个报文的长度if(inbuffer.size()<totallen) {cout<<"输入的消息不完整,请继续输入.continue..."<<endl;continue;//报文没读完继续读}cout<<"处理前的inbuffer: \n"<<inbuffer<<endl;*out=inbuffer.substr(0,totallen);inbuffer.erase(0,totallen);cout<<"处理后的inbuffer: \n"<<inbuffer<<endl;break;
}
else return false;
}return true;}
  • Json序列化在Request类和Response类中使用。

条件编译

  • #ifdef指令说明，如果预处理已经定义了后面的标识符（DEBUG），即DEBUG为真，则执行 #ifdef 与 #else 之间的所有所有代码，不执行#else之后的代码。若DEBUFG为未定义，即DEBUG为假，则执行#else与#endif之间的代码。#endif 用于结束该条件编译指令。#ifdef和#endif搭配使用。

格式

#ifdef DEBUG
//......
#else
//......
#endif

//Request类内的Json序列化片段-Serialize
Json::Value root;//json的对象是键值对[key,value]
root["first"]=_x;//int类型被设置进json的键值对时自动转换为string类型
root["second"]=_y;
root["oper"]=_op;Json::FastWriter writer;*out=writer.write(root);//调用接口序列化返回值为字符串
  • 创建一个Json的Value对象，键为"first"对应的值为_x,将操作数和运算符设置进Value对象里，然后通过Json的FastWriter对象调用write进行序列化。
Request类内的Json反序列化片段-Deserialize
Json::Value root;
Json::Reader reader;
reader.parse(origin,root);//反序列化，将字符串中的协议字符串填进对象对应的元素中_x=root["first"].asInt();
_y=root["second"].asInt();
_op=root["oper"].asInt();
  • 创建一个Json的Value对象，然后再创建一个Json的Reader对象，调用Reader对象的parse把携带协议的字符串填进Value对象对应的元素里。然后再通过键值对的方式把元素取出。

image-20230830150840323

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

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

相关文章

AI:05 - 基于深度学习的道路交通信号灯的检测与识别

AI:05 - 基于深度学习的道路交通信号灯的检测与识别

随着人工智能的快速发展，基于深度学习的视觉算法在道路交通领域中起到了重要作用。本文将探讨如何利用深度学习技术实现道路交通信号灯的检测与识别，通过多处代码实例展示技术深度。 道路交通信号灯是指示交通参与者行驶和停止的重要信号。准确地检测和识别交通信号灯对于智…
阅读更多...
06.sqlite3学习——DQL（数据查询）（全）

06.sqlite3学习——DQL（数据查询）（全）

目录 SQLite——DQL&#xff08;数据查询&#xff09; 数据集 select语句 条件查询 比较 确定范围 确定集合 like 查询记录 查询不重复的记录 排序和限制 排序 限制 聚合 聚合函数 语法 SQLite Group By详解 语法 实例 SQLite Having 子句 语法 实例 多…
阅读更多...
Linux通信--构建进程通信System-V 消息队列|信号量

Linux通信--构建进程通信System-V 消息队列|信号量

文章目录 目录 一、消息队列 二、信号量 1.互斥 2.信号量 一、消息队列 消息队列提供了从一个进程向另一个进程发送数据块的方法每个数据块都被认为是有一个类型&#xff0c;接收者进程接收的数据块可以有不同的类型值IPC资源必须删除&#xff0c;不会随进程自动清楚&#…
阅读更多...
webrtc-m79-msvc编译H264

webrtc-m79-msvc编译H264

0 写在前面 本文主要参考&#xff1a;webrtc 4577版本vs编译_tusong86的博客-CSDN博客 4577也就是m93&#xff0c;由于源码版本的不同&#xff0c;可能存在一定的出入&#xff0c;可根据实际情况进行修改&#xff1b; 感谢作者的付出&#xff1b; 1 编译参数 powershell运…
阅读更多...
【git】Idea撤回本地分支、或远程分支提交记录的各种实际场景操作步骤

【git】Idea撤回本地分支、或远程分支提交记录的各种实际场景操作步骤

文章目录 idea撤回本地分支、远程分支场景操作集合场景1&#xff1a;要撤回最后一次本地分支的提交实现效果&#xff1a;操作步骤&#xff1a; 场景2&#xff1a;要撤回最后一次远程分支的提交有撤销记录的&#xff1a;实现效果&#xff1a;操作步骤&#xff1a; 无撤销记录的&…
阅读更多...
数据分析基础-数据可视化学习笔记03-可视化的符号与表示-图形符号学

数据分析基础-数据可视化学习笔记03-可视化的符号与表示-图形符号学

概念 图型符号学&#xff08;Cartographic Symbolization&#xff09;是地图学领域中的一个重要概念&#xff0c;涉及到如何使用不同的符号、颜色、图案和标记来在地图上表示地理信息和数据。图型符号学旨在传达地理信息&#xff0c;使得地图能够清晰、有效地传达各种空间数据…
阅读更多...
微信小程序scroll-view隐藏滚动条参数不生效问题

微信小程序scroll-view隐藏滚动条参数不生效问题

如题&#xff0c;先来看看问题是怎么出现的。 先看文档如何隐藏滚动条&#xff1a; 再根据文档实现wxml文件&#xff1a; <scroll-view show-scrollbar"{{false}}" enhanced><view wx:for"{{1000}}">11111</view> </scroll-view>…
阅读更多...
pytorch异常——RuntimeError:Given groups=1, weight of size..., expected of...

pytorch异常——RuntimeError:Given groups=1, weight of size..., expected of...

文章目录 省流异常报错异常截图异常代码原因解释修正代码执行结果 省流 nn.Conv2d 需要的输入张量格式为 (batch_size, channels, height, width)&#xff0c;但您的示例输入张量 x 是 (batch_size, height, width, channels)。因此&#xff0c;需要对输入张量进行转置。 注意…
阅读更多...
探索未知世界：桌面端3D GIS引领地理信息新时代

探索未知世界：桌面端3D GIS引领地理信息新时代

近年来&#xff0c;桌面端的三维地理信息系统&#xff08;3D GIS&#xff09;在地理信息领域迎来了显著的发展&#xff0c;为我们带来了更深入、更丰富的地理空间认知和数据分析体验。从城市规划到环境保护&#xff0c;从资源管理到应急响应&#xff0c;桌面端的3D GIS正逐渐成…
阅读更多...
day 30 动态GDP柱状图绘制

day 30 动态GDP柱状图绘制

列表.sort(key选择排序依据的函数&#xff0c;reverseTrue|False) 参数key:要求传入一个函数&#xff0c;表示将列表的每一个元素传入函数当中&#xff0c;返回排序的依据&#xff0c; 参数reverse,是否反转排序结果&#xff0c;True降序&#xff0c;False升序 my_list [[&…
阅读更多...
【爬虫小知识】如何利用爬虫爬网页——python爬虫

【爬虫小知识】如何利用爬虫爬网页——python爬虫

前言 网络时代的到来&#xff0c;给我们提供了海量的信息资源&#xff0c;但是&#xff0c;想要获取这些信息&#xff0c;手动一个一个网页进行查找&#xff0c;无疑是一项繁琐且效率低下的工作。这时&#xff0c;爬虫技术的出现&#xff0c;为我们提供了一种高效的方式去获取…
阅读更多...
Android JNI系列详解之生成指定CPU的库文件

Android JNI系列详解之生成指定CPU的库文件

一、前提 这次主要了解Android的cpu架构类型&#xff0c;以及在使用CMake工具的时候&#xff0c;如何指定生成哪种类型的库文件。 如上图所示&#xff0c;是我们之前使用CMake工具默认生成的四种cpu架构的动态库文件&#xff1a;arm64-v8a、armeabi-v7a、x86、x86_64&#xff0…
阅读更多...
【附安装包】MyEclipse2019安装教程

【附安装包】MyEclipse2019安装教程

软件下载 软件&#xff1a;MyEclipse版本&#xff1a;2019语言&#xff1a;简体中文大小&#xff1a;1.86G安装环境&#xff1a;Win11/Win10/Win8/Win7硬件要求&#xff1a;CPU2.5GHz 内存4G(或更高&#xff09;下载通道①百度网盘丨下载链接&#xff1a;https://pan.baidu.co…
阅读更多...
系统架构师---系统规划

系统架构师---系统规划

目录 前言&#xff1a; 项目的提出与选择 项目立项的目标和动机 进行基础研究并获取技术 进行应用研发并获得产品 提供技术服务 信息技术产品的使用者 项目的选择和确定 选择有核心价值的产品、项目或可开发方向 评估项目风险、收益和代价 评估项目的多种实施方式 平…
阅读更多...
app.js和页面.js 实现全局传参

app.js和页面.js 实现全局传参

实现全局传参的几个步骤&#xff1a;1. 在页面.js文件中 输入 const appgetApp() 2.便可以在页面中引用app.js中的globalData中的数据。 注意点&#xff1a;app.js中是使用的是this.globalData (调用自身的数据&#xff09; 页面.js中使用的是app.globalData&#xff08;引用ap…
阅读更多...
国产系统下开发QT程序总结

国产系统下开发QT程序总结

国产系统下开发QT程序总结 1. 国产系统简介 开发国产系统客户端的过程中&#xff0c;会出现兼容性问题。以下介绍Kylin和UOS环境下开发QT程序&#xff0c; 首先麒麟和统信这两个系统基于Ubuntu开发的。所以在Ubuntu开发理论上在国产系统上也能运行。芯片架构又分为amd,arm,mi…
阅读更多...
vue v-for 例子

vue v-for 例子

vue v-for 例子 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Document</title> </head&…
阅读更多...
ArcGIS学习总结（19）——要素转点与空间连接（属性表字段映射）

ArcGIS学习总结（19）——要素转点与空间连接（属性表字段映射）

1.在新创建的面矢量数据的属性表中没有对应的字段信息&#xff0c;为了能够和有属性信息的数据进行匹配&#xff0c;使其具有对应字段的信息。 2.需要匹配的矢量文件属性表信息。 3.对新创建的矢量文件执行要素转点&#xff1a;数据管理工具→要素→要素转点。 4.选择分析工…
阅读更多...
AI聊天机器人平台Poe发布更新；自然语言理解课程概要

AI聊天机器人平台Poe发布更新；自然语言理解课程概要

&#x1f989; AI新闻 &#x1f680; AI聊天机器人平台Poe发布更新 突破功能限制 增加企业级服务 摘要&#xff1a;知名问答网站Quora旗下的AI聊天机器人平台Poe发布了一系列更新&#xff0c;包括推出Mac应用、支持同时进行多个对话、接入Meta的Llama 2模型等功能。用户只需支…
阅读更多...
Shell 脚本入门

Shell 脚本入门

目录 一、Shell是什么 1.1 我们为什么要学习Shell和使用Shell&#xff1f; 1.2 Shell的分类有哪些&#xff1f; 二、Shell脚本入门知识 2.1 Shell文件命名规范 2.2 Shell解析器 2.3 用Shell 编写hello World 三、Shell的四种变量类型 3.1 系统预定义变量 3.2 自定义变…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023