【Linux网络编程】序列化与反序列化

我们网络收发数据实际上只能接收到字符串,但是在现实生活中描述一个客观物体都是以很多属性来描述的,所以在网络中结构体类型的数据更常见,那我们如何发送结构体数据呢?

这里就涉及到协议的概念了。我们想象一个场景,在特种兵执行任务时,他们有特定的战术手语,这样他们就能根据手语进行相应的战术配合了。所以协议也是一样,客户端和服务器都遵循相同的协议,以某种格式把字符串变成结构体或把结构体变成字符串。这个过程中就是序列化与反序列化。

序列化:结构体类型数据转化成字节序

反序列化:字节序转化成结构体类型数据

话不多说,看图

服务器利用套接字接收请求,进行反序列化后,对请求进行业务处理,处理完成把结果生成响应

然后序列化发送给客户端。自然,客户端接收响应也必须反序列化。

简易网络计算器协议协议部分代码:定制自己的协议,确定数据格式。

下面还利用到了Json这种数据转换格式语言。

cpp 复制代码
#pragma once

#include <vector>
#include <string>
#include "Util.hpp"
#include <iostream>
#include <jsoncpp/json/json.h>
// 利用条件编译,在这里定义一个宏,如果定义了就走a,否则就走b,这相当于是一个开关

// #define HAHA 666
//  给网络版本计算器制定协议
namespace Protocol_ns
{

#define SEP " "
#define SEP_LEN strlen(SEP) // 不能用sizeof
#define HEADER_SEP "\r\n"
#define HEADER_SEP_LEN strlen("\r\n")

    // 请求/响应 = 报头\r\n有效载荷\r\n

    // "10 + 20" => "7"\r\n""10 + 20"\r\n
    std::string AddHeader(std::string &str)
    {
        std::string s = std::to_string(str.size());

        s += HEADER_SEP;
        s += str;
        s += HEADER_SEP;
        return s;
    }

    // 读取一个完整的报文;
    int ReadPackage(int sock, std::string &inbuffer, std::string *package)
    {

        char buffer[1024];
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 读取
        if (n <= 0)
            return -1;
        buffer[n] = 0; // 添加字符串末尾'/0';
        inbuffer += buffer;

        size_t pos = inbuffer.find(HEADER_SEP);
        if (pos == std::string::npos)
            return 0; // 虽然读到了数据,但是不存在一个完整的报文,应该继续读取

        std::string lenStr = inbuffer.substr(0, pos);
        int len = Util::toInt(lenStr);
        int targetPackageLen = HEADER_SEP_LEN * 2 + len + lenStr.size();
        if (inbuffer.size() < targetPackageLen)
            return 0; // 虽然读到了数据,但是不存在一个完整的报文,应该继续读取

        *package = inbuffer.substr(0, targetPackageLen); // 提取到了整个报文
        inbuffer.erase(0, targetPackageLen);             // 从inbuffer中直接移除整个报文

        return len; // 返回有效载荷长度
    }

    // "7"\r\n""10 + 20"\r\n => "10 + 20"
    void RemoveHeader(std::string *package, int len)
    {
        size_t pos = (*package).find(HEADER_SEP);
        *package = (*package).erase(0, pos);

        *package = (*package).erase(0, HEADER_SEP_LEN);

        *package = (*package).substr(0, len);
    }

    // Request && Response都要提供序列化和反序列化功能
    class Request
    {
    public:
        Request() {}

        Request(int x, int y, char op)
            : _x(x), _y(y), _op(op)
        {
        }

        // struct -> string
        bool Serialization(std::string *outStr)
        {
            *outStr = "";
#ifdef HAHA

            std::string x_string = std::to_string(_x);
            std::string y_string = std::to_string(_y);

            // 手动序列化
            *outStr = x_string + SEP + _op + SEP + y_string; // outstr在这里是输出型参数;
#else
            Json::Value root; // Value: 一种万能对象, 接受任意的kv类型

            root["x"] = _x;
            root["y"] = _y;
            root["op"] = _op;

            Json::StyledWriter writer; // Writer是用来进行序列化的,struct->string
            *outStr = writer.write(root);

#endif
            return true;
        }

        // string->struct
        bool Deserialization(const std::string &inStr)
        {
#ifdef HAHA

            std::vector<std::string> result;
            Util::StringSplit(inStr, SEP, &result); // 对序列化数据进行分割,这相当于是一种解释;
            if (result.size() != 3)
                return false;
            if (result[1].size() != 1)
                return false;

            _x = Util::toInt(result[0]);
            _y = Util::toInt(result[2]);
            _op = result[1][0];
#else
            Json::Value root;
            Json::Reader reader; // Reader:用来进行反序列化的。

            reader.parse(inStr, root);
            _x = root["x"].asInt();
            _y = root["y"].asInt();
            _op = root["op"].asInt();

#endif
            return true;
        }

        ~Request() {}

    public:
        int _x;
        int _y;
        char _op;
    };

    class Response
    {
    public:
        Response() {}

        Response(int result, int code)
            : _result(result), _code(code)
        {
        }

        bool Serialization(std::string *outStr)
        {

            *outStr = "";
#ifdef HAHA
            std::string _result_string = std::to_string(_result);
            std::string _code_string = std::to_string(_code);

            // 手动序列化
            *outStr = _result_string + SEP + _code_string; // outstr在这里是输出型参数;

#else
            Json::Value root;
            root["result"] = _result;
            root["code"] = _code;

            Json::StyledWriter writer; // writer::用来进行序列化的;

            *outStr = writer.write(root);

#endif
            return true;
        }

        bool Deserialization(const std::string &inStr)
        {
#ifdef HAHA
            std::vector<std::string> result;
            Util::StringSplit(inStr, SEP, &result); // 对序列化数据进行分割,这相当于是一种解释;
            if (result.size() != 2)
                return false;

            _result = Util::toInt(result[0]);
            _code = Util::toInt(result[1]);
#else
            Json::Value root;
            Json::Reader reader;

            reader.parse(inStr,root);
            _result=root["result"].asInt();
            _code=root["code"].asInt();


#endif
            return true;
        }

        ~Response() {}

    public:
        int _result;
        int _code; // 0 success, 1,2,3,4代表不同的错误码;
    };
}
相关推荐
龙哥说跨境9 分钟前
如何利用指纹浏览器爬虫绕过Cloudflare的防护?
服务器·网络·python·网络爬虫
懒大王就是我23 分钟前
C语言网络编程 -- TCP/iP协议
c语言·网络·tcp/ip
Elaine20239137 分钟前
06 网络编程基础
java·网络
pk_xz1234562 小时前
Shell 脚本中变量和字符串的入门介绍
linux·运维·服务器
小珑也要变强2 小时前
Linux之sed命令详解
linux·运维·服务器
海绵波波1072 小时前
Webserver(4.3)TCP通信实现
服务器·网络·tcp/ip
Lary_Rock4 小时前
RK3576 LINUX RKNN SDK 测试
linux·运维·服务器
热爱跑步的恒川5 小时前
【论文复现】基于图卷积网络的轻量化推荐模型
网络·人工智能·开源·aigc·ai编程
云飞云共享云桌面6 小时前
8位机械工程师如何共享一台图形工作站算力?
linux·服务器·网络
Peter_chq6 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端