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

news2024/11/6 21:32:31

为什么要序列化？

如果光看定义很难理解序列化的意义，那么我们可以从另一个角度来推导出什么是序列化, 那么究竟序列化的目的是什么？

其实序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。

因为我们单方面的只把对象转成字节数组还不行，因为没有规则的字节数组我们是没办法把对象的本来面目还原回来的，所以我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）。

如果我们要把一栋房子从一个地方运输到另一个地方去，序列化就是我把房子拆成一个个的砖块放到车子里，然后留下一张房子原来结构的图纸，反序列化就是我们把房子运输到了目的地以后，根据图纸把一块块砖头还原成房子原来面目的过程。

是需要进行“跨平台存储”和”网络传输”的数据，都需要进行序列化。本质上存储和网络传输 都需要经过 把一个对象状态保存成一种跨平台识别的字节格式，然后其他的平台才可以通过字节信息解析还原对象信息。

序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：

JDK（不支持跨语言）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protostuff、FST（不支持跨语言）

在进行网络传输之前，我们要将数据转换成字符串的形式，以字节流的方式发送信息。双方在通信时如果发送端一直发送数据，但是接收端并没有及时的接收数据，那这一对的数据就会被堆积下来。等接收端能开始接收数据时该如何保证报文和报文的边界的呢？保证读到的时一个报文而不是半个或者1.5个报文的呢？

常见的解决方法：

1. 定  长：     即可以规定一个报文的大小为1024字节，读取时严格的按照定下的长度读取

2.特殊符号：在报文的结束端加上特殊符号“ + ” " - "等特殊符号以此区分不同的报文

3.自描述方式：规定报文的头四个字节存储的是报文的有效长度，未来在读取报文的时候首先读取这头四个字节，根据这四个字节存储的长度然后截取这个报文。

协议的实现

接下来将采用序列化和反序列化+自描述的方式实现一款简易版网络计算器。网络计算器在发起请求的过程中的格式为：a运算符b ，我们首先创建一个对象将两个运算的数和一个运算符存储起来，因为tcp是面向字节流的所以在网络通信前，首先需要将这个对象转换为字符串的形式，以字节流的方式发送数据到服务端。上文所讲为了方便服务端读取报文，所以这里采用的是自描述的方式发送数据，即在报文的有效载荷前加上一个存储报文有效长度的报头，报头再与报文之间用特殊的字符隔开，未来再服务端进行读取时就找这个特殊的分隔符，根据分隔符确定报头的位置，然后根据报头中存储的有效的长度就可以完整的读取到一条客户端的请求。

 客户端发起请求就是serialize+enLength（序列化+自描述），服务端在接收到这个报文后首先去掉报头得到正文，将正文反序列化得到一个包含正文元素的对象（请求对象），此时再创建一个要返回结果的对象（响应对象），将这请求对象和相应对象传入到计算函数中，计算函数将计算的结果和计算的退出码保存到相应对象中，再将相应对象序列化+添加报头组成一个大的“字符串”通过网络发送到客户端，客户端接收后先去报头再反序列化构建出一个对象，这个对象中就保存着计算的结果和计算的退出码。

客户端从网络接收到数据后先去报头得到正文，反序列化得到对象，对象中所存储的值就有这次运算的退出码和运算结果。

 协议的定制中包括：1分隔符的种类2.添加报头3.去报头3.数据从缓冲区的接收4.请求对象的序列化和反序列化 5.相应对象的序列化和反序列化6.运行结果的退出码

代码如下： 

#pragma once

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

#define SEP " "
#define SEP_LEN strlen(SEP) // 不敢使用sizeof()
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP) // 不敢使用sizeof()

enum
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};

// "x op y" -> "content_len"\r\n"x op y"\r\n
// "exitcode result" -> "content_len"\r\n"exitcode result"\r\n
std::string enLength(const std::string &text)
{
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;

    return send_string;
}

// "content_len"\r\n"exitcode result"\r\n
bool deLength(const std::string &package, std::string *text)
{
    auto pos = package.find(LINE_SEP);
    if (pos == std::string::npos)
        return false;
    std::string text_len_string = package.substr(0, pos);
    int text_len = std::stoi(text_len_string);
    *text = package.substr(pos + LINE_SEP_LEN, text_len);
    return true;
}

// 没有人规定我们网络通信的时候，只能有一种协议！！
// 我们怎么让系统知道我们用的是哪一种协议呢？？
// "content_len"\r\n"协议编号"\r\n"x op y"\r\n

class Request
{
public:
    Request() : x(0), y(0), op(0)
    {
    }
    Request(int x_, int y_, char op_) : x(x_), y(y_), op(op_)
    {
    }
    // 1. 自己写
    // 2. 用现成的
    bool serialize(std::string *out)
    {
#ifdef MYSELF
        *out = "";
        // 结构化 -> "x op y";
        std::string x_string = std::to_string(x);
        std::string y_string = std::to_string(y);

        *out = x_string;
        *out += SEP;
        *out += op;
        *out += SEP;
        *out += y_string;
#else
        Json::Value root;
        root["first"] = x;
        root["second"] = y;
        root["oper"] = op;

        Json::FastWriter writer;
        // Json::StyledWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }

    // "x op yyyy";
    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        // "x op y" -> 结构化
        auto left = in.find(SEP);
        auto right = in.rfind(SEP);
        if (left == std::string::npos || right == std::string::npos)
            return false;
        if (left == right)
            return false;
        if (right - (left + SEP_LEN) != 1)
            return false;

        std::string x_string = in.substr(0, left); // [0, 2) [start, end) , start, end - start
        std::string y_string = in.substr(right + SEP_LEN);

        if (x_string.empty())
            return false;
        if (y_string.empty())
            return false;
        x = std::stoi(x_string);
        y = std::stoi(y_string);
        op = in[left + SEP_LEN];
#else
        Json::Value root;
        Json::Reader reader;
        reader.parse(in, root);

        x = root["first"].asInt();
        y = root["second"].asInt();
        op = root["oper"].asInt();
#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)
    {
#ifdef MYSELF
        *out = "";
        std::string ec_string = std::to_string(exitcode);
        std::string res_string = std::to_string(result);

        *out = ec_string;
        *out += SEP;
        *out += res_string;
#else
        Json::Value root;
        root["exitcode"] = exitcode;
        root["result"] = result;

        Json::FastWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }
    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        // "exitcode result"
        auto mid = in.find(SEP);
        if (mid == std::string::npos)
            return false;
        std::string ec_string = in.substr(0, mid);
        std::string res_string = in.substr(mid + SEP_LEN);
        if (ec_string.empty() || res_string.empty())
            return false;

        exitcode = std::stoi(ec_string);
        result = std::stoi(res_string);
#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; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
    int result;   // 计算结果
};

// "content_len"\r\n"x op y"\r\n"content_len"\r\n"x op y"\r\n"content_len"\r\n"x op
bool recvPackage(int sock, std::string &inbuffer, std::string *text)
{
    char buffer[1024];
    while (true)
    {
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if (n > 0)
        {
            buffer[n] = 0;
            inbuffer += buffer;
            // 分析处理
            auto pos = inbuffer.find(LINE_SEP);
            if (pos == std::string::npos)
                continue;
            std::string text_len_string = inbuffer.substr(0, pos);
            int text_len = std::stoi(text_len_string);
            int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
            // text_len_string + "\r\n" + text + "\r\n" <= inbuffer.size();
            std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;

            if (inbuffer.size() < total_len)
            {
                std::cout << "你输入的消息，没有严格遵守我们的协议，正在等待后续的内容, continue" << std::endl;
                continue;
            }

            // 至少有一个完整的报文
            *text = inbuffer.substr(0, total_len);
            inbuffer.erase(0, total_len);

            std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;

            break;
        }
        else
            return false;
    }
    return true;
}

服务端将字符串通过去报头和反序列化的操作就将客户端的请求构建出来一个请求对象，服务端再创建一个响应对象，这两个对象在计算函数的内部将计算的结果和计算的退出码一起存储到响应对象中，至此完成了计算任务，计算函数如下：

bool cal(const Request &req, Response &resp)
{
  
    resp.exitcode = OK;
    resp.result = OK;

    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.exitcode = DIV_ZERO;
        else
            resp.result = req.x / req.y;
    }
    break;
    case '%':
    {
        if (req.y == 0)
            resp.exitcode = MOD_ZERO;
        else
            resp.result = req.x % req.y;
    }
    break;
    default:
        resp.exitcode = OP_ERROR;
        break;
    }

    return true;
}

客户端启动后，就会弹出让用户输入计算的式子，这个式子是从键盘接收的，首先将接收的式子存到一个零时缓冲区内，方便我们对输入的式子切割并完成对请求对象的构建，调用切割的函数如下：

 Request ParseLine(const std::string &line)
    {
        
        int status = 0; 
        int i = 0;
        int cnt = line.size();
        std::string left, right;
        char op;
        while (i < cnt)
        {
            switch (status)
            {
            case 0:
            {
                if(!isdigit(line[i]))
                {
                    op = line[i];
                    status = 1;
                }
                else left.push_back(line[i++]);
            }
            break;
            case 1:
                i++;
                status = 2;
                break;
            case 2:
                right.push_back(line[i++]);
                break;
            }
        }
        std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
        return Request(std::stoi(left), std::stoi(right), op);
    }

这是一个名为ParseLine的C++函数，它接受一个名为line的std::string参数，并返回一个Request对象。ParseLine函数首先初始化一些变量，包括status、i、cnt、left、right和op。status跟踪正在读取字符串的哪个部分，i跟踪正在读取的字符的索引，cnt是输入字符串的大小，left和right分别保存左操作数和右操作数，op保存运算符。接下来，ParseLine使用while循环遍历输入字符串中的每个字符。在while循环内，有一个switch语句，根据当前状态处理不同情况。在第0种情况下，函数使用isdigit()检查索引i处的当前字符是否为数字。如果它不是数字，则将op设置为当前字符，将状态更新为1，并继续到下一个字符。否则，它将当前字符附加到left字符串中并增加i。在第1种情况下，它增加i并将状态更改为2。在第2种情况下，它将当前字符附加到right字符串中并增加i。while循环结束后，函数使用std::cout打印left、right和op的值，并使用解析后的left、right和op值构造一个Request对象并返回它。这样就完成了请求对象的构建。

对于序列化和反序列化这个操作的过程可以自己完成，也可以使用Json协议，使用别人定制好的成熟的方法，关于Json第三方库的安装，可以使用命令下载Json:

sudo yum install -y jsoncpp-deve

至于要使用自己的方法还是Json协议，这里可以使用条件编译的方式，将两者方法都写进代码中

代码在上方的协议文件中有体现。

数据前面的字符串就是为反序列化建立的索引，先说序列化：Value是Json中的一个万能对象，用它可以序列化不同格式的数据，创建Value对象root，root[“x”, _x]就是在root中插入了一个键值对，把所有的数插入到root后，创建FastWrite对象，以root为参数调用其write方法，用string类型对象str接收write的返回值，str中保存的就是{“op”:43,“x”:1,“y”:1}这样的字符串，是将数据序列化后的结果。

至于Json的反序列化：我们创建Reader类型对象rd与Value类型对象root，调用rd的parse方法，将root和序列化后的字符串str作为parse的参数，parse方法会将反序列化后的结果写入root，此时我们就能根据当时创建root对象时，为数据建立的索引来还原数据，比如root[“x”].asInt()，将root中以"x"为key的value值以int的格式返回，这样我们就能将数据还原到我们的结构体中

关于条件编译，我们可以在makefile文件中，以命令行的方式，在编译源文件时创建宏，具体是-D 宏的名字

实验结果演示

 全部代码：

calClient.cc:

#include "calClient.hpp"
#include <memory>

using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " serverip serverport\n\n";
}
// ./tcpclient serverip serverport
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> tcli(new CalClient(serverip, serverport));
    tcli->initClient();
    tcli->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 "protocol.hpp"

#define NUM 1024

class CalClient
{
public:
    CalClient(const std::string &serverip, const uint16_t &serverport)
        : _sock(-1), _serverip(serverip), _serverport(serverport)
    {
    }
    void initClient()
    {
        
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            std::cerr << "socket create error" << std::endl;
            exit(2);
        }
        
    }
    void start()
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(_serverport);
        server.sin_addr.s_addr = inet_addr(_serverip.c_str());

        if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
        {
            std::cerr << "socket connect error" << std::endl;
        }
        else
        {
            std::string line;
            std::string inbuffer;
            while (true)
            {
                std::cout << "mycal>>> ";
                std::getline(std::cin, line);  
                Request req = ParseLine(line); 
                std::string content;
                req.serialize(&content);
                std::string send_string = enLength(content);
                send(_sock, send_string.c_str(), send_string.size(), 0); 

                std::string package, text;
              
                if (!recvPackage(_sock, inbuffer, &package))
                    continue;
                if (!deLength(package, &text))
                    continue;
              
                Response resp;
                resp.deserialize(text);
                std::cout << "exitCode: " << resp.exitcode << std::endl;
                std::cout << "result: " << resp.result << std::endl;
            }
        }
    }
    Request ParseLine(const std::string &line)
    {
        
        int status = 0; 
        int i = 0;
        int cnt = line.size();
        std::string left, right;
        char op;
        while (i < cnt)
        {
            switch (status)
            {
            case 0:
            {
                if(!isdigit(line[i]))
                {
                    op = line[i];
                    status = 1;
                }
                else left.push_back(line[i++]);
            }
            break;
            case 1:
                i++;
                status = 2;
                break;
            case 2:
                right.push_back(line[i++]);
                break;
            }
        }
        std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
        return Request(std::stoi(left), std::stoi(right), op);
    }
    ~CalClient()
    {
        if (_sock >= 0)
            close(_sock);
    }

private:
    int _sock;
    std::string _serverip;
    uint16_t _serverport;
};

calServer.cc:

#include "calServer.hpp"
#include <memory>

using namespace server;
using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}

bool cal(const Request &req, Response &resp)
{
  
    resp.exitcode = OK;
    resp.result = OK;

    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.exitcode = DIV_ZERO;
        else
            resp.result = req.x / req.y;
    }
    break;
    case '%':
    {
        if (req.y == 0)
            resp.exitcode = MOD_ZERO;
        else
            resp.result = req.x % req.y;
    }
    break;
    default:
        resp.exitcode = OP_ERROR;
        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> tsvr(new CalServer(port));
    tsvr->initServer();
    tsvr->start(cal);
    return 0;
}

calServer.hpp:

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <functional>
#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 "log.hpp"
#include "protocol.hpp"

namespace server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5;

   
    typedef std::function<bool(const Request &req, Response &resp)> func_t;


    void handlerEntery(int sock, func_t func)
    {
        std::string inbuffer;
        while (true)
        {
           
            std::string req_text, req_str;
          
            if (!recvPackage(sock, inbuffer, &req_text))
                return;
            std::cout << "带报头的请求：\n" << req_text << std::endl;
            if (!deLength(req_text, &req_str))
                return;
            std::cout << "去掉报头的正文：\n" << req_str << std::endl;
            

          
            Request req;
            if (!req.deserialize(req_str))
                return;
            
            Response resp;
            func(req, resp); 

           
            std::string resp_str;
            resp.serialize(&resp_str);

            std::cout << "计算完成, 序列化响应: " <<  resp_str << std::endl;

          
            std::string send_string = enLength(resp_str);
            std::cout << "构建完成完整的响应\n" <<  send_string << std::endl;
        
            send(sock, send_string.c_str(), send_string.size(), 0); 
        }
    }

    class CalServer
    {
    public:
        CalServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
        {
        }
        void initServer()
        {
        
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock < 0)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success: %d", _listensock);

           
            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(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");

        
            if (listen(_listensock, gbacklog) < 0) 
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }
        void start(func_t func)
        {
            for (;;)
            {
               
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
                if (sock < 0)
                {
                    logMessage(ERROR, "accept error, next");
                    continue;
                }
                logMessage(NORMAL, "accept a new link success, get new sock: %d", sock); // ?

                // version 2 多进程版(2)
                pid_t id = fork();
                if (id == 0) // child
                {
                    close(_listensock);
                    // if(fork()>0) exit(0);
                    //  serviceIO(sock);
                    handlerEntery(sock, func);
                    close(sock);
                    exit(0);
                }
                close(sock);

                // father
                pid_t ret = waitpid(id, nullptr, 0);
                if (ret > 0)
                {
                    logMessage(NORMAL, "wait child success"); // ?
                }
            }
        }
        ~CalServer() {}

    private:
        int _listensock;
        uint16_t _port;
    };

}

日志：

#pragma once

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

#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4

const char * to_levelstr(int level)
{
    switch(level)
    {
        case DEBUG : return "DEBUG";
        case NORMAL: return "NORMAL";
        case WARNING: return "WARNING";
        case ERROR: return "ERROR";
        case FATAL: return "FATAL";
        default : return nullptr;
    }
}

void logMessage(int level, const char *format, ...)
{
#define NUM 1024
    char logprefix[NUM];
    snprintf(logprefix, sizeof(logprefix), "[%s][%ld][pid: %d]",
        to_levelstr(level), (long int)time(nullptr), getpid());

    char logcontent[NUM];
    va_list arg;
    va_start(arg, format);
    vsnprintf(logcontent, sizeof(logcontent), format, arg);

    std::cout << logprefix << logcontent << std::endl;
}

protocol.hpp:

#pragma once

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

#define SEP " "
#define SEP_LEN strlen(SEP) // 不敢使用sizeof()
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP) // 不敢使用sizeof()

enum
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};

// "x op y" -> "content_len"\r\n"x op y"\r\n
// "exitcode result" -> "content_len"\r\n"exitcode result"\r\n
std::string enLength(const std::string &text)
{
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;

    return send_string;
}

// "content_len"\r\n"exitcode result"\r\n
bool deLength(const std::string &package, std::string *text)
{
    auto pos = package.find(LINE_SEP);
    if (pos == std::string::npos)
        return false;
    std::string text_len_string = package.substr(0, pos);
    int text_len = std::stoi(text_len_string);
    *text = package.substr(pos + LINE_SEP_LEN, text_len);
    return true;
}

// 没有人规定我们网络通信的时候，只能有一种协议！！
// 我们怎么让系统知道我们用的是哪一种协议呢？？
// "content_len"\r\n"协议编号"\r\n"x op y"\r\n

class Request
{
public:
    Request() : x(0), y(0), op(0)
    {
    }
    Request(int x_, int y_, char op_) : x(x_), y(y_), op(op_)
    {
    }
    // 1. 自己写
    // 2. 用现成的
    bool serialize(std::string *out)
    {
#ifdef MYSELF
        *out = "";
        // 结构化 -> "x op y";
        std::string x_string = std::to_string(x);
        std::string y_string = std::to_string(y);

        *out = x_string;
        *out += SEP;
        *out += op;
        *out += SEP;
        *out += y_string;
#else
        Json::Value root;
        root["first"] = x;
        root["second"] = y;
        root["oper"] = op;

        Json::FastWriter writer;
        // Json::StyledWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }

    // "x op yyyy";
    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        // "x op y" -> 结构化
        auto left = in.find(SEP);
        auto right = in.rfind(SEP);
        if (left == std::string::npos || right == std::string::npos)
            return false;
        if (left == right)
            return false;
        if (right - (left + SEP_LEN) != 1)
            return false;

        std::string x_string = in.substr(0, left); // [0, 2) [start, end) , start, end - start
        std::string y_string = in.substr(right + SEP_LEN);

        if (x_string.empty())
            return false;
        if (y_string.empty())
            return false;
        x = std::stoi(x_string);
        y = std::stoi(y_string);
        op = in[left + SEP_LEN];
#else
        Json::Value root;
        Json::Reader reader;
        reader.parse(in, root);

        x = root["first"].asInt();
        y = root["second"].asInt();
        op = root["oper"].asInt();
#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)
    {
#ifdef MYSELF
        *out = "";
        std::string ec_string = std::to_string(exitcode);
        std::string res_string = std::to_string(result);

        *out = ec_string;
        *out += SEP;
        *out += res_string;
#else
        Json::Value root;
        root["exitcode"] = exitcode;
        root["result"] = result;

        Json::FastWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }
    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        // "exitcode result"
        auto mid = in.find(SEP);
        if (mid == std::string::npos)
            return false;
        std::string ec_string = in.substr(0, mid);
        std::string res_string = in.substr(mid + SEP_LEN);
        if (ec_string.empty() || res_string.empty())
            return false;

        exitcode = std::stoi(ec_string);
        result = std::stoi(res_string);
#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; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
    int result;   // 计算结果
};

// "content_len"\r\n"x op y"\r\n"content_len"\r\n"x op y"\r\n"content_len"\r\n"x op
bool recvPackage(int sock, std::string &inbuffer, std::string *text)
{
    char buffer[1024];
    while (true)
    {
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if (n > 0)
        {
            buffer[n] = 0;
            inbuffer += buffer;
            // 分析处理
            auto pos = inbuffer.find(LINE_SEP);
            if (pos == std::string::npos)
                continue;
            std::string text_len_string = inbuffer.substr(0, pos);
            int text_len = std::stoi(text_len_string);
            int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
            // text_len_string + "\r\n" + text + "\r\n" <= inbuffer.size();
            std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;

            if (inbuffer.size() < total_len)
            {
                std::cout << "你输入的消息，没有严格遵守我们的协议，正在等待后续的内容, continue" << std::endl;
                continue;
            }

            // 至少有一个完整的报文
            *text = inbuffer.substr(0, total_len);
            inbuffer.erase(0, total_len);

            std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;

            break;
        }
        else
            return false;
    }
    return true;
}

makefile:

cc=g++
LD=-DMYSELF
.PHONY:all
all:calserver calclient

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[第一章 web入门]常见的搜集

[第一章 web入门]常见的搜集

首先就利用御剑或者dirsearch扫描一下网站后台&#xff0c;可以得到以下三个路径返回正常 robots.txt index.php~ .index.php.swp 其实我没扫描出来&#xff0c;这些都是看的别人的wp才做出来的&#xff0c;一开始我其实意识到御剑其实就是有一个字典&#xff0c;然后按照字典的…
阅读更多...
【蓝桥杯算法题】用java遍写税收计算

【蓝桥杯算法题】用java遍写税收计算

【蓝桥杯算法题】用java遍写税收计算 题目&#xff1a;劳务报酬税收计算&#xff1a;输入 m &#xff0c;输出税后收入。如果 m <800&#xff0c;不扣税&#xff0c; 如果800< m <4000&#xff0e;则 m 减去800后的金额扣除20&#xff05;所得税。如果 m >4000&…
阅读更多...
SpringBoot项目使用CXF框架开发Soap通信接口

SpringBoot项目使用CXF框架开发Soap通信接口

SpringBoot项目使用CXF框架开发Soap通信接口 物料准备&#xff1a; 1.引入cxf官方提供的SpringBootStarter依赖 2.定义需要暴雷给外部调用的java接口以及接口的实现类 3.配置CxfConfig类&#xff0c;把你定义的java接口注册为webservice的Endpoint 引入cxf-spring-boot-st…
阅读更多...
Solidwoks PDM Add-ins (C#) 创建菜单命令

Solidwoks PDM Add-ins (C#) 创建菜单命令

演示如何创建 C# Add-ins :将菜单命令添加到库视图的上下文相关菜单的。 注意&#xff1a;由于 SOLIDWORKS PDM Professional 无法强制重新加载add-ins&#xff0c;因此必须重新启动所有客户端计算机以确保使用最新版本的add-ins。 启动VS。新建项目&#xff0c;选择类库。在“…
阅读更多...
数据结构——队列

数据结构——队列

数据结构——队列 文章目录 数据结构——队列前言队列基本概念队列的基本操作队列的顺序存储结构创建顺序队列代码入队操作代码出队操作代码顺序队列的关键语句 队列的链式存储结构链式队列初始化链式队列判断空链式队列的入队操作链式队列的出队操作 循环队列循环队列基本思想…
阅读更多...
「Tech初见」Linux驱动之chrdev

「Tech初见」Linux驱动之chrdev

目录 免责声明I. MotivationII. SolutionS1 - 主次设备号S2 - 设备驱动程序S3 - 字符设备驱动程序 III. Result 免责声明 「Tech初见」系列的文章&#xff0c;是本人第一次接触的话题 对所谓真理的理解暂时可能还不到位&#xff0c;避免不了会出现令人嗤鼻的谬论 所以&#…
阅读更多...
Oracle中改变表的Owner和tablespace

Oracle中改变表的Owner和tablespace

初用Oracle&#xff0c;很多的不熟悉&#xff0c;建完库&#xff0c;没有建用户&#xff0c;也没创建表空间&#xff0c;就直接system用户建表添加数据&#xff0c;几个月过去&#xff0c;表建了近百个&#xff0c;数据添加了几万条&#xff0c;才越来越觉得这种方式缺点太多&a…
阅读更多...
docker对cpu资源做限制

docker对cpu资源做限制

系列文章目录 文章目录 系列文章目录一、cgroup1.groups四大功能2.CPU 资源控制 二、1.限制可用的 swap 大小&#xff0c; --memory-swap2.对磁盘IO配额控制&#xff08;blkio&#xff09;的限制 总结 一、cgroup 1.groups四大功能 资源限制&#xff1a;可以对任务使用的资源…
阅读更多...
华为OD机试真题 JavaScript 实现【相对开音节】【2022Q4 100分】，附详细解题思路

华为OD机试真题 JavaScript 实现【相对开音节】【2022Q4 100分】，附详细解题思路

一、题目描述 相对开音节构成的结构为辅音元音&#xff08;aeiou&#xff09;辅音(r除外)e&#xff0c;常见的单词有life,time,woke,coke,joke,note,nose,communicate&#xff0c;use&#xff0c;gate&#xff0c;same&#xff0c;late等。 给定一个字符串&#xff0c;以空格…
阅读更多...
递归算法在编程中的重要应用

递归算法在编程中的重要应用

递归算法在编程中的重要应用 引言一、引言1.1、什么是递归算法&#xff1f;1.2、递归算法的特点和优缺点 二、树和图的遍历2.1、深度优先搜索&#xff08;DFS&#xff09;和广度优先搜索&#xff08;BFS&#xff09;2.2、二叉树遍历、树的深度、节点个数等问题2.2.1、二叉树遍历…
阅读更多...
关于对【oracle索引】的理解与简述

关于对【oracle索引】的理解与简述

【版权声明】未经博主同意&#xff0c;谢绝转载&#xff01;&#xff08;请尊重原创&#xff0c;博主保留追究权&#xff09; https://blog.csdn.net/m0_69908381/article/details/131094864 出自【进步*于辰的博客】 无论使用的是oracle、mysql&#xff0c;亦或者其他数据库&a…
阅读更多...
如何吃透一个Java项目？

如何吃透一个Java项目？

现在Austin的文档我觉得还是比较全的&#xff0c;但到了看代码的时候&#xff0c;可能有的同学就不知道应该怎么看&#xff0c;有想知道模块之间的调用链路&#xff0c;有想一点一点把细节给全看了。这时候就很可能在项目里犯迷糊了&#xff0c;绕不出不来了。 Java开源项目消息…
阅读更多...
MySQL的下载安装以及环境配置---图文教程

MySQL的下载安装以及环境配置---图文教程

目录 一.下载 二.安装 三.设置环境变量 四.MySQL数据库的使用及注意事项 SQL语句注意事项 一.下载 1.打开 MySQL 数据库的网站。 2.往下滑 3.进入新的页面之后&#xff0c;点击 MySQL Installer for Windows 4.进入新的页面时&#xff0c;就可以下载MySQL数据库了&#x…
阅读更多...
数据结构05：树的定义与双亲、孩子表示法[更新中]

数据结构05：树的定义与双亲、孩子表示法[更新中]

参考用书&#xff1a;王道考研《2024年 数据结构考研复习指导》 参考用书配套视频&#xff1a;5.1.1 树的定义和基本术语_哔哩哔哩_bilibili 特别感谢&#xff1a; Chat GPT老师[部分名词解释、修改BUG]、BING老师[封面图]~ 备注&#xff1a;博文目前是未完成的状态&#xff…
阅读更多...
Web安全：拿到 Web 服务器 最高权限.（vulntarget 靶场 A）

Web安全：拿到 Web 服务器 最高权限.（vulntarget 靶场 A）

Web安全&#xff1a;拿到 Web 服务器 最高权限. Web 服务器一般指网站服务器&#xff0c;是指驻留于因特网上某种类型计算机的程序&#xff0c;可以处理浏览器等Web客户端的请求并返回相应响应&#xff0c;也可以放置网站文件&#xff0c;让全世界浏览&#xff1b;可以放置数据…
阅读更多...
43 最佳实践-性能最佳实践-IOThread配置

43 最佳实践-性能最佳实践-IOThread配置

文章目录 43 最佳实践-性能最佳实践-IOThread配置43.1 概述43.2 配置说明 43 最佳实践-性能最佳实践-IOThread配置 43.1 概述 KVM平台上&#xff0c;对虚拟磁盘的读写在后端默认由QEMU主线程负责处理。这样会造成如下问题&#xff1a; 虚拟机的I/O请求都由一个QEMU主线程进行…
阅读更多...
基于springboot的数码论坛系统设计（Java、MySQL、B/S）

基于springboot的数码论坛系统设计（Java、MySQL、B/S）

wx供重浩&#xff1a;创享日记 对话框发送&#xff1a;数码论坛 获取源码源文件论文报告PPT 网络的广泛应用给生活带来了十分的便利。所以把数码论坛与现在网络相结合&#xff0c;利用java技术建设数码论坛系统&#xff0c;实现数码论坛的信息化。则对于进一步提高数码论坛发展…
阅读更多...
Linux 下pause函数是如何实现的？

Linux 下pause函数是如何实现的？

当你在程序中调用 pause() 函数时&#xff0c;它会使得你的程序停止执行&#xff0c;直到有一个信号被捕获。这是通过系统调用实现的。系统调用会使得程序从用户模式切换到内核模式。 这里是 pause() 函数的基本工作原理&#xff1a; 当你的程序调用 pause() 函数时&#xff…
阅读更多...
python基础知识(十):类

python基础知识(十):类

目录 1. 类和方法的概念2. 类的定义3. 类的继承4. 重写父类的方法 1. 类和方法的概念 类&#xff1a;用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。举个例子&#xff0c;狗类就是狗的集合&#xff0c;每条狗都是狗…
阅读更多...
kali学习笔记（二）

kali学习笔记（二）

一、关闭自动锁屏 关闭自动锁屏对于测试人员来说&#xff0c;可以按照自己的习惯来设置&#xff0c;不然kali会过十分钟就锁屏&#xff0c;有的时候会比较不方便。 1、使用root账号登录&#xff0c;在display设置选项中做如下设置。 2、把休眠选项关掉。 二、创建快照 关机创…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023