计算机网络 -- 序列化与反序列化

已于 2024-05-16 07:54:40 修改
阅读量867 收藏 19
点赞数 29
文章标签： 计算机网络 网络 tcp/ip 网络协议 服务器 java c++
于 2024-05-15 21:01:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sushhsishdgsusk/article/details/138862021
版权

一 协议的重要性

  我们都知道，在进行网络通信的过程中，通信的双方可以是不同的设备，不同的平台，不同的平台，比如说，手机用户和电脑用户进行通信，ios系统和安卓系统进行通信。

  自己的数据，如何保证对方端能安全接收到呢，假设linux为服务端，Windows为客户端，如何确保数据能被正确接收呢？

  就像我们中国人用中文进行交流一样，假设我们和某个外国人进行交流，母语的差异导致双方无法正常交流，信息也无法传达，于是我们只能打开手机上的 同声传译功能，可以将信息转换为对方能听懂的语言，最终实现交流。 

  同声传译 这个功能可以看做一种 协议（可以确保对端能理解自己传达的信息），协议 的出现解决了主机间的交流问题。

  也就是说，我们通过协议，规定了网络通信的双方，必须按照某种规则来对传输的内容进行解析或者是打包。

  对于网络来说，协议是双方通信的基石，如果没有协议，那么即使数据传输的再完美也无法使用，比如下面这个就是一个简单的 两正整数运算协议。

  • 协议要求：发送的数据必须由两个操作数（正整数）和一个运算符组成，并且必须遵循 x op y 这样的运算顺序。
int x;
int y;
char op; // 运算符

  主机A在发送消息时需要将 操作数x、操作数y和运算符op 进行传递，只要主机A和主机B都遵循这个 协议，那么主机B在收到消息后一定清楚这是两个操作数和一个运算符

  现在的问题是如何传递？

方案一：将两个操作数和一个运算符拼接在一起直接传递
方案二：将两个操作数和一个运算符打包成一个结构体传递

方案一：直接拼接 xopy

方案二：封装成结构体
struct Mssage{
	int x;
	int y;
	char op;
};

  无论是方案一还是方案二都存在问题，前者是对端接收到消息后无法解析，后者则是存在平台兼容问题（不同平台的结构体内存规则可能不同，会导致读取数据出错）

  要想确保双方都能正确理解 协议，还需要进行 序列化与反序列化 处理。

二 .什么是序列化与反序列化？

  序列化是指 将一个或多个需要传递的数据，按照协议的格式，拼接为一条字节流数据，反序列化则是 将收到的数据按照格式解析。 

  可见，反序列化和序列化就是协议的一部分。

  比如主机A想通过 两正整数运算协议 给主机B发送这样的消息:

//1+1
int x = 1;
int y = 1;
char op = '+';

可以根据格式（这里使用 （空格））进行 序列化，序列化后的数据长这样：

// 经过序列化后得到
string msg = "1 + 1";

在经过网络传输后，主机B收到了消息，并根据 （空格）进行 反序列化，成功获取了主机A发送的信息。

string msg = "1 + 1";

// 经过反序列化后得到
int x = 1;
int y = 1;
char op = '+';

   这里可以将需要传递的数据存储在结构体中，传递/接收 时将数据填充至类中，类中提供 序列化与反序列化 的相关接口即可。

  

class Request
{
public:
	void Serialization(string* str)
	{}

	void Deserialization(const sting& str)
	{}
	
public:
	int _x;
	int _y;
	char _op;
};

  以上就是一个简单的 序列化和反序列化 流程，简单来说就是 协议 定制后不能直接使用，需要配合 序列化与反序列化 这样的工具理解，接下来我们就基于 两正整数运算协议 编写一个简易版的网络计算器，重点在于 理解协议、序列化和反序列化。

三 相关程序的实现框架

我们接下来要编写的程序从实现功能来看是十分简单的：

  客户端给出两个正整数和一个运算符，服务器计算出结果后返回

整体框架为：

客户端获取正整数与运算符 -> 将这些数据构建出 Request 对象 -> 序列化 -> 将结果（数据包）传递给服务器 ->

服务器进行反序列化 -> 获取数据 -> 根据数据进行运算 -> 将运算结果构建出 Response 对象（回响对象） -> 序列化 -> 将结果（数据包）传递给客户端 -> 客户端反序列后获取最终结果。

 既然这是一个基于网络的简易版计算器，必然离不开网络相关接口，在编写 服务器 与 客户端 的逻辑之前，需要先将 socket 接口进行封装，方面后续的使用。

四 程序实现

4.1 封装socket相关操作

注：当前实现的程序是基于 TCP 协议的

   简单回顾下，服务器需要 创建套接字、绑定IP地址和端口号、进入监听连接状态、等待客户端连接，至于客户端需要 创建套接字、由操作系统绑定IP地址和端口号、连接服务器，等客户端成功连上服务器后，双方就可以正常进行网络通信了。

    为了让客户端和服务器都能使用同一个头文件，我们可以把客户端和服务器需要的所有操作都进行实现，各自调用即可。

Sock.hpp 套接字相关接口头文件

#pragma once

#include "Log.hpp"
#include "Err.hpp"

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

class Sock{

    const static int default_sock = -1;
    const static int default_backlog = 32;
public:
    Sock()
        :_sock(default_sock)
    {}

    // 创建套接字
    void Socket(){
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if(_sock == -1){
            logMessage(Fatal, "Creater Socket Fail! [%d]->%s", errno, strerror(errno));
            exit(SOCKET_ERR);
        }
        logMessage(Debug, "Creater Socket Success");
    }

    // 绑定IP与端口号
    void Bind(const 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(_sock, (struct sockaddr*)&local, sizeof(local)) == -1){
            logMessage(Fatal, "Bind Socket Fail! [%d]->%s", errno, strerror(errno));
            exit(BIND_ERR);
        }
        logMessage(Debug, "Bind Socket Success");
    }

    // 进入监听状态
    void Listen(){
        if(listen(_sock, default_backlog) == -1) {
            logMessage(Fatal, "Listen Socket Fail! [%d]->%s", errno, strerror(errno));
            exit(LISTEN_ERR);
        }
    }

    // 尝试处理连接请求
    int Accept(std::string* ip, uint16_t* port){
        struct sockaddr_in client;
        socklen_t len = sizeof(client);

        int retSock = accept(_sock, (struct sockaddr*)&client, &len)
;
        if(retSock < 0)
            logMessage(Warning, "Accept Fail! [%d]->%s", errno, strerror(errno));
        else{
            *ip = inet_ntoa(client.sin_addr);
            *port = ntohs(client.sin_port);
            logMessage(Debug, "Accept [%d -> %s:%d] Success", retSock, ip->c_str(), *port);
        }

        return retSock;
    }

    // 尝试进行连接
    int Connect(const std::string& ip, const uint16_t& port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));

        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        server.sin_addr.s_addr = inet_addr(ip.c_str());

        return connect(_sock, (struct sockaddr*)&server, sizeof(server));
    }

    // 获取sock
    int GetSock(){
        return _sock;
    }

    // 关闭sock
    void Close(){
        if(_sock != default_sock){
            close(_sock);
        }
        logMessage(Debug, "Close Sock Success");
    }

    ~Sock()
    {}
private:
    int _sock; // 既可以是监听套接字，也可以是连接成功后返回的套接字
};

Err.hpp 错误码头文件

#pragma once

enum{

    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR,
    CONNECT_ERR,
    FORK_ERR,
    SETSID_ERR,
    CHDIR_ERR,
    OPEN_ERR,
    READ_ERR,
    
};

Log.hpp 日志输出头文件 

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <cstdio>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdarg.h>

using namespace std;

enum{
    Debug = 0,
    Info,
    Warning,
    Error,
    Fatal
};

static const string file_name = "./tcp_log";

string getLevel(int level){

    vector<string> vs = {"<Debug>", "<Info>", "<Warning>", "<Error>", "<Fatal>", "<Unknown>"};
    
    //避免非法情况
    if(level < 0 || level >= vs.size() - 1){
        return vs[vs.size() - 1];
    }
    
    return vs[level];
}

string getTime(){

    time_t t = time(nullptr);   //获取时间戳
    struct tm *st = localtime(&t);    //获取时间相关的结构体

    char buff[128];
    snprintf(buff, sizeof(buff), "%d-%d-%d %d:%d:%d", st->tm_year + 1900, st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);

    return buff;
}

//处理信息
void logMessage(int level, const char* format, ...)
{
    //日志格式：<日志等级> [时间] [PID] {消息体}
    string logmsg = getLevel(level);    //获取日志等级
    logmsg += " " + getTime();  //获取时间
    logmsg += " [" + to_string(getpid()) + "]";    //获取进程PID

    //截获主体消息
    char msgbuff[1024];
    va_list p;
    va_start(p, format);    //将 p 定位至 format 的起始位置
    vsnprintf(msgbuff, sizeof(msgbuff), format, p); //自动根据格式进行读取
    va_end(p);

    logmsg += " {" + string(msgbuff) + "}";    //获取主体消息

    // 直接输出至屏幕上 方便进行测试
    cout << logmsg << endl;

    // //持久化。写入文件中
    // FILE* fp = fopen(file_name.c_str(), "a");   //以追加的方式写入
    // if(fp == nullptr) return;   //不太可能出错

    // fprintf(fp, "%s\n", logmsg.c_str());
    // fflush(fp); //手动刷新一下
    // fclose(fp);
    // fp = nullptr;
}

有了 Sock.hpp 头文件后，服务器/客户端就可以专注于逻辑编写了.

4.2 服务器

  首先准备好 TcpServer.hpp 头文件，其中实现了服务器初始化、服务器启动、序列化与反序列化等功能。

server.hpp 服务器头文件

#pragma once

#include "Sock.hpp"
#include <iostream>
#include <string>
#include <pthread.h>

namespace My_Server{

    class server;
    // 线程所需要的信息类
    class ThreadDate{
    public:

        ThreadDate(int& sock, std::string& ip, uint16_t& port, TcpServer* ptsvr)
            :_sock(sock)
            ,_ip(ip)
            ,_port(port)
            ,_ptsvr(ptsvr)
        {}

        ~ThreadDate()
        {}

        int _sock;
        std::string _ip;
        uint16_t _port;
        TcpServer* _ptsvr; // 回指指针
    };

    class server{
        const static uint16_t default_port = 8888;
    private:
        // 线程的执行函数
        static void* threadRoutine(void* args){

            // 线程剥离
            pthread_detach(pthread_self());

            ThreadDate* td = static_cast<ThreadDate*>(args);

            td->_ptsvr->ServiceIO(td->_sock, td->_ip, td->_port);
            delete td;
            return nullptr;
        }

        // 进行IO服务的函数
        void ServiceIO(const int& sock, const std::string ip, const uint16_t& port){
            // TODO
        }

    public:

        server(const uint16_t port = default_port)
            :_port(port)
        {}

        // 初始化服务器
        void Init(){
            _listen_sock.Socket();
            _listen_sock.Bind(_port);
            _listen_sock.Listen();
        }


        // 启动服务器
        void Start(){

            while(true){
                std::string ip;
                uint16_t port;

                int sock = _listen_sock.Accept(&ip, &port);
                if(sock == -1){
                   continue;
                }
                // 创建子线程，执行业务处理
                pthread_t tid;
                ThreadDate* td = new ThreadDate(sock, ip, port, this);
                pthread_create(&tid, nullptr, threadRoutine, td);
            }
        }

        ~server(){
            _listen_sock.Close();
        }

    private:
        Sock _listen_sock; // 监听套接字
        uint16_t _port;    // 服务器端口号
    };
}

server.cc 简易计算器服务器源文件

#include <iostream>
#include <memory>
#include "server.hpp"

using namespace std;

int main(){
    unique_ptr<My_Server::server> tsvr(new My_Server::server());

    tsvr->Init();
    tsvr->Start();

    return 0;
}

Makefile 自动编译脚本

.PHONY:all
all:server 
# //client

server:server.cc
	g++ -o $@ $^ -std=c++11 -lpthread

# client:client.cc
# 	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -rf server 
# client

编译并运行程序，同时查看网络使用情况:
 

netstat -nltp

此时就证明前面写的代码已经没有问题了，接下来是填充 ServiceIO() 函数

4.3 序列化和反序列化

ServiceIO() 函数需要做这几件事

  • 读取数据
  • 反序列化
  • 业务处理
  • 序列化
  • 发送数据

除了 序列化和反序列化 外，其他步骤之前都已经见过了，所以我们先来看看如何实现 序列化与反序列化。

ServiceIO() 函数 — 位于 server.hpp 头文件中的 server 类中

// 进行IO服务的函数
void ServiceIO(const int& sock, const std::string ip, const uint16_t& port){
    // 1.读取数据

    // 2.反序列化

    // 3.业务处理

    // 4.序列化

    // 5.发送数据
}

  需要明白我们当前的 协议 为 两正整数运算，分隔符为 （空格），客户端传给服务器两个操作数和一个运算符，服务器在计算完成后将结果返回，为了方便数据的读写，可以创建两个类：Request (客户端发送的一串待求的运算字符串）和 Response（服务器发送给客户端的结果），类中的成员需要遵循协议要求，并在其中支持 序列化与反序列化。

  但这两个函数，明显重复率有点高，我们的分隔符同样为一个空格，需要进行提取的，也都是数字，因此我们可以写个工具类，从而方便序列化和反序列化。

Util.hpp 工具类

#pragma once
#include <string>
#include <vector>

class Util{
public:

    //数字转化为字符串
    static std::string IntToStr(int val){
         // 特殊处理
        if(val == 0)
            return "0";
        
        std::string str;
        while(val){
            str += (val % 10) + '0';
            val /= 10;
        }

        int left = 0;
        int right = str.size() - 1;
        while(left < right){
             std::swap(str[left++], str[right--]);
        }
        return str;
    }
   

   //字符串转化为数字
    static int StrToInt(const std::string& str) {
        int ret = 0;
        for(auto e : str){
            ret = (ret * 10) + (e - '0');
        }
        return ret;
    }

    // 将给定的字符串用分隔符进行分割
    static void StringSplit(const std::string& str, const std::string& sep, std::vector<std::string>* result){
        size_t left = 0;
        size_t right = 0;
        while(right < str.size()){
            // 每次right都查找到下一个分隔符
            right = str.find(sep, left); 
            if(right == std::string::npos){
                  break;
            }
            //left到right之间即为要提取的数字
            result->push_back(str.substr(left, right - left));
            //left指向分割符下一个数字
            left = right + sep.size();
        }
        
        //会漏掉最后一个数字
        if(left < str.size()){
            result->push_back(str.substr(left));
        }
    }
};

  Protocol.hpp 协议处理相关头文件。

#pragma once
#include <string>
#include"Util.hpp"
#include<iostream>
namespace My_protocol{

// 协议的分隔符 这里我们自己设定为" "
const char* SEP= " ";
//分隔符长度
const int SEP_LEN = strlen(SEP);

//对运算进行序列和反序列化
class Request{
public:
    Request(int x = 0, int y = 0, char op = '+')
        : _x(x), _y(y), _op(op)
    {}

    // 序列化
    bool Serialization(std::string *outStr){
        *outStr = ""; // 清空

        std::string left = Util::IntToStr(_x);
        std::string right = Util::IntToStr(_y);
        *outStr = left + SEP + _op + SEP + right;

        return true;
    }

    // 反序列化
    bool Deserialization(const std::string &inStr){

        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::StrToInt(result[0]);
        _y = Util::StrToInt(result[2]);
        _op = result[1][0];

        return true;
    }

    ~Request()
    {}

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

   //业务处理函数
    class Response
   {
    public:
    Response(int result = 0, int code = 0)
        :_result(result), _code(code)
    {}

    // 序列化
    bool Serialization(std::string *outStr) {
        
        *outStr = ""; // 清空
        std::string left = Util::IntToStr(_result);
        std::string right = Util::IntToStr(_code);
        *outStr = left + SEP + right;

        return true;
    }

    // 提取结果和错误码
    bool Deserialization(const std::string &inStr){

        std::vector<std::string> result;
        Util::StringSplit(inStr, SEP, &result);

        if(result.size() != 2)
            return false;

        _result = Util::StrToInt(result[0]);
        _code = Util::StrToInt(result[1]);

        return true;
    }

    ~Response()
    {}

   public:
    int _result; // 结果
    int _code;   // 错误码
   };

}

4.4 业务的实际处理

  server 中的业务处理函数由 CalcServer.cc 传递，规定业务处理函数的类型为 void(Request&, Response*)

Calculate() 函数 — 位于server.cc

#include "server.hpp"
#include "Protocol.hpp"

#include <iostream>
#include <memory>
#include <functional>
#include <unordered_map>

using namespace std;

void Calculate(My_protocol::Request& req, My_protocol::Response* resp){

    // 这里只是简单的计算而已
    int x = req._x;
    int y = req._y;
    char op = req._op;
    unordered_map<char, function<int()>> hash = 
    {
        {'+', [&](){ return x + y; }},
        {'-', [&](){ return x - y; }},
        {'*', [&](){ return x * y; }},
        {'/', [&]()
            {
                if(y == 0)
                {
                    resp->_code = 1;
                    return 0;
                } 
                return x / y; 
            }
        },
        {'%', [&]()
            { 
                if(y == 0)
                {
                    resp->_code = 2;
                    return 0;
                }
                return x % y;
            }
        }
    };

    if(hash.count(op) == 0)
        resp->_code = 3;
    else
        resp->_result = hash[op]();
}

int main(){

    unique_ptr<My_Server::server> tsvr(new My_Server::server(Calculate));

    tsvr->Init();
    tsvr->Start();

    return 0;
}

既然 CalcServer 中传入了 Calculate() 函数对象，server 类中就得接收并使用，也就是业务处理.

server.hpp 头文件

#pragma once

#include "Sock.hpp"
#include <iostream>
#include <string>
#include <pthread.h>
#include "Protocol.hpp"
#include<functional>

namespace My_Server
{

    class server;
    // 线程所需要的信息类
    class ThreadDate
    {
    public:
        ThreadDate(int &sock, std::string &ip, uint16_t &port, server *ptsvr)
            : _sock(sock), _ip(ip), _port(port), _ptsvr(ptsvr)
        {
        }

        ~ThreadDate()
        {
        }

        int _sock;
        std::string _ip;
        uint16_t _port;
        server *_ptsvr; // 回指指针
    };
    
     using func_t = std::function<void(My_protocol::Request&, My_protocol::Response*)>;

    class server
    {
        const static uint16_t default_port = 8088;

    private:
        // 线程的执行函数
        static void *threadRoutine(void *args)
        {

            // 线程剥离
            pthread_detach(pthread_self());

            ThreadDate *td = static_cast<ThreadDate *>(args);

            td->_ptsvr->ServiceIO(td->_sock, td->_ip, td->_port);
            delete td;
            return nullptr;
        }

        // 进行IO服务的函数
        void ServiceIO(const int &sock, const std::string ip, const uint16_t &port){
            while (true){
                // 1.读取数据
                std::string package; // 假设这是已经读取到的数据包，格式为 "1 + 1"

                // 2.反序列化
                My_protocol::Request req;
                if (req.Deserialization(package) == false){
                    logMessage(Warning, "Deserialization fail!");
                    continue;
                }

                // 3.业务处理
                // TODO
                My_protocol::Response resp; // 业务处理完成后得到的响应对象
                _func(req, &resp);

                // 4.序列化
                std::string sendMsg;
                resp.Serialization(&sendMsg);
                std::cout<<sendMsg<<std::endl;
                // 5.发送数据
            }
        }

    public:
        server(func_t fun,const uint16_t port = default_port)
            : _port(port)
            ,_func(fun)
        {}

        // 初始化服务器
        void Init(){
            _listen_sock.Socket();
            _listen_sock.Bind(_port);
            _listen_sock.Listen();
        }

        // 启动服务器
        void Start(){

            while (true){
                std::string ip;
                uint16_t port;

                int sock = _listen_sock.Accept(&ip, &port);
                if (sock == -1)
                {
                    continue;
                }
                // 创建子线程，执行业务处理
                pthread_t tid;
                ThreadDate *td = new ThreadDate(sock, ip, port, this);
                pthread_create(&tid, nullptr, threadRoutine, td);
            }
        }

        ~server(){
            _listen_sock.Close();
        }

    private:
        Sock _listen_sock; // 监听套接字
        uint16_t _port;    // 服务器端口号
        func_t _func;      // 上层传入的业务处理函数

    };
}

  这就做好业务处理了，ServiceIO() 函数已经完成了 50% 的工作，接下来的重点是如何读取和发送数据？

  TCP 协议是面向字节流的，这也就意味着数据在传输过程中可能会因为网络问题，分为多次传输，这也就意味着我们可能无法将其一次性读取完毕，需要制定一个策略，来确保数据全部递达.

4.5 报头处理

如何确认自己已经读取完了所以数据？答案是提前知道目标数据的长度，边读取边判断

数据在发送时，是需要在前面添加 长度 这个信息的，通常将其称为 报头，而待读取的数据称为 有效载荷，报头 和 有效载荷 的关系类似于快递单与包裹的关系，前者是后者成功递达的保障

最简单的 报头 内容就是 有效载荷 的长度。

问题来了，如何区分 报头 与 有效载荷 呢？

  • 当前可以确定的是，我们的报头中只包含了长度这个信息
  • 可以通过添加特殊字符，如 \r\n 的方式进行区分
  • 后续无论有效载荷变成什么内容，都不影响我们通过报头进行读取

报头处理属于协议的一部分

所以在正式读写数据前，需要解决 报头 的问题（收到数据后移除报头，发送数据前添加报头）

ReadPackage() 读取函数 — 位于 Protocol.hpp 头文件

在 Protocol.hpp 中完成报头的添加和移除

#define HEAD_SEP "\r\n"
#define HEAD_SEP_LEN strlen(HEAD_SEP)

// 添加报头
void AddHeader(std::string& str){
    // 先计算出长度
    size_t len = str.size();
    std::string strLen = Util::IntToStr(len);

    // 再进行拼接
    str = strLen + HEAD_SEP + str;
}

// 移除报头
void RemoveHeader(std::string& str, size_t len){
    // len 表示有效载荷的长度
    str = str.substr(str.size() - len);
}

报头+有效载荷需要通过 read() 或者 recv() 函数从网络中读取，并且需要边读取边判断。

ReadPackage() 读取函数 — 位于 Protocol.hpp 头文件

#define BUFF_SIZE 1024
// 读取数据
int ReadPackage(int sock, std::string& inBuff, std::string* package){
   
    // 也可以使用 read 函数
    char buff[BUFF_SIZE];
    int n = recv(sock, buff, sizeof(buff) - 1, 0);
    if(n < 0)
        return -1; // 表示读取失败
    else if(n == 0)
        return 0; // 需要继续读取
    
    buff[n] = '\0';
    inBuff += buff;

    // 判断 inBuff 中是否存在完整的数据包（报头\r\n有效载荷）
    int pos = inBuff.find(HEAD_SEP);
    if(pos == std::string::npos)
        return -1;
    
    std::string strLen = inBuff.substr(0, pos); // 有效载荷的长度
    int packLen = strLen.size() + HEAD_SEP_LEN + Util::StrToInt(strLen); // 这是 报头+分隔符+有效载荷 的总长度
    if(inBuff.size() < packLen)
        return -1;
    
    *package = inBuff.substr(0, packLen); // 获取 报头+分隔符+有效载荷 ，也就是数据包
    inBuff.erase(0, packLen); // 从缓冲区中取走字符串
    return Util::StrToInt(strLen);
}

完整代码：
 

#pragma once
#include <string>
#include"Util.hpp"
#include<iostream>



namespace My_protocol{

#define HEAD_SEP "\r\n"
#define HEAD_SEP_LEN strlen(HEAD_SEP)

// 添加报头
void AddHeader(std::string& str){
    // 先计算出长度
    size_t len = str.size();
    std::string strLen = Util::IntToStr(len);

    // 再进行拼接
    str = strLen + HEAD_SEP + str;
}

// 移除报头
void RemoveHeader(std::string& str, size_t len){
    // len 表示有效载荷的长度
    str = str.substr(str.size() - len);
}

#define BUFF_SIZE 1024
// 读取数据
int ReadPackage(int sock, std::string& inBuff, std::string* package){
   
    // 也可以使用 read 函数
    char buff[BUFF_SIZE];
    int n = recv(sock, buff, sizeof(buff) - 1, 0);
    if(n < 0)
        return -1; // 表示读取失败
    else if(n == 0)
        return 0; // 需要继续读取
    
    buff[n] = '\0';
    inBuff += buff;

    // 判断 inBuff 中是否存在完整的数据包（报头\r\n有效载荷）
    int pos = inBuff.find(HEAD_SEP);
    if(pos == std::string::npos)
        return -1;
    
    std::string strLen = inBuff.substr(0, pos); // 有效载荷的长度
    int packLen = strLen.size() + HEAD_SEP_LEN + Util::StrToInt(strLen); // 这是 报头+分隔符+有效载荷 的总长度
    if(inBuff.size() < packLen)
        return -1;
    
    *package = inBuff.substr(0, packLen); // 获取 报头+分隔符+有效载荷 ，也就是数据包
    inBuff.erase(0, packLen); // 从缓冲区中取走字符串
    return Util::StrToInt(strLen);
}



// 协议的分隔符 这里我们自己设定为" "
const char* SEP= " ";
//分隔符长度
const int SEP_LEN = strlen(SEP);

//对运算进行序列和反序列化
class Request{
public:
    Request(int x = 0, int y = 0, char op = '+')
        : _x(x), _y(y), _op(op)
    {}

    // 序列化
    bool Serialization(std::string *outStr){
        *outStr = ""; // 清空

        std::string left = Util::IntToStr(_x);
        std::string right = Util::IntToStr(_y);
        *outStr = left + SEP + _op + SEP + right;

        return true;
    }

    // 反序列化
    bool Deserialization(const std::string &inStr){

        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::StrToInt(result[0]);
        _y = Util::StrToInt(result[2]);
        _op = result[1][0];

        return true;
    }

    ~Request()
    {}

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

   //业务处理函数
    class Response
   {
    public:
    Response(int result = 0, int code = 0)
        :_result(result), _code(code)
    {}

    // 序列化
    bool Serialization(std::string *outStr) {

        *outStr = ""; // 清空
        std::string left = Util::IntToStr(_result);
        std::string right = Util::IntToStr(_code);
        *outStr = left + SEP + right;

        return true;
    }

    // 提取结果和错误码
    bool Deserialization(const std::string &inStr){

        std::vector<std::string> result;
        Util::StringSplit(inStr, SEP, &result);

        if(result.size() != 2)
            return false;

        _result = Util::StrToInt(result[0]);
        _code = Util::StrToInt(result[1]);

        return true;
    }

    ~Response()
    {}

   public:
    int _result; // 结果
    int _code;   // 错误码
   };

}

此时对于 ServiceIO() 函数来说，核心函数都已经准备好了，只差拼装了。

ServiceIO() 函数 — 位于 server.hpp 头文件中的server 类中

 // 进行IO服务的函数
        void ServiceIO(const int &sock, const std::string ip, const uint16_t &port)
        {
            std::string inBuff;
            while (true)
            {
                // 1.读取数据
                std::string package; // 假设这是已经读取到的数据包，格式为 "5\r\n1 + 1"
                int len = My_protocol::ReadPackage(sock, inBuff, &package);
                if (len < 0)
                    break;
                else if (len == 0)
                    continue;

                // 2.移除报头
                My_protocol::RemoveHeader(package, len);

                // 3.反序列化
                My_protocol::Request req;
                if (req.Deserialization(package) == false)
                {
                    logMessage(Warning, "Deserialization fail!");
                    continue;
                }

                // 4.业务处理
                My_protocol::Response resp; // 业务处理完成后得到的响应对象
                _func(req, &resp);

                // 5.序列化
                std::string sendMsg;
                resp.Serialization(&sendMsg);
                cout << sendMsg << endl;

                // 6.添加报头
                My_protocol::AddHeader(sendMsg);

                // 7.发送数据
                send(sock, sendMsg.c_str(), sendMsg.size(), 0);
            }
        }

至此服务器编写完毕，接下来就是进行客户端的编写了.

4.5 客户端

Client.hpp 客户端头文件

#pragma once

#include "Sock.hpp"
#include "Protocol.hpp"
#include "Log.hpp"
#include "Err.hpp"

#include <iostream>
#include <string>
#include <unistd.h>

namespace My_Client
{
    class client
    {
    public:
        client(const std::string& ip, const uint16_t& port)
            :_server_ip(ip)
            ,_server_port(port)
        {}

        void Init()
        {
            _sock.Socket();
        }

        void Start()
        {
            int i = 5;
            while(i > 0)
            {
                if(_sock.Connect(_server_ip, _server_port) != -1)
                    break;
                
                logMessage(Warning, "Connect Server Fail! %d", i--);
                sleep(1);
            }

            if(i == 0)
            {
                logMessage(Fatal, "Connect Server Fail!");
                exit(CONNECT_ERR);
            }

            // 执行读写函数
            ServiceIO();
        }

        void ServiceIO()
        {
            while(true)
            {
                std::string str;
                std::cout << "Please Enter:> ";
                std::getline(std::cin, str);

                // 1.判断是否需要退出
                if(str == "quit")
                    break;

                // 2.分割输入的字符串
                My_protocol::Request req;
                [&]()
                {
                    std::string ops = "+-*/%";
                    int pos = 0;
                    for(auto e : ops)
                    {
                        pos = str.find(e);
                        if(pos != std::string::npos)
                            break;
                    }

                    req._x = Util::StrToInt(str.substr(0, pos));
                    req._y = Util::StrToInt(str.substr(pos + 1));
                    req._op = str[pos];
                }();

                // 3.序列化
                std::string sendMsg;
                req.Serialization(&sendMsg);

                // 4.添加报头
                My_protocol::AddHeader(sendMsg);

                // 5.发送数据
                send(_sock.GetSock(), sendMsg.c_str(), sendMsg.size(), 0);

                // 6.获取数据
                std::string inBuff;
                std::string package;
                int len = 0;
                while(true)
                {
                    len = My_protocol::ReadPackage(_sock.GetSock(), inBuff, &package);
                    if(len < 0)
                        exit(READ_ERR);
                    else if(len > 0)
                        break;
                }

                // 7.移除报头
                My_protocol::RemoveHeader(package, len);

                // 8.反序列化
                My_protocol::Response resp;
                if(resp.Deserialization(package) == false)
                {
                    logMessage(Warning, "Deserialization fail!");
                    continue;
                }
                
                // 9.获取结果
                std::cout << "The Result: " << resp._result << " " << resp._code << endl;
            }
        }

        ~client()
        {
            _sock.Close();
        }

    private:
        Sock _sock;
        std::string _server_ip;
        uint16_t _server_port;
    };
}

client.cc 客户端源文件

#include "client.hpp"

#include <iostream>
#include <memory>

using namespace std;

int main()
{
    unique_ptr<My_Client::client> tclt(new My_Client::client("127.0.0.1", 8088));

    tclt->Init();
    tclt->Start();
    
    return 0;
}

五 测试

六 使用库

事实上，序列化与反序列化 这种工作轮不到我们来做，因为有更好更强的库，比如 Json、XML、Protobuf 等

比如我们就可以使用 Json 来修改程序

首先需要安装 json-cpp 库，如果是 CentOS7 操作系统的可以直接使用下面这条命令安装

yum install -y jsoncpp-devel

安装完成后，可以引入头文件 <jsoncpp/json/json.h>

然后就可以在 Protocol.hpp 头文件中进行修改了，如果想保留原来自己实现的 序列化与反序列化 代码，可以利用 条件编译 进行区分

Protocol.hpp 协议相关头文件

#pragma once
#include "Util.hpp"

#include <jsoncpp/json/json.h>
#include <string>
#include <vector>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>

namespace My_protocol
{
// 协议的分隔符
#define SEP " "
#define SEP_LEN strlen(SEP)
#define HEAD_SEP "\r\n"
#define HEAD_SEP_LEN strlen(HEAD_SEP)
#define BUFF_SIZE 1024
// #define USER 1

    // 添加报头
    void AddHeader(std::string& str)
    {
        // 先计算出长度
        size_t len = str.size();
        std::string strLen = Util::IntToStr(len);

        // 再进行拼接
        str = strLen + HEAD_SEP + str;
    }

    // 移除报头
    void RemoveHeader(std::string& str, size_t len)
    {
        // len 表示有效载荷的长度
        str = str.substr(str.size() - len);
    }

    // 读取数据
    int ReadPackage(int sock, std::string& inBuff, std::string* package)
    {
        // 也可以使用 read 函数
        char buff[BUFF_SIZE];
        int n = recv(sock, buff, sizeof(buff) - 1, 0);
        if(n < 0)
            return -1; // 表示什么都没有读到
        else if(n == 0)
            return 0; // 需要继续读取
        
        buff[n] = 0;
        inBuff += buff;

        // 判断 inBuff 中是否存在完整的数据包（报头\r\n有效载荷）
        int pos = inBuff.find(HEAD_SEP);
        if(pos == std::string::npos)
            return 0;
        
        std::string strLen = inBuff.substr(0, pos); // 有效载荷的长度
        int packLen = strLen.size() + HEAD_SEP_LEN + Util::StrToInt(strLen); // 这是 报头+分隔符+有效载荷 的总长度
        if(inBuff.size() < packLen)
            return 0;
        
        *package = inBuff.substr(0, packLen); // 获取 报头+分隔符+有效载荷 ，也就是数据包
        inBuff.erase(0, packLen); // 从缓冲区中取走字符串
        return Util::StrToInt(strLen);
    }

    class Request
    {
    public:
        Request(int x = 0, int y = 0, char op = '+')
            : _x(x), _y(y), _op(op)
        {}

        // 序列化
        bool Serialization(std::string *outStr)
        {
            *outStr = ""; // 清空
#ifdef USER
            std::string left = Util::IntToStr(_x);
            std::string right = Util::IntToStr(_y);
            *outStr = left + SEP + _op + SEP + right;
#else
            // 使用 Json
            Json::Value root;
            root["x"] = _x;
            root["op"] = _op;
            root["y"] = _y;

            Json::FastWriter writer;
            *outStr = writer.write(root);
#endif
            std::cout << "序列化完成: " << *outStr << std::endl << std::endl;
            return true;
        }

        // 反序列化
        bool Deserialization(const std::string &inStr)
        {
#ifdef USER
            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::StrToInt(result[0]);
            _y = Util::StrToInt(result[2]);
            _op = result[1][0];
#else
            // 使用Json
            Json::Value root;
            Json::Reader reader;
            reader.parse(inStr, root);

            _x = root["x"].asInt();
            _op = root["op"].asInt();
            _y = root["y"].asInt();
#endif
            return true;
        }

        ~Request()
        {}

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

    class Response
    {
    public:
        Response(int result = 0, int code = 0)
            :_result(result), _code(code)
        {}

        // 序列化
        bool Serialization(std::string *outStr)
        {
            *outStr = ""; // 清空
#ifdef USER
            std::string left = Util::IntToStr(_result);
            std::string right = Util::IntToStr(_code);
            *outStr = left + SEP + right;
#else
            // 使用 Json
            Json::Value root;
            root["_result"] = _result;
            root["_code"] = _code;

            Json::FastWriter writer;
            *outStr = writer.write(root);
#endif
            std::cout << "序列化完成: " << *outStr << std::endl << std::endl;
            return true;
        }

        // 反序列化
        bool Deserialization(const std::string &inStr)
        {
#ifdef USER
            std::vector<std::string> result;
            Util::StringSplit(inStr, SEP, &result);

            if(result.size() != 2)
                return false;

            _result = Util::StrToInt(result[0]);
            _code = Util::StrToInt(result[1]);
#else
            // 使用Json
            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;   // 错误码
    };
}

注意： 因为现在使用了 Json 库，所以编译代码时需要指明其动态库

.PHONY:all
all:server client

server:server.cc
	g++ -o $@ $^ -std=c++11 -lpthread -ljsoncpp

client:client.cc
	g++ -o $@ $^ -std=c++11 -ljsoncpp

.PHONY:clean
clean:
	rm -rf server  client

使用了 Json 库之后，序列化 后的数据会更加直观，当然也更易于使用

云烟梦柳
关注
  • 29
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树的序列化和反序列化——C++
净无邪博客
12-15 2521
总体解题思想为先用层次遍历存储包括空节点的每个节点，存储是每个节点都存储左右子节点，如果节点为空，则存储"#,"，否则存储节点的值val，同时用逗号','分割每个节点内容，存储完后进行序列化string。反序列化则先按逗号','分割每个字符串为数组字符串vector<string> valStrArr，该valStrArr存储每个节点的值，包括空节点；然后遍历valStrArr，反向构建原始二叉树。反向构建二叉树时由于存储是按层次遍历存入的，所以反向遍历时也需要按照层次遍历依次将非空节点压栈和弹出栈。由于层
Json序列化和反序列化方法解析
10-26
**实体类（DataContract与DataMember）** 在JSON序列化和反序列化中，为了指定哪些属性应该被序列化或反序列化，通常会使用`[DataContract]`和`[DataMember]`特性。在示例中，定义了一个名为`TestObj`的实体类，包含...
[计算机网络]---序列化和反序列化
分享技术
02-16 1982
重点理解序化和反序列化
一文彻底搞懂序列化和反序列化
Circ
07-23 2332
Redis（Remote Dictionary Server）是一种开源的高性能键值存储数据库，它也被称为数据结构服务器，因为它支持多种灵活的数据结构。Redis以内存中的数据结构为基础，提供了快速、高效的数据存储和访问能力。它可以用作数据库、缓存、消息代理和排行榜等多种用途。Redis将数据存储为键值对，其中键是唯一的标识符，而值可以是字符串、哈希、列表、集合、有序集合等各种数据结构。（因为我们是面向对象开发，所有就要使用内存数据库啦，因为要把对象存取来哦）
【计算机网络】序列化与反序列化
qq_62939852的博客
08-29 2622
在命名空间Protocol_n中，定义两个类，分别为Request类和Reponse类若读到 字符串风格的Request ，就需要通过序列化 转成 结构化的数据自己定义 将结构化的数据 转化为 字符串假设空格作为分割符使用to_string 将任意类型转化为string使用 宏， 将SEP表示为空格将_x _y _op 使用空格连接起来提供一个函数StringSplit ，去掉字符串中的空格，分别填入vector数组中,作为vetcor数组中的元素。
JSON 序列化和反序列化 讲解
天马3798
12-05 7141
一、什么是JSON 数据 JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于ECMAScript(欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。 是JavaScript用来处理数据的一种格式，大部分是用来处理JavaScript和web服务器端之间的数...
Go_Json的序列化和反序列化
itzhuzhu的博客
02-21 2163
序列化用json.Marshal() 反序列化用json.Unmarshal()，反序列化时要和序列化前的数据类型保持一致
Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解释
热门推荐
请叫我大师兄
11-28 12万+
遇到这个 Java Serializable 序列化这个接口，我们可能会有如下的问题a，什么叫序列化和反序列化 b，作用。为啥要实现这个 Serializable 接口，也就是为啥要序列化 c，serialVersionUID 这个的值到底是在怎么设置的，有什么用。有的是1L，有的是一长串数字，迷惑ing。 我刚刚见到这个关键字 Serializable 的时候，就有如上的这么些问题。 在处理这个...
Hadoop序列化与反序列化详解
王傲旗的大数据之路
11-11 5412
1.什么是序列化? 序列化就是把内存中的对象,转换成字节序列(或其他数据传输协议)以便于存储到磁盘(持久化)和网络传输 反序列化就是将收到字节序列(或其他数据传输协议) 或者是磁盘的持久化数据,转换成内存中的对象 2.为什么要序列化? 一般来说,"活的"对象只能在内存中生存,关机断电就没有了,而且"活的"对象只能由本地的进程使用,不能被发送到网络上的另外一台计算机,然而序列化可以存储"活的"...
RPC之对象序列化/反序列化
sunny_sailor的专栏
04-14 2249
从传统的单体服务到现在的分布式服务，微服务截然已经成为主流。RPC作为微服务最重要的核心模块之一，也越来越受到关注。市场主流的rpc有dubbo、spring cloud、thrift、grpc、brpc等。 那RPC的通信传输数据方式是什么样子呢？我们通过下面一张图来看下 服务调用方（consumer）将数据序列化打包通过网络模块传给服务提供方（provider）。provider...
Python实现的序列化和反序列化二叉树算法示例
09-19
在计算机科学中，序列化和反序列化是两种重要的数据处理技术，特别是在处理复杂的数据结构如二叉树时。在Python中，序列化是将对象转换为可存储或可传输的格式，而反序列化则是将这种格式还原为原来的对象。在本示例...
【leetcode-树】二叉树的序列化与反序列化
12-21
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现...
计算机研究 -时间序列形式的基因芯片数据的聚类分析.pdf
07-02
通过与标记的核酸序列杂交，基因芯片可以揭示基因表达的差异，为生物学和医学研究提供大量信息。 基因芯片数据处理的核心在于分析大量基因表达数据，这些数据通常以数值矩阵的形式表示，矩阵的行代表基因，列代表...
计算机网络-教学课件-6PPT文档.pptx
11-19
TCP是面向连接的、可靠的传输协议，它通过建立连接、序列化数据、确认应答、重传丢失数据以及流量控制来确保数据的完整性和顺序。TCP使用滑动窗口机制来控制发送方的发送速率，避免网络拥塞。此外，TCP还通过超时重...
离线使用端口扫描工具Nmap和Netcat
最新发布
生活不只是眼前的苟且,还有诗和远方!
06-21 836
这个扫描是针对本地计算机的 localhost 地址进行的，即本机回环地址。localhost 是一个特殊的网络地址，指向本机的 IP 地址（通常是 127.0.0.1）。这个扫描是针对网络中的一台具体主机（IP地址为 10.16.36.204）进行的。Nmap（Network Mapper）是一个强大的网络扫描和安全审计工具，它支持多种扫描技术和方法。所以，这次扫描是在本机上执行的，它展示了本机上所有运行的服务和开放的端。# 扫描报告，显示扫描的目标是本地主机（127.0.0.1）
不出网上线CS的各种姿势（内网横向）
qq_64395221的博客
06-21 926
在内网环境中可以使用ipc $生成的SMB Beacon上传到目标主机执行，但是目标主机并不会直接上线的，需要我们自己用链接命令(link <ip>)去连接它。经常是拿下一台边缘机器，其有多块网卡，用于连接内外网，内网机器都不出网。因为连接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB Beacon相对隐蔽，绕防火墙时可能发挥奇效。一样，建立pystinger连接之后，直接生成payload在业务主机执行，业务内网主机192.168.111.236即可成功上线。
Java——包
Stewie Lee的博客
06-21 840
包是Java命名空间机制的一部分，用于将相关的类、接口和子包进行分组，以避免命名冲突和提高代码的可维护性，以及控制类、接口等的访问范围。在一个Java源文件的开头使用package关键字来声明它所属的包。
网络编程1
bonfirelit的博客
06-21 296
服务器接收到 FIN 包后，会向客户端发送一个 ACK（Acknowledgment）包，确认已经接收到 FIN。客户端接收到服务器的 FIN 包后，向服务器发送一个 ACK 包，确认已经接收到 FIN。网络编程中，客户端调用close或者shutdown后，操作系统会给服务器发送一个FIN。操作系统会发送一个 FIN 包给服务器，表示客户端不会再发送数据。服务器进入半关闭状态，可以继续向客户端发送数据，但不能再接收数据。当双方都发送并接收到 FIN 和 ACK 包后，连接才完全关闭。
序列化与反序列化作用
07-29
序列化和反序列化是在计算机科学中常用的概念，用于将对象或数据结构转换为可传输或存储的格式，以及从这些格式恢复为原始对象或数据结构。 序列化的作用是将对象或数据结构转换为字节流或其他可传输的格式，以便在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值