1. Toy模板网首页
  2. > Toy博客

【网络编程】协议定制+Json序列化与反序列化

10月前 作者：蒋灵瑜的笔记本 分类：Toy博客 阅读(55) 违法举报

这篇具有很好参考价值的文章主要介绍了【网络编程】协议定制+Json序列化与反序列化。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【网络编程】协议定制+Json序列化与反序列化

需要云服务器等云产品来学习Linux的同学可以移步/-->腾讯云<--/-->阿里云<--/-->华为云<--/官网，轻量型云服务器低至112元/年，新用户首次下单享超低折扣。

 目录

一、序列化与反序列化的概念

二、自定义协议设计一个网络计算器

2.1TCP协议，如何保证接收方收到了完整的报文呢？

2.2自定义协议的实现

2.3自定义协议在客户端与服务器中的实现

三、使用Json进行序列化和反序列化

3.1jsoncpp库的安装

3.2改造自定义协议

3.3自定义协议的命名区分

网络版计算器代码可参考博主gitee。

一、序列化与反序列化的概念

        序列化是指将对象转换为字节流或其他可存储或传输的格式，以便将其存储在文件中或通过网络发送到另一个系统。反序列化是指将序列化的数据重新转换为对象。在序列化和反序列化过程中，对象的状态信息被保存和恢复，以保证数据的完整性和正确性。在分布式系统中，序列化和反序列化是实现远程方法调用和消息传递的重要技术。

        例如微信发送一条消息，会将头像、昵称、消息内容、发送时间等“结构化”数据进行序列化，形成一个字节流报文，通过网络将该报文发送给接收方，接收方进行反序列化将报文重新拆解为头像、昵称、消息内容、发送时间等“结构化”数据。

【网络编程】协议定制+Json序列化与反序列化

二、自定义协议设计一个网络计算器

2.1TCP协议，如何保证接收方收到了完整的报文呢？

【网络编程】协议定制+Json序列化与反序列化

1、我们调用的所有发送/接收函数，并不是直接从网络中发送/接收数据，应用层调用的发送/接收函数，本质是一个拷贝函数。
例如客户端发送数据时，应用层调用发送函数将会把应用层的发送缓冲区数据拷贝至传输层的发送缓冲区。传输层自主决定何时将发送缓冲区的数据发送至网络里，再通过网络发送至服务器的接收缓冲区中，所以TCP协议是一种传输控制协议。

2、TCP协议的通信双方的发送缓冲区和接收缓冲区互不干扰，可以双向同时进行通信。TCP是一种全双工的通信协议。

3、如果TCP服务器的读取速度跟不上客户端的发送速度，将会导致服务器接收缓冲区积攒大量的报文，这些报文数据可是一连串的粘连在一起的，如何一条一条的将完整的报文提取出来呢？使用协议！协议设计方式：

  • 定长（例如规定该报文定长为1024字节）
  • 特殊符号（在报文和报文之间增加特殊符号）
  • 自描述方式（自己设计协议）

本文代码协议设计如下图所示：使用该协议设计一个网络计算器。

【网络编程】协议定制+Json序列化与反序列化

        如果是UDP协议，UDP客户端，发送报文时只需创建请求，对请求进行序列化后即可发送；接收报文时只需将接收的数据进行反序列化即可。无需进行协议内容的添加与解析。这是因为UDP每次发送与接收都是以数据报的形式，数据是完整的，不像TCP是面向字节流，需要使用相关的协议进行界定报文边界。

2.2自定义协议的实现

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
enum
{
    OK=0,
    DIV_ZERO_ERR,
    MOD_ZERO_ERR,
    OP_ZERO_ERR,
};
#define SEP " "
#define SEP_LEN strlen(SEP)//不能使用sizeof，用sizeof会统计到'\0'
#define LINE_SEP "\r\n"
#define LINE_SEP_LINE strlen(LINE_SEP)
//"_exitcode result" -> "content_len"\r\n"_exitcode result"\r\n
//"_x _op _y" -> "content_len"\r\n"_x _op _y"\r\n
std::string enLength(const std::string& text)//text:_x _op _y。添加协议规则，用于构建一个完整的报文（类似"打包"）
{
    std::string send_string=std::to_string(text.size());//计算有效载荷的长度"_x _op _y"
    send_string+=LINE_SEP;
    send_string+=text;
    send_string+=LINE_SEP;
    return send_string;
}
//_exitcode result
bool deLength(const std::string& package,std::string* text)//获取报文中的有效载荷（类似"解包"）
{
    auto pos=package.find(LINE_SEP);
    if(pos==std::string::npos){return false;}
    int textLen=std::stoi(package.substr(0,pos));//计算有效载荷的长度
    *text=package.substr(pos+LINE_SEP_LINE,textLen);
    return true;
}
class Request//请求类
{
public:
    Request(int x,int y,char op)
        :_x(x)
        ,_y(y)
        ,_op(op)
    {}
    Request()
        :_x(0)
        ,_y(0)
        ,_op(0)
    {}
    bool serialize(std::string* out)//序列化，将成员变量转字符串
    {
        //结构化->"_x _op _y"
        *out="";//清空string对象
        std::string x_tostring=std::to_string(_x);
        std::string y_tostring=std::to_string(_y);
        *out=x_tostring+SEP+_op+SEP+y_tostring;//_x _op _y
        return true;
    }
    bool deserialize(const std::string& in)//反序列化
    {
        //"_x _op _y"->结构化
        auto leftSpace=in.find(SEP);//左边的空格
        auto rightSpace=in.rfind(SEP);//右边的空格
        if(leftSpace==std::string::npos||rightSpace==std::string::npos){return false;}
        if(leftSpace==rightSpace){return false;} 
        //子串提取
        std::string x_tostring=in.substr(0,leftSpace);
        if(rightSpace-(leftSpace+SEP_LEN)!=1){return false;}//表示操作符一定只占1位
        _op=in.substr(leftSpace+SEP_LEN,rightSpace-(leftSpace+SEP_LEN))[0];
        std::string y_tostring=in.substr(rightSpace+SEP_LEN);
        //对x，y进行转换
        _x=std::stoi(x_tostring); 
        _y=std::stoi(y_tostring);
        return true;
    }
public:
    //_x _op _y
    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(std::string* out)//序列化，将成员变量转string对象
    {
        *out="";//清空string对象
        std::string outString=std::to_string(_exitCode)+SEP+std::to_string(_result);
        *out=outString;
        return true; 
    }
    bool deserialize(const std::string& in)//反序列化
    {
        auto space=in.find(SEP);//找空格
        if(space==std::string::npos){return false;}
        std::string exitString=in.substr(0,space);
        std::string resString=in.substr(space+SEP_LEN);
        if(exitString.empty()||resString.empty()){return false;}//一个字符串为空就false
        _exitCode=std::stoi(exitString);
        _result=std::stoi(resString);
        return true;
    }
public:
    int _exitCode;//0表示计算成功，非零代表除零等错误
    int _result;//运算结果
};

bool recvPackage(int sock,std::string& inbuffer,std::string* text)//服务器/客户端读取报文
{
    //将缓冲区数据拆分成一个个报文"content_len"\r\n"_x _op _y"\r\n
    char buffer[1024];
    while(1)
    {
        ssize_t n=recv(sock,buffer,sizeof(buffer)-1,0);//阻塞式读取，等价于read接口
        if(n>0)
        {
            buffer[n]=0;//字符串末尾添加'\0'
            inbuffer+=buffer;
            //拆分成一个个报文
            auto pos=inbuffer.find(LINE_SEP);//找\r\n的起始位置
            if(pos==std::string::npos)//没找到说明暂时还没找到\r\n分隔符，跳过本次循环，等待下次读取
            {
                continue;
            }
            std::string textLenString=inbuffer.substr(0,pos);
            int textLen=std::stoi(textLenString);//拿出有效载荷的长度
            int totalLen=textLenString.size()+2*LINE_SEP_LINE+textLen;//单个报文总长度
            if(inbuffer.size()<totalLen)//说明缓冲区长度还不到一个报文大小，需要跳过本次循环继续读取
            {
                continue;
            }
            std::cout<<"截取报文前inbuffer中的内容:\n"<<inbuffer<<std::endl;
            //走到这里，一定有一个完整的报文
            *text=inbuffer.substr(0,totalLen);//取出一个报文
            inbuffer.erase(0,totalLen);//删掉缓冲区中刚刚被提取走的报文数据
            std::cout<<"截取报文后inbuffer中的内容:\n"<<inbuffer<<std::endl;
            break;
        }
        else
        {
            return false;
        }
    }
    return true;
}

代码解释：

本协议设计了一个Request请求类和一个Response响应类，请求类存储计算器的操作数和操作符，响应类存储计算结果和退出码。这两个类中各自实现了对有效载荷的序列化与反序列化的接口。

enLength用于给有效载荷添加报头，即自定义协议的规则。deLength则用于解析收到的报文，剔除报文中的协议报头，提取出其中的有效载荷。协议是明确缓冲区中报文与报文之间边界的一种特殊格式，而enLength和deLength用于添加报头和去掉报头。

2.3自定义协议在客户端与服务器中的实现

【网络编程】协议定制+Json序列化与反序列化

三、使用Json进行序列化和反序列化

3.1jsoncpp库的安装

        从上方代码可以看到，使用string对象手动进行序列化与反序列化非常麻烦。可以使用Json进行序列化与反序列化操作。

        Json（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于Web应用程序中的数据传输。它是一种基于文本的格式，易于读写和解析。Json格式的数据可以被多种编程语言支持，包括JavaScript、Python、Java、C#、C++等。Json数据由键值对组成，使用大括号表示对象，使用方括号表示数组。

【网络编程】协议定制+Json序列化与反序列化

        C++使用Json需要包含Jsoncpp库，yum安装Jsoncpp库指令：先执行第二句，如果报错再执行第一句！

sudo mv /var/lib/rpm/__db.00* /tmp/&&yum clean all
sudo yum install -y jsoncpp-devel

3.2改造自定义协议

makefile：使用jsoncpp库记得在编译时加上-ljsoncpp

cc=g++#将cc变量设置为g++编译器
LD=#-DMYSELF
.PHONY:all
all:calClient calServer

calClient:calClient.cc
	$(cc) -o $@ $^ -std=c++11 -ljsoncpp ${LD}
calServer:calServer.cc
	$(cc) -o $@ $^ -std=c++11 -ljsoncpp ${LD}
	
.PHONY:clean
clean:
	rm -f calClient calServer

改造的协议： 

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <jsoncpp/json/json.h>
#include <sys/types.h>
#include <sys/socket.h>
enum
{
    OK=0,
    DIV_ZERO_ERR,
    MOD_ZERO_ERR,
    OP_ZERO_ERR,
};
#define SEP " "
#define SEP_LEN strlen(SEP)//不能使用sizeof，用sizeof会统计到'\0'
#define LINE_SEP "\r\n"
#define LINE_SEP_LINE strlen(LINE_SEP)
//"_exitcode result" -> "content_len"\r\n"_exitcode result"\r\n
//"_x _op _y" -> "content_len"\r\n"_x _op _y"\r\n
std::string enLength(const std::string& text)//text:_x _op _y。添加协议规则，用于构建一个完整的报文（类似"打包"）
{
    std::string send_string=std::to_string(text.size());//计算有效载荷的长度"_x _op _y"
    send_string+=LINE_SEP;
    send_string+=text;
    send_string+=LINE_SEP;
    return send_string;
}
//_exitcode result
bool deLength(const std::string& package,std::string* text)//获取报文中的有效载荷（类似"解包"）
{
    auto pos=package.find(LINE_SEP);
    if(pos==std::string::npos){return false;}
    int textLen=std::stoi(package.substr(0,pos));//计算有效载荷的长度
    *text=package.substr(pos+LINE_SEP_LINE,textLen);
    return true;
}
class Request//请求类
{
public:
    Request(int x,int y,char op)
        :_x(x)
        ,_y(y)
        ,_op(op)
    {}
    Request()
        :_x(0)
        ,_y(0)
        ,_op(0)
    {}
    bool serialize(std::string* out)//序列化，将成员变量转字符串
    {
#ifdef MYSELF
        //结构化->"_x _op _y"
        *out="";//清空string对象
        std::string x_tostring=std::to_string(_x);
        std::string y_tostring=std::to_string(_y);
        *out=x_tostring+SEP+_op+SEP+y_tostring;//_x _op _y
#else
        //Json序列化
        Json::Value root;//Json::Value万能对象，可接收任何对象
        root["first"]=_x;//自动将_x转换为字符串
        root["second"]=_y;
        root["oper"]=_op;
        //序列化
        Json::FastWriter writer;//Json::StyledWriter write;等价
        *out=writer.write(root);//将root进行序列化，返回值为string对象，接收即可
#endif
        return true;
    }
    bool deserialize(const std::string& in)//反序列化
    {
#ifdef MYSELF
        //"_x _op _y"->结构化
        auto leftSpace=in.find(SEP);//左边的空格
        auto rightSpace=in.rfind(SEP);//右边的空格
        if(leftSpace==std::string::npos||rightSpace==std::string::npos){return false;}
        if(leftSpace==rightSpace){return false;} 
        //子串提取
        std::string x_tostring=in.substr(0,leftSpace);
        if(rightSpace-(leftSpace+SEP_LEN)!=1){return false;}//表示操作符一定只占1位
        _op=in.substr(leftSpace+SEP_LEN,rightSpace-(leftSpace+SEP_LEN))[0];
        std::string y_tostring=in.substr(rightSpace+SEP_LEN);
        //对x，y进行转换
        _x=std::stoi(x_tostring); 
        _y=std::stoi(y_tostring);
#else
        //Json反序列化
        Json::Value root;//Json::Value万能对象，可接收任何对象
        Json::Reader reader;
        reader.parse(in,root);//第一个参数：解析哪个流；第二个参数：将解析的数据存放到对象中
        //反序列化
        _x=root["first"].asInt();//默认是字符串，转换为整型
        _y=root["second"].asInt();
        _op=root["oper"].asInt();//转换为整型，整型可以给char类型。
#endif
        return true;
    }
public:
    //_x _op _y
    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(std::string* out)//序列化，将成员变量转string对象
    {
#ifdef MYSELF
        *out="";//清空string对象
        std::string outString=std::to_string(_exitCode)+SEP+std::to_string(_result);
        *out=outString;
#else
        //Json序列化
        Json::Value root;//Json::Value万能对象，可接收任何对象
        root["exitCode"]=_exitCode;//自动将_exitCode转换为字符串
        root["result"]=_result;
        //序列化
        Json::FastWriter writer;//Json::StyledWriter write;等价
        *out=writer.write(root);//将root进行序列化，返回值为string对象，接收即可
#endif
        return true; 
    }
    bool deserialize(const std::string& in)//反序列化
    {
#ifdef MYSELF
        auto space=in.find(SEP);//找空格
        if(space==std::string::npos){return false;}
        std::string exitString=in.substr(0,space);
        std::string resString=in.substr(space+SEP_LEN);
        if(exitString.empty()||resString.empty()){return false;}//一个字符串为空就false
        _exitCode=std::stoi(exitString);
        _result=std::stoi(resString);
#else
        //Json反序列化
        Json::Value root;//Json::Value万能对象，可接收任何对象
        Json::Reader reader;
        reader.parse(in,root);//第一个参数：解析哪个流；第二个参数：将解析的数据存放到对象中
        //反序列化
        _exitCode=root["exitCode"].asInt();//默认是字符串，转换为整型
        _result=root["result"].asInt();
#endif
        return true;
    }
public:
    int _exitCode;//0表示计算成功，非零代表除零等错误
    int _result;//运算结果
};

bool recvPackage(int sock,std::string& inbuffer,std::string* text)//服务器/客户端读取报文
{
    //将缓冲区数据拆分成一个个报文"content_len"\r\n"_x _op _y"\r\n
    char buffer[1024];
    while(1)
    {
        ssize_t n=recv(sock,buffer,sizeof(buffer)-1,0);//阻塞式读取，等价于read接口
        if(n>0)
        {
            buffer[n]=0;//字符串末尾添加'\0'
            inbuffer+=buffer;
            //拆分成一个个报文
            auto pos=inbuffer.find(LINE_SEP);//找\r\n的起始位置
            if(pos==std::string::npos)//没找到说明暂时还没找到\r\n分隔符，跳过本次循环，等待下次读取
            {
                continue;
            }
            std::string textLenString=inbuffer.substr(0,pos);
            int textLen=std::stoi(textLenString);//拿出有效载荷的长度
            int totalLen=textLenString.size()+2*LINE_SEP_LINE+textLen;//单个报文总长度
            if(inbuffer.size()<totalLen)//说明缓冲区长度还不到一个报文大小，需要跳过本次循环继续读取
            {
                continue;
            }
            std::cout<<"截取报文前inbuffer中的内容:\n"<<inbuffer<<std::endl;
            //走到这里，一定有一个完整的报文
            *text=inbuffer.substr(0,totalLen);//取出一个报文
            inbuffer.erase(0,totalLen);//删掉缓冲区中刚刚被提取走的报文数据
            std::cout<<"截取报文后inbuffer中的内容:\n"<<inbuffer<<std::endl;
            break;
        }
        else
        {
            return false;
        }
    }
    return true;
}
bool recvPackageAll(int sock,std::string& inbuffer,std::vector<std::string>* out)
{
    std::string line; 
    while(recvPackage(sock,inbuffer,&line))
    {
        out->push_back(line);
    }
}

3.3自定义协议的命名区分

        未来在一套系统中可以自定义多种协议，为了区分不同的自定义协议，可以参照如下格式设计协议的格式：

【网络编程】协议定制+Json序列化与反序列化

当然前人已经设计好了常见的网络协议，例如http/https。

【网络编程】协议定制+Json序列化与反序列化文章来源地址https://www.toymoban.com/news/detail-461929.html

到了这里，关于【网络编程】协议定制+Json序列化与反序列化的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 协议定制 + Json序列化反序列化

    协议定制 + Json序列化反序列化

    1.1 结构化数据 协议是一种 “约定”，socket api的接口, 在读写数据时，都是按 “字符串” 的方式来发送接收的。如果我们要传输一些\\\"结构化的数据\\\" 怎么办呢? 结构化数据： 比如我们在QQ聊天时，并不是单纯地只发送了消息本身，是把自己的头像、昵称、发送时间、消息本身

    2024年02月09日
    浏览(46)
  • 【网络】协议定制+序列化/反序列化

    【网络】协议定制+序列化/反序列化

    如果光看定义很难理解序列化的意义，那么我们可以从另一个角度来推导出什么是序列化, 那么究竟序列化的目的是什么？ 其实序列化最终的目的是为了对象可以 跨平台存储，和进行网络传输 。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是

    2024年02月08日
    浏览(43)
  • 【网络】应用层——协议定制 | 序列化和反序列化 | 初识http

    【网络】应用层——协议定制 | 序列化和反序列化 | 初识http

    🐱作者：一只大喵咪1201 🐱专栏：《网络》 🔥格言： 你只管努力，剩下的交给时间！ 在前面本喵已经带大家见识过了 scoket 网络通信的样子，现在开始深入学习网络的原理，本喵采取的策略是从顶层往底层讲解，也就是从应用层到数据链路层的顺序。 我们知道，协议就是

    2024年02月15日
    浏览(47)
  • TCP定制协议，序列化和反序列化

    TCP定制协议，序列化和反序列化

    目录 前言 1.理解协议 2.网络版本计算器 2.1设计思路 2.2接口设计 2.3代码实现： 2.4编译测试 总结         在之前的文章中，我们说TCP是面向字节流的，但是可能对于面向字节流这个概念，其实并不理解的，今天我们要介绍的是如何理解TCP是面向字节流的，通过编码的方式，自

    2024年02月12日
    浏览(34)
  • 【Linux后端服务器开发】协议定制（序列化与反序列化）

    【Linux后端服务器开发】协议定制（序列化与反序列化）

    目录 一、应用层协议概述 二、序列化与反序列化 Protocal.h头文件 Server.h头文件 Client.h头文件 server.cpp源文件 client.cpp源文件 什么是应用层 ？我们通过编写程序解决一个个实际问题、满足我们日常需求的网络程序，都是应用层程序。 协议是一种“约定”，socket的api接口，在读

    2024年02月16日
    浏览(40)
  • 协议，序列化，反序列化，Json

    协议，序列化，反序列化，Json

    协议究竟是什么呢？首先得知道主机之间的网络通信交互的是什么数据，像平时使用聊天APP聊天可以清楚，用户看到的不仅仅是聊天的文字，还能够看到用户的头像昵称等其他属性。也就可以证明网络通信不仅仅是交互字符串那么简单。事实上网络通信还可能会通过一个结构

    2024年02月13日
    浏览(40)

  • 序列化协议：JSON和XML

    作者：CARROT 链接：https://www.zhihu.com/question/604811576/answer/3100483698 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。   json和xml都是数据传输的格式。比如我们开发过程中需要和网页交换数据，我们既可以使用json格式也可以使用xml格式。再

    2024年02月11日
    浏览(36)
  • 【Linux】简单的网络计算器的实现（自定义协议，序列化，反序列化）

    【Linux】简单的网络计算器的实现（自定义协议，序列化，反序列化）

    我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端` 详细可参考我之前写的博客【Linux】记录错误信息日志的实现

    2024年02月19日
    浏览(55)

  • Android网络编程，HTTP请求和Json解析

    以下代码模拟了点击按钮请求百度的网页源码： 其中需要注意的是Android在API27之后不再支持明文访问HTTP，需要在manifest文件中配置属性允许使用明文访问， 并且Url需要使用https layout.xml 字节流转换字符串工具类： 主类.java: 配置manifest.xml文件： 将上述代码中的webview相关内容

    2023年04月09日
    浏览(41)
  • 【网络编程·网络层】IP协议

    【网络编程·网络层】IP协议

    需要云服务器等云产品来学习Linux的同学可以移步/--腾讯云--/--阿里云--/--华为云--/官网，轻量型云服务器低至112元/年，新用户首次下单享超低折扣。  目录 一、IP协议的概念 二、IP协议的报头 1、四位首部长度 2、16位总长度（解包） 3、8位协议（分用） 4、16位首部校验和

    2024年02月13日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包