Linux中的自定义协议+序列反序列化用法

2025-08-06 09:50
文章标签 序列化 自定义 linux 用法 序列 协议

本文主要是介绍Linux中的自定义协议+序列反序列化用法，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Linux中的自定义协议+序列反序列化用法》文章探讨网络程序在应用层的实现,涉及TCP协议的数据传输机制、结构化数据的序列化与反序列化方法,以及通过JSON和自定义协议构建网络计算器的思路,强调分层...

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

一，再次理解协议

思考1: 我们究竟是如何将数据发送出去的？

（1）我们都知道TCP是双加工的，所以在内核中存在着发送缓冲区和接受缓冲区，而我们write是写入发送缓冲区的，read是从接受缓冲区里读的，所以我们会发现这两个函数其实就是拷贝函数！！write将数据从用户层拷贝到内核层就返回，read将数据从内核层拷贝到用户层就返回，意思就是我用户不管，反正我把数据都交给你OS了，发送过程中的可靠性由你来维护。（就像当年我们只需要将内容写到文件内核缓冲区，而由OS来决定什么时候，以什么方式刷新到磁盘上）

（2）所以TCP协议是属于操作系统的网络模块部分，他之所以叫做传输控制协议，就是因为他需要确保数据传输过程中的可靠性，比方说我什么时候应该发给对方？要发多少？万一出错了怎么办？

思考2：回忆管道和文件系统

（1）以往我们往管道文件里写了很多次的时候，可能我们一次就全部读上来了

（2）而在文件系统中，我们的写很容易，可以分很多次写，各种类型比如整数/字符串…… 但是读的时候就很难去读，同时不同的文件的读取方式可能也不一样，比如按行读也仅仅只是读取文件的一种方式而已。

思考3：TCP是面向字节流的，你怎么保证你读上来的数据一定是一个"完整的报文"呢？

(1)早期的时候我们可能会想到比方说我们约定必须要凑齐多少字节才往上读，但是这个其实只适用于一些固定类型的报文，比方说我们规定读的是int，而int对应的就是一个错误码或者是某一个固定的任务。但是如果是一些长度不固定的报文，比如说我们在聊天的时候发送的字符串长度都是不一样的，那么这个时候就很容易读到不完整的报文

（2）所以为了应对这种情况，我们就需要在报文直接加入一下分割符，或者是标识这个报文有多长，以确保能够读到完整的报文， 而协议要添加报头就会有很多新得问题出来-比如序列化和反序列化。

二，序列化和反序列化

问题1：协议是一种 "约定". socket api的接口， 在读写数据时， 都是按 "字符串" 的方式来发送接收的. 如果我们要传输一些"结构化的数据" 怎么办呢?

（1）同一个结构体在不同的编译器下编译的大小不一定一样（结构体的内存对齐），其实linux的协议就是传结构体做到的，但是他底层可以把所有方方面面的情况都考虑到了，但是我们用户去定的时候很难考虑得这么周全。

（2） 可以如果不用结构体的话，我们如果用字符串呢？举个例子，我们聊天的时候我发了一句哈哈，但是发送的时候还会带上昵称以及发送时间，所以我们肯定不能把这三个字符串分开发，因为这也服务端就不知道你这话是谁说的，所以我肯定希望把三个字符串打包成一个字符串发过去，然后服务的把消息广播给所有客户端的时候，会再把这个包根据一定的方法解析分成三个字符串然后再给你显现出来！------------->也就是说我们需要在类里面定义两种方法，一种是把类内的数据打包成一个字符串发送过去，另一种是解析的时候将这个字符串再拆分出来。 而这个过程就是序列化和反序列化

问题2 ：我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去， 然后由服务器进行计算， 最 后再把结果返回给客户端.

约定方案一:

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

约定方案二:

定义结构体来表示我们需要交互的信息;

发送数据时将这个结构体按照一个规则转换成字符串， 接收到数据的时候再按照相同的规则把字符串转 化回结构体; 这个过程叫做 "序列化" 和”反序列化“

三，实现网络计算器

3.1 日志文件

#pragma once

#include <IOStream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define SIZE 1024

#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define Onefile 2
#define Classfile 3

#define LogFile "log.txt"
class Log
{
public:
    Log()
    {
        printMethod = Screen;
        path = "./log/";
    }
    void Enable(int method)
    {
        printMethod = method;
    }
    std::string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }

    // void logmessage(int level， const char *format， ...)
    // {
    //     time_t t = time(nullptr);
    //     struct tm *ctime = localtime(&t);
    //     char leftbuffer[SIZE];
    //     snprintf(leftbuffer， sizeof(leftbuffer)， "[%s][%d-%d-%d %d:%d:%d]"， levelToString(level).c_str()，
    //              ctime->tm_year + 1900， ctime->tm_mon + 1， ctime->tm_mday，
    //              ctime->tm_hour， ctime->tm_min， ctime->tm_sec);

    //     // va_list s;
    //     // va_start(s， format);
    //     char rightbuffer[SIZE];
    //     vsnprintf(rightbuffer， sizeof(rightbuffer)， format， s);
    //     // va_end(s);

    //     // 格式：默认部分+自定义部分
    //     char logtxt[SIZE * 2];
    //     snprintf(logtxt， sizeof(logtxt)， "%s %s\n"， leftbuffer， rightbuffer);

    //     // printf("%s"， logtxt); // 暂时打印
    //     printLog(level， logtxt);
    // }
    void printLog(int level， const std::string &logtxt)
    {
        switch (printMethod)
        {
        case Screen:
            std::cout << logtxt << stdjavascript::endl;
            break;
        case Onefile:
            printOneFile(LogFile， logtxt);
            break;
        case Classfile:
            printClassFile(level， logtxt);
            break;
        default:
            break;
        }
    }
    void printOneFile(const std::string &logname， const std::string &logtxt)
    {
        std::string _logname = path + logname;
        int fd = open(_logname.c_str()， O_WRONLY | O_CREAT | O_APPEND， 0666); // "log.txt"
        if (fd < 0)
            return;
        write(fd， logtxt.c_str()， logtxt.size());
        close(fd);
    }
    void printClassFile(int level， const std::string &logtxt)js
    {
        std::string filename = LogFile;
        filename += ".";
        filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
        printOneFile(filename， logtxt);
    }

    ~Log()
    {
    }
    void operator()(int level， const char *format， ...)
    {
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer， sizeof(leftbuffer)， "[%s][%d-%d-%d %d:%d:%d]"， levelToString(level).c_str()，
                 ctime->tm_year + 1900， ctime->tm_mon + 1， ctime->tm_mday，
                 ctime->tm_hour， ctime->tm_min， ctime->tm_sec);

        va_list s;
        va_start(s， format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer， sizeof(rightbuffer)， format， s);
        va_end(s);

        // 格式：默认部分+自定义部分
        char logtxt[SIZE * 2];
        snprintf(logtxt， sizeof(logtxt)， "%s %s"， leftbuffer， rightbuffer);

        // printf("%s"， logtxt); // 暂时打印
        printLog(level， logtxt);
    }

private:
    int printMethod;
    std::string path;
};

// int sum(int n， ...)
// {
//     va_list s; // char*
//     va_start(s， n);

//     int sum = 0;
//     while(n)
//     {
//         sum += va_arg(s， int); // printf("hello %d， hello %s， hello %c， hello %d，"， 1， "hello"， 'c'， 123);
//         n--;
//     }

//     va_end(s); //s = NULL
//     return sum;
// }
Log lg; // 命令对象 用来打印日志信息

3.2Socket.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 <string.h>
#include "Log.hpp"

enum {
    SocketError = 1，
    BindError =2，
    ListenError = 3，
    AcceptError = 4
};
const int defaultbacklog = 10;//监听队列默认长度
class Sock
{
public:
    Sock(){}
    ~Sock(){}
    void Socket()//创建套接字
    {
        _sockfd = socket(AF_INET， SOCK_STREAM， 0);
        if (_sockfd<0)
        {
            lg(Fatal，"socket error，%s:%d"，strerror(errno)，errno);
            exit(SocketError);
        }
    }
    void Bind(uint16_t port)//绑定套接字
    {
        struct sockaddr_in addr;
        bzero(&addr， sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;
        if(bind(_sockfd， (struct sockaddr*)&addr， sizeof(addr))<0)
        {
            lg(Fatal，"bind error，%s:%d"，strerror(errno)，errno);
            exit(BindError);
        }
    }
    void Listen(int backlog=defaultbacklog)//监听套接字
    {
        if(listen(_sockfd， backlog)<0)
        {
            lg(Fatal，"listen error，%s:%d"，strerror(errno)，errno);
            exit(ListenError);
        }
    }

    int Accept(std::string *clientip，uint16_t *clientport)//接受套接字并把客户端的ip和端口返回（输出型参数）
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int connfd = accept(_sockfd， (struct sockaddr*)&client， &len);
        if(connfd<0)
        {
            lg(Error，"accept error，%s:%d"，strerror(errno)，errno);//如果接受失败 打印错误信息并退出程序
            exit(AcceptError);
        }
         char ipstr[64];
        inet_ntop(AF_INET， &client.sin_addr，ipstr， sizeof(ipstr));
        *clientip = ipstr;
        *clientport = ntohs(client.sin_port);
        lg(Info，"accept a client %s:%d"，*clientip，*clientport);//表示接受成功了并打印客户端的ip和端口
        return connfd;
    }
    int GetSockfd()//获取套接字
    {
        return _sockfd;
    }
    void Close()//关闭套接字
    {
        close(_sockfd);
    }
    bool Connect(const std::string &ip，const uint16_t &port)//连接套接字
    {
        struct sockaddr_in addr;
        bzero(&addr， sizeof(struct sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        inet_pton(AF_INET， ip.c_str()， &addr.sin_addr) ;//将ip地址转换为网络字节序
        if(connect(_sockfd， (struct sockaddr*)&addr， sizeof(addr))<0)
        {
            lg(Warning，"connect error，%s:%d"，strerror(errno)，errno);
            return false;
        }
        return true;
    }

private:
    int _sockfd;
};

3.3 TcpServer.hpp

#pragma once
#include <functional>
#include <signal.h>
#include "Socket.hpp"

using func_t = std::function<std::string(std::string &package)>; // 回调函数

class TcpServer
{
public:
    TcpServer(uint16_t port， func_t callback) : _port(port)， _callback(callback)， _isrunning(false)
    {
    }
    ~TcpServer() {}

    void InitServer()
    {
        _listensock.Socket();
        _listensock.Bind(_port);
        _listensock.Listen(10);
        lg(Info， "Server is running on port %d"， _port); // 看看服务器在哪个端口上运行
    }
    void Start() // 启动服务器
    {
        _isrunning = true;
        signal(SIGCHLD， SIG_IGN); // 忽略子进程结束信号 因为子进程结束时会产生SIGCHLD信号
        signal(SIGPIPE， SIG_IGN); // 忽略管道错误信号 因为当网络连接中某个套接字被关闭或者重启时，该套接字已经发送缓冲区中的数据都发送完毕了，但是它仍然可以接收数据 此时该套接字就会产生SIGPIPE信号
        while (_isrunning)
        {
            std::string clientip;
            uint16_t clientport;
            int sockfd = _listensock.Accept(&clientip， &clientport); // 接受客户端连接并返回套接字描述符
            if (sockfd < 0)
                continue;       // 连接失败就继续尝试重连
            pid_t pid = fork(); // 创建子进程 帮助我们处理每个客户端的请求
            if (pid < 0)        // 出错
            {
                lg(Error， "Fork error");
                continue;
            }
            if (pid == 0) // 子进程
            {
                _listensock.Close();          // 关闭监听套接字 防止accept阻塞
                std::string inbuffer_stream; // 用来获取客户端发来的所有数据
                while (true)
                {
                    char buffer[1024];
                    ssize_t n = read(sockfd， buffer， sizeof(buffer)); // 读取客户端数据
                    if (n == 0)                                       // 客户vzxsbImgG端断开了
                    {
                        lg(Info， "Client %s:%d disconnected"， clientip.c_str()， clientport);
                        break;
                    }
                    if (n < 0) // 读取出错
                    {
                        lg(Error， "Read error");
                        break;
                    }
                    // 拼接所有数据
                    buffer[n]=0;
                    inbuffer_stream+=buffer;
                    lg(Debug， "debug:\n%s"， inbuffer_stream.c_str());// 调试看看整个流的信息
                    //有可能一个流里面有多个报文，所以我们要循环去处理
                    while(1)
                    {
                        std::string info =_callback(inbuffer_stream);// 调用回调函数获取服务端需要的数据
                        //看看剩余的报文信息
                        if(info.empty()) break;//说明读不到完整报文了
                        lg(Debug， "debug:\n%s"， inbuffer_stream.c_str());// 调试看看整个流的信息
                        lg(Debug， "debug，response:\n%s"，info.c_str());// 调试看看发给客户端数据
                        write(sockfd， info.c_str()， info.size()); // 发送数据给客户端
                    }
                }
                exit(0); // 子进程结束
            }
            close(sockfd); // 关闭套接字
        }
    }

private:
    uint16_t _port;   // 端口号
    Sock _listensock; // 监听套接字
    func_t _callback; // 回调函数 用来提供服务
    // ip模式是0
    bool _isrunning; // 是否运行
};

1、tcpserver只负责网络通信读到了那些数据，但是关于数据的解析 全部交给callback回调函数去处理这样就是将网络通信和协议解析进行了解耦

2、因为我们并不确定读到的是否是一个完整报文，所以我们要将读到的内容加到inbuffer-stream里

3.4 Protocol.hpp

协议其实就是我们双方约定好的结构化字段

Linux中的自定义协议+序列反序列化用法Linux中的自定义协议+序列反序列化用法

为了确保读到完整的报文，在前面加个有关报文长度的字段是是一种方案，在报文的后面加个分割符\其实也是一个方案

甚至我们可以在前面增加protocol select字段，表示我们选择的不同的协议类型！

  • "len"/n"x op y"/n就是我们约定request的协议，里面要提供序列化和反序列化的方法
  • ”len“/n"result code"/n 就是我们约定的respose的协议里面要提供序列化和反序列化的方法
#pragma once

#include <iostream>
#include <string>

// #define MySelf 1

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)
{
    std::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);
    // package = len_str + content_str + 2
    std::size_t total_len = len_str.size() + len + 2;
    if(package.size() < total_len) return false;

    *content = package.substr(pos+1， len);
    // earse 移除报文 package.erase(0， total_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)
    {
        // 构建报文的有效载荷
        // 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 = inphp.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 + 1);

        if (left + 2 != right)
            return false;
        _op = in[left + 1];
        _x = std::stoi(part_x);
        _y = std::stoi(part_y);
        return true;
    }
    void DebugPrint()
    {
        std::cout << "新请求构建完成:  " << _x << _op << _y << "=?" << std::endl;
    }
public:
    // x op y
    int _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) // "result code"
    {
        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具体是几，表明对应的错误原因
};

不仅需要有序列化和反序列化的方法，还要有添加报头和解析报头（要有很多检查 将一个有效的报文提取出来）的方法

3.5 Servercal.hpp

// 计算器服务

#include <iostream>
#include "Protocol.hpp" //协议头文件 必须遵守

enum
{
    Div_Zero = 1，
    Mod_Zero = 2，
    Other_Oper = 3
};


class ServerCal
{
public:
    ServerCal() {}
    ~ServerCal() {}

Response Calhelper(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._code = Div_Zero;
       else resp._result = req._x / req._y;
       break;
   case '%':
       if (req._y == 0) resp._code = Mod_Zero;
       else resp._result = req._x % req._y;
       break;
   default:
       resp._code=Other_Oper;
       break;
   }
 return resp;
}

//设计一个回调方法 来帮助我们计算
std::string Cal(std::string package) //回调方法  到时传过去
{
    std::string content;//返回的内容
    bool r=Decode(package，&content);
    if(!r)  return "";//报文不完整
    //我们要将这个报文反序列化拿到数据 然后计算成respond 然后再序列化发给客户端
    Request req;
    r=req.Deserialize(content); //"10 + 20 " ->
    if(!r) return ""; //解析失败
    content=""; //清空再利用
    Response resp=Calhelper(req);
    resp.Serialize(&content);
    content=Encode(content);//把报头加上去
    return content;
}

};

在这里写一个回调方法，如果解析失败的话就返回空串

3.6 ServerCal.cc

#include"ServerCal.hpp"
#include"TcpServer.hpp"

static void Usage(const std::string &proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl; 
}

int main(int argc， char *argv[])//./servercal 8080
{
   if(argc != 2)
   {
       Usage(argv[0]);
       exit(0);
   }
   uint16_t port = atoi(argv[1]);
   ServerCal cal;//用来做计算请求的对象
   TcpServer *tsvp = new TcpServer(port，std::bind(&ServerCal::Cal， &cal， std::placeholders::_1));//bind
   tsvp->InitServer();
 // Daemon();
    daemon(0， 0);
   tsvp->Start();

   
   return 0;
}

3.7ClientCal.cc

#include <iostream>
#include <string>
#include <ctime>
#include <cassert>
#include <unistd.h>
#include "Socket.hpp"
#include "Protocol.hpp" //客户端也得知道协议

static void Usage(const std::string &proc)
{
    std::cout << "\nUsage: " << proc << " serverip serverport\n"
              << std::endl;
}

//./client 127.0.0.1 8080
int main(int argc， char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        return -1;
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    Sock sockfd;
    sockfd.Socket();
    bool r=sockfd.Connect(serverip， serverport);//尝试和服务端连接
    if(!r)
    {
        std::cout<<"连接失败"<<std::endl;
        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(1234);
        int y = rand() % 100;
        usleep(4321);
        char oper = opers[rand()%opers.size()];
        Request req(x， y， oper);
        req.DebugPrint();

        std::string package;
        req.Serialize(&package);

        package = Encode(package);

        write(sockfd.GetSockfd()， package.c_str()， package.size());
        // std::cout << "这是最新的发出去的请求: " << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "这是最新的发出去的请求: \n" << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "这是最新的发出去的请求: \n" << n << "\n" << package;
        // n = write(sockfd.Fd()， package.c_str()， package.size());
        // std::cout << "这是最新的发出去的请求: \n" << n << "\n" << package;


        char buffer[128];
        ssize_t n = read(sockfd.GetSockfd()， buffer， sizeof(buffer)); // 我们也无法保证我们能读到一个完整的报文
        if(n > 0)
        {
            buffer[n] = 0;
            inbuffer_stream += buffer; // "len"\n"result code"\n
            std::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;
}

3.8 Daemon.hpp

#pragma once

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string nullfile = "/dev/null";

void Daemon(const std::string &cwd = "")
{
    // 1. 忽略其他异常信号
    signal(SIGCLD， SIG_IGN);
    signal(SIGPIPE， SIG_IGN);
    signal(SIGSTOP， SIG_IGN);

    // 2. 将自己变成独立的会话
    if (fork() > 0)
        exit(0);
    setsid();

    // 3. 更改当前调用进程的工作目录
    if (!cwd.empty())
        chdir(cwd.c_str());

    // 4. 标准输入，标准输出，标准错误重定向至/dev/null
    int fd = open(nullfile.c_str()， O_RdwR);
    if(fd > 0)
    {
        dup2(fd， 0);
        dup2(fd， 1);
        dup2(fd， 2);
        close(fd);
    }
}

3.9 json简单使用

其实我们有更好的两个工具能帮我们完成序列化和反序列化，一个是json 一个是productor

  • 关于json的下载

Linux中的自定义协议+序列反序列化用法

安装这个json，其实就是将头文件和源文件安装在制定的路径下

  • 头文件：

Linux中的自定义协议+序列反序列化用法

  • 库文件：

Linux中的自定义协议+序列反序列化用法

  • 使用第三方库必须要指定链接

Linux中的自定义协议+序列反序列化用法

测试代码：

#include <iostream>
#include <jsoncpp/json/json.h>
#include <unistd.h>

// {a:120， b:"123"}
int main()
{
    Json::Value part1;
    part1["haha"] = "haha";
    part1["hehe"] = "hehe";


    Json::Value root;
    root["x"] = 100;
    root["y"] = 200;
    root["op"] = '+';
    root["desc"] = "this is a + oper";
    root["test"] = part1;

    //Json::FastWriter w;
    Json::StyledWriter w;
    std::string res = w.write(root);

    std::cout << res << std::endl;

    sleep(3);

    Json::Value v;
    Json::Reader r;
    r.parse(res， v);

    int x = v["x"].asInt();
    int y = v["y"].asInt();
    char op = v["op"].asInt();
    std::string desc = v["desc"].asString();
    Json::Value temp = v["test"];
    std::cout << x << std::endl;
    std::cout << y << std::endl;
    std::cout << op << std::endl;
    std::cout << desc << std::endl;



    return 0;
}

（1）头文件必须要指明路径

（2）Json是万能类 Value代表对象

（3）FastWrite是快速写StyleWrite是风格写

（4）asInt表示解析成int类型

3.10Protocol.hpp改进版

#pragma once

#include <iostream>
#include <string>
#include<jsoncpp/json/json.h>
// #define MySelf 1

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
// "protocohttp://www.chinasem.cnlnumber"\n"len"\n"x op y"\nXXXXXX
bool Decode(std::string &package， std::string *content)
{
    std::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);
    // package = len_str + content_str + 2
    std::size_t total_len = len_str.size() + len + 2;
    if(package.size() < total_len) return false;

    *content = package.substr(pos+1， len);
    // earse 移除报文 package.erase(0， total_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;
#else
        Json::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 MySelf
        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 + 1);

        if (left + 2 != right)
            return false;
        _op = in[left + 1];
        _x = std::stoi(part_x);
        _y = std::stoi(part_y);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in， root);

        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _op = root["op"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout << "新请求构建完成:  " << _x << _op << _y << "=?" << std::endl;
    }
public:
    // x op y
    int _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;
#else
        Json::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) // "result code"
    {
#ifdef MySelf
        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;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in， root);

        _result = root["result"].asInt();
        _code = root["code"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout << "结果响应完成， result: " << _result << "， code: "<< _code << std::endl;
    }
public:
    int _result;
    int _code; // 0，可信，否则!0具体是几，表明对应的错误原因
};

3.11 Makefile

.PHONY:all
all:servercal clientcal

Flag=#-DMySelf=1
Lib=-ljsoncpp

servercal:ServerCal.cc
	g++ -o $@ $^ -std=c++11 $(Lib) $(Flag)
clientcal:ClientCal.cc
	g++ -o $@ $^ -std=c++11 -g $(Lib) $(Flag)


.PHONY:clean
clean:
	rm -f clientcal servercal

Linux中的自定义协议+序列反序列化用法

Linux中的自定义协议+序列反序列化用法

四，再谈七层协议

Linux中的自定义协议+序列反序列化用法

  • 会话层： 由服务端解决获取新链接，维护整个链接的使用情况，创建子进程来对外提供服务，相当于没访问一次服务我就会创建一个新的会话，然后去处理新的连接，不需要就关掉
  • 表示层：相当于协议的序列化和反序列化
  • 应用层：处理数据，不同的数据需要有不同的协议

为什么要压成一层呢？？因为以上都是在用户层去实现的，因为方法由很多但是谁也说服不了谁，所以无法统一把他搞到OS模块而必须由用户根据不同的场景去定制

每次服务都要自己去定自定义协议吗？？其实是不需要的，有人想就会有人去做，所以应用层的协议大部分不需要自己写，可以直接用就可以了，因为他全都考虑到了。 一般公司产品比较严格不会让你使用第三方库。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持China编程(www.chinasem.cn)。

这篇关于Linux中的自定义协议+序列反序列化用法的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155611。

相关文章

C语言自定义类型之联合和枚举解读

C语言自定义类型之联合和枚举解读

《C语言自定义类型之联合和枚举解读》联合体共享内存,大小由最大成员决定,遵循对齐规则；枚举类型列举可能值,提升可读性和类型安全性,两者在C语言中用于优化内存和程序效率... 目录一、联合体1.1 联合体类型的声明1.2 联合体的特点1.2.1 特点11.2.2 特点21.2.3 特点31.3 联合体的大小1
阅读更多...
Linux中的HTTPS协议原理分析

Linux中的HTTPS协议原理分析

《Linux中的HTTPS协议原理分析》文章解释了HTTPS的必要性：HTTP明文传输易被篡改和劫持,HTTPS通过非对称加密协商对称密钥、CA证书认证和混合加密机制,有效防范中间人攻击,保障通信安全... 目录一、什么是加密和解密？二、为什么需要加密？三、常见的加密方式3.1 对称加密3.2非对称加密四、
阅读更多...
javaSE类和对象进阶用法举例详解

javaSE类和对象进阶用法举例详解

《javaSE类和对象进阶用法举例详解》JavaSE的面向对象编程是软件开发中的基石,它通过类和对象的概念,实现了代码的模块化、可复用性和灵活性,：本文主要介绍javaSE类和对象进阶用法的相关资... 目录前言一、封装1.访问限定符2.包2.1包的概念2.2导入包2.3自定义包2.4常见的包二、stati
阅读更多...
Linux之UDP和TCP报头管理方式

Linux之UDP和TCP报头管理方式

《Linux之UDP和TCP报头管理方式》文章系统讲解了传输层协议UDP与TCP的核心区别：UDP无连接、不可靠,适合实时传输（如视频）,通过端口号标识应用；TCP有连接、可靠,通过确认应答、序号、窗... 目录一、关于端口号1.1 端口号的理解1.2 端口号范围的划分1.3 认识知名端口号1.4 一个进程
阅读更多...
Linux权限管理与ACL访问控制详解

Linux权限管理与ACL访问控制详解

《Linux权限管理与ACL访问控制详解》Linux权限管理涵盖基本rwx权限（通过chmod设置）、特殊权限（SUID/SGID/StickyBit）及ACL精细授权,由umask决定默认权限,需合... 目录一、基本权限概述1. 基本权限与数字对应关系二、权限管理命令（chmod）1. 字符模式语法2.
阅读更多...
在Linux系统上连接GitHub的方法步骤(适用2025年)

在Linux系统上连接GitHub的方法步骤(适用2025年)

《在Linux系统上连接GitHub的方法步骤(适用2025年)》在2025年,使用Linux系统连接GitHub的推荐方式是通过SSH(SecureShell)协议进行身份验证,这种方式不仅安全,还... 目录步骤一：检查并安装 Git步骤二：生成 SSH 密钥步骤三：将 SSH 公钥添加到 github
阅读更多...
Linux线程同步/互斥过程详解

Linux线程同步/互斥过程详解

《Linux线程同步/互斥过程详解》文章讲解多线程并发访问导致竞态条件,需通过互斥锁、原子操作和条件变量实现线程安全与同步,分析死锁条件及避免方法,并介绍RAII封装技术提升资源管理效率... 目录01. 资源共享问题1.1 多线程并发访问1.2 临界区与临界资源1.3 锁的引入02. 多线程案例2.1 为
阅读更多...
C语言中%zu的用法解读

C语言中%zu的用法解读

《C语言中%zu的用法解读》size_t是无符号整数类型,用于表示对象大小或内存操作结果,%zu是C99标准中专为size_t设计的printf占位符,避免因类型不匹配导致错误,使用%u或%d可能引发... 目录size_t 类型与 %zu 占位符%zu 的用途替代占位符的风险兼容性说明其他相关占位符验证示
阅读更多...
MySQL中EXISTS与IN用法使用与对比分析

MySQL中EXISTS与IN用法使用与对比分析

《MySQL中EXISTS与IN用法使用与对比分析》在MySQL中,EXISTS和IN都用于子查询中根据另一个查询的结果来过滤主查询的记录,本文将基于工作原理、效率和应用场景进行全面对比... 目录一、基本用法详解1. IN 运算符2. EXISTS 运算符二、EXISTS 与 IN 的选择策略三、性能对比
阅读更多...
Oracle数据库定时备份脚本方式(Linux)

Oracle数据库定时备份脚本方式(Linux)

《Oracle数据库定时备份脚本方式(Linux)》文章介绍Oracle数据库自动备份方案,包含主机备份传输与备机解压导入流程,强调需提前全量删除原库数据避免报错,并需配置无密传输、定时任务及验证脚本... 目录说明主机脚本备机上自动导库脚本整个自动备份oracle数据库的过程（建议全程用root用户）总结
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2