• 【计算机网络_应用层】协议定制&序列化反序列化

    文章目录

    1. TCP协议的通信流程

    在之前的代码中，相信大家对TCP的通信过程的代码已经有了一定了了解。在很早之前就了解到过一些网络通信的相关描述，比如TCP的三次握手和四次挥手。那么什么是三次握手和四次挥手呢？

    在介绍之前我们首先看一个图，通过这个图来了解，接下来我们讲解这张图：

    ca04d7ca00e56d5855fd5d0bc694bc6d

    在最开始的时候客户端和服务器都是处于关闭状态的。

    1. 开始前的准备

    1. 服务端和客户端在任意时刻在应用层调用socket函数分配一个文件描述符
    2. 服务端显示bind指定端口和任意IP地址
    3. 服务端调用listen使对应的文件描述符成为一个监听描述符
    4. 服务端调用accept阻塞等待客户端的连接（至此，服务端在通信钱的准备已经完成）

    2. 三次握手

    1. 客户端调用connect函数向服务器发起连接请求，然后阻塞自己等待完成

    2. 服务端收到客户端的连接请求之后由OS完成连接然后accept调用完成

      这里connect是三次握手的开始，accept调用完成时三次握手一定已经结束了，三次握手是OS内部自己完成的在TCP层我们感知不到

    3. 四次挥手

    四次挥手的工作都是由双方的OS完成，而我们决定什么时候挥手，一旦调用系统调用close，应用层就不用管了

    2. 应用层协议定制

    我们在第一次谈到协议的时候就说协议其实就是一种约定。在此之前，我们也写过一些UDP和TCP的通信代码，使用过一些socket API，我们可以发现socket API在发送数据的时候都是按照“字符串”的形式来发送和接收的，那如果我们要传输一些结构化的数据该怎么办呢？

    比如在发送一条QQ消息的时候，需要带上发消息的人的昵称、QQ号、消息本身等等，这些消息必须要一次性绑定的发送，那么我们在发送的时候就需要把这些内容打包成一个“字符串”来发送

    为什么不直接发送一个结构体对象？

    网络通信涉及到不同的机器，可能出现大小段问题和内存对齐问题等等，所以不能直接发送结构体

    这个打包成一个字符串的过程就是序列化，将收到的一个字符串转化为多个信息的过程就是反序列化

    那么最终我们发送的消息就可以看作是一个完整的Content，但是TCP通信是面向字节流的，所以在通信的过程中，我们也没有办法知道一次发送过来的数据里面有几个完整的Content，这就需要在应用层定制一些“协议”来保证能区分每个数据包，一般来说我们有以下几种方法

    1. 确保每个数据包是定长的； 2. 用特殊符号来表示结尾； 3. 自描述

    注意：这里序列化反序列化和协议定制是两码事。序列化反序列化的作用是将要发送的信息变成一整条消息；协议定制的作用是保证每次读取一整个数据包，这个数据包里面会包含包头和有效载荷，这个有效载荷就是我们所说的“一整条消息”

    3. 通过“网络计算器”的实现来实现应用层协议定制和序列化

    3.1 protocol

    设计思想：实现两个类：request用于存储对应的运算请求，存放算式，包括两个操作数和一个操作符。response表示对应请求的响应，也就是运算的结果状态和运算结果。最终经过系列化和反序列化之后形成一个字符串形式的有效载荷，我们在这个有效载荷前面加上报头信息，这里我们**约定：报头的内容是一个字符串格式的数据，存放的是有效载荷的长度，有效载荷和报头之间存在一个分隔符**

    这里的约定就是我们的协议

    既然有了应用层的通信协议，那么我们就要实现对应的为有效载荷添加报头和去除报头：

    std::string enLength(const std::string &text) // 在text上加报头
{
    // "content_len"\r\t"text"\r\t
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;

    return send_string;
}
bool deLength(const std::string &package, std::string *text) // 从package上去报头
{
    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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    3.2 序列化和反序列化

    3.2.1 手写序列化和反序列化

    按照我们的约定，我们希望发送的结构化的数据就是Request和Response，里面有一些特定的字段

    enum // 协议定义的相关错误枚举
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};
class Request // 客户端请求数据
{
public:
    int x;
    int y;
    char op;
};
class Response // 服务器响应数据
{
public:
    int exitcode;
    int result;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    那么对于结构化的数据，我们要首先将其序列化，才能够作为有效载荷去添加报头，然后发送。接收到发送的数据去除报头之后的有效载荷，同样需要进行反序列化才能拿到结构化的数据，进行操作

    #define SEP " "                       // 分隔符
#define SEP_LEN strlen(SEP)           // 分隔符长度
#define LINE_SEP "\r\n"               // 行分隔符（分隔报头和有效载荷）
#define LINE_SEP_LEN strlen(LINE_SEP) // 行分隔符长度
// class Request // 客户端请求数据
bool serialize(std::string *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;
    return true;
}
// "x op y"
bool deserialize(std::string &in) // 反序列化
{
    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 - SEP_LEN - left != 1)
        return false; // op的长度不为1

    std::string left_str = in.substr(0, left);
    std::string right_str = in.substr(right + SEP_LEN);
    if (left_str.empty() || right_str.empty())
        return false;

    x = std::stoi(left_str);
    y = std::stoi(right_str);
    op = in[left + SEP_LEN];
    return true;
}
// class Response // 服务器响应数据
bool serialize(std::string *out) // 序列化
{
    // "exitcode result"
    *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;
    return true;
}
bool deserialize(std::string &in) // 反序列化 "exitcode result"
{
    auto pos = in.find(SEP);
    if (pos == std::string::npos)
        return false;
    std::string ec_string = in.substr(0, pos);
    std::string res_string = in.substr(pos + SEP_LEN);
    if (ec_string.empty() || res_string.empty())
        return false;
    exitcode = std::stoi(ec_string);
    result = std::stoi(res_string);
    return true;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    3.2.2 使用Json库

    我们会发现手写序列化好麻烦 ，那么实际上有人已经帮我们做过这件事情了，提供了一些可以使用的组件，我们只需要按照规则使用即可。常用的序列化和反序列化工具有1. Json； 2. protobuf； 3. xml。这里我们为了使用的方便，采用Json来写。（protobuf在之后的博文会更新使用方式）

    // class Request // 客户端请求数据
bool serialize(std::string *out) // 序列化
{
    Json::Value root; // Json::Value 是一个KV结构。首先定义出这个结构
    root["first"] = x; // 按照KV结构的模式，为每个字段添加一个Key，给这个字段赋值
    root["second"] = y;
    root["oper"] = op;

    Json::FastWriter writer; // FastWriter是一个序列化的类，里面提供了write方法，这个方法可以将Value的对象转成std::string
    *out = writer.write(root); // 转换后的字符串就是序列化后的结果
    return true;
}
bool deserialize(std::string &in) // 反序列化
{
    Json::Value root; // 序列化后的结果需要被存放
    Json::Reader reader; // Reader类是用作读取的，里面提供了parse（解析）方法，可以将对应的序列化结果string转化成Value对象
    reader.parse(in, root);

    x = root["first"].asInt();// 按照KV结构的模式将存放的内容提取出来，提取出来的结果的类型是Json内部的，要使用的时候需要指定类型
    y = root["second"].asInt();
    op = root["oper"].asInt();
    return true;
}

// class Response // 服务器响应数据
bool serialize(std::string *out) // 序列化
{
    Json::Value root;
    root["first"] = exitcode;
    root["second"] = result;
    Json::FastWriter writer;
    *out = writer.write(root);
    return true;
}
bool deserialize(std::string &in) // 反序列化 "exitcode result"
{
    Json::Value root;
    Json::Reader reader;
    reader.parse(in, root);
    exitcode = root["first"].asInt();
    result = root["second"].asInt();
    return true;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    Json库不是标准库的内容，所以在使用之前需要安装，在cent OS下的安装命令

    sudo yum install -y jsoncpp-devel # 安装json

    • 1

    安装之后编译我们的代码会报错么？当然会！因为我们没有链接

    cc=g++

.PHONY:all
all:Server Client

Server:calServer.cc
	$(cc) -o $@ $^ -lpthread -ljsoncpp -std=c++11 # 这里加上-ljsoncpp

Client:calClient.cc
	$(cc) -o $@ $^ -ljsoncpp -std=c++11 # 这里加上-ljsoncpp

.PHONY:clean
clean:
	rm -f Server Client

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    3.3 数据包读取

    首先明确一点：TCP协议是面向字节流的，不能确定是否当前收到的就是一个完整的报文，所以需要进行判断与读取

    这里我们采用的方法是：如果读取到一个完整的报文就进行后续处理，如果没有读取到一个完整的报文，那就继续读取，直到遇到完整报文再处理

    /**
 * sock:读取对应套接字的报文
 * inbuffer:接收缓冲区，这里存放接收到的所有数据
 * req_text:输出型参数，如果读到完整报文就将报文内容存放到req_text中
 * 返回值:读取成功返回true，失败返回false
*/
bool recvPackage(int sock, std::string &inbuffer, std::string *req_text)
{
    char buffer[1024];
    while (true)
    {
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 接收数据
        if (n > 0)
        {
            buffer[n] = 0;      // 当前本次接收的数据
            inbuffer += buffer; // 放在inbuffer后面，处理整个inbuffer
            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 + 2 * LINE_SEP_LEN + text_len_string.size(); // 报文总长度

            if (inbuffer.size() < total_len)
            {
                // 收到的信息不是一个完整的报文
                continue;
            }
            // 到这里就拿到了一个完整的报文
            *req_text = inbuffer.substr(0, total_len);
            inbuffer.erase(0, total_len); // 在缓冲区中删除拿到的报文
            return true;
        }
        else
            return false;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    3.4 服务端设计

    按照我们在上一篇博文的多进程版本设计，这里服务端将会让一个孙子进程来执行相关的操作，其中孙子进程需要执行的任务分为5个步骤：

    1. 读取报文，读取到一个完整报文之后去掉报头； 2. 将有效载荷反序列化； 3. 进行业务处理（回调）； 4. 将响应序列化； 5. 将徐姐话的响应数据构建成一个符合协议的报文发送回去

    void handleEntery(int sock, func_t func) // 服务端调用
{
    std::string inbuffer;// 接收缓冲区
    while(true)
    {
        // 1. 读取数据
        std::string req_text, req_str;
        // 1.1 读到一个完整的请求（带报头）req_text = "content_len"\r\t"x op y"\r\t
        if(!recvPackage(sock, inbuffer, &req_text)) return;
        // 1.2 将req_text解析成req_str（不带报头）"x op y"
        if(!deLength(req_text, &req_str)) return;

        // 2. 数据反序列化
        Request req;
        if(!req.deserialize(req_str)) return;

        // 3. 业务处理
        Response resp;
        func(req, resp);

        // 4. 数据序列化
        std::string send_str;
        if(!resp.serialize(&send_str)) return;

        // 5. 发送响应数据
        // 5.1 构建一个完整的报文
        std::string resp_str = enLength(send_str);
        // 5.2 发送
        send(sock, resp_str.c_str(), resp_str.size(), 0);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    对应需要执行的内容我们就在业务逻辑层来处理

    bool cal(const Request &req, Response &resp)
{
    // 此时结构化的数据就在req中，可以直接使用
    resp.exitcode = 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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    3.5 最后的源代码和运行结果

    /*calServer.hpp*/
#pragma once

#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 

#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 handleEntery(int sock, func_t func) // 服务端调用
    {
        std::string inbuffer;// 接收缓冲区
        while(true)
        {
            // 1. 读取数据
            std::string req_text, req_str;
            // 1.1 读到一个完整的请求（带报头）req_text = "content_len"\r\t"x op y"\r\t
            if(!recvPackage(sock, inbuffer, &req_text)) return;
            // 1.2 将req_text解析成req_str（不带报头）"x op y"
            if(!deLength(req_text, &req_str)) return;

            // 2. 数据反序列化
            Request req;
            if(!req.deserialize(req_str)) return;

            // 3. 业务处理
            Response resp;
            func(req, resp);

            // 4. 数据序列化
            std::string send_str;
            if(!resp.serialize(&send_str)) return;

            // 5. 发送响应数据
            // 5.1 构建一个完整的报文
            std::string resp_str = enLength(send_str);
            // 5.2 发送
            send(sock, resp_str.c_str(), resp_str.size(), 0);
        }
    }
    class tcpServer;
    class ThreadData // 封装线程数据，用于传递给父进程
    {
    public:
        ThreadData(tcpServer *self, int sock) : _self(self), _sock(sock) {}

    public:
        tcpServer *_self;
        int _sock;
    };

    class tcpServer
    {
    public:
        tcpServer(uint16_t &port) : _port(port)
        {
        }
        void initServer()
        {
            // 1. 创建socket文件套接字对象
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock == -1)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success:%d", _listensock);
            // 2.bind自己的网络信息
            sockaddr_in local;
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);
            local.sin_addr.s_addr = INADDR_ANY;
            int n = bind(_listensock, (struct sockaddr *)&local, sizeof local);
            if (n == -1)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");
            // 3. 设置socket为监听状态
            if (listen(_listensock, gbacklog) != 0) // listen 函数
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }

        void start(func_t func)
        {
            while (true)
            {
                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;
                }

                // version 2:多进程版本
                pid_t id = fork();
                if (id == 0)
                {
                    close(_listensock); // 子进程不会使用监听socket，但是创建子进程的时候写时拷贝会拷贝，这里先关掉
                    // 子进程再创建子进程
                    if (fork() > 0)
                        exit(0); // 父进程退出
                    // 走到当前位置的就是子进程
                    handleEntery(sock, func); // 使用
                    close(sock);     // 关闭对应的通信socket（这里也可以不关闭，因为此进程在下个语句就会退出）
                    exit(0);         // 孙子进程退出
                }
                // 走到这里的是监听进程（爷爷进程）
                pid_t n = waitpid(id, nullptr, 0);
                if (n > 0)
                {
                    logMessage(NORMAL, "wait success pid:%d", n);
                }
                close(sock);

            }
        }
        ~tcpServer() {}

    private:
        uint16_t _port;
        int _listensock;
    };

} // namespace Server
/*calServer.cc*/
#include 
#include 

#include "calServer.hpp"
#include "protocol.hpp"

using namespace Server;

static void Usage(const char *proc)
{
    std::cout << "\n\tUsage:" << proc << " local_port\n";
}

bool cal(const Request &req, Response &resp)
{
    // 此时结构化的数据就在req中，可以直接使用
    resp.exitcode = 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;
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<tcpServer> tsvr(new tcpServer(port));
    tsvr->initServer();
    tsvr->start(cal);
    return 0;
}
/*protocol.hpp*/
#pragma once

#include 
#include 
#include 

#define SEP " "                       // 分隔符
#define SEP_LEN strlen(SEP)           // 分隔符长度
#define LINE_SEP "\r\n"               // 行分隔符（分隔报头和有效载荷）
#define LINE_SEP_LEN strlen(LINE_SEP) // 行分隔符长度

enum // 协议定义的相关错误枚举
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};

std::string enLength(const std::string &text) // 在text上加报头
{
    // "content_len"\r\t"text"\r\t
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;

    return send_string;
}
bool deLength(const std::string &package, std::string *text) // 从package上去报头
{
    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;
}

class Request // 客户端请求数据
{
public:
    Request() {}
    Request(int x_, int y_, char op_) : x(x_), y(y_), op(op_) {}
    bool serialize(std::string *out) // 序列化 -> "x op y"
    {
#ifdef MYSELF
        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; // Json::Value 是一个KV结构。首先定义出这个结构
        root["first"] = x; // 按照KV结构的模式，为每个字段添加一个Key，给这个字段赋值
        root["second"] = y;
        root["oper"] = op;

        Json::FastWriter writer; // FastWriter是一个序列化的类，里面提供了write方法，这个方法可以将Value的对象转成std::string
        *out = writer.write(root); // 转换后的字符串就是序列化后的结果
#endif
        return true;
    }
    // "x op y"
    bool deserialize(std::string &in) // 反序列化
    {
#ifdef MYSELF
        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 - SEP_LEN - left != 1)
            return false; // op的长度不为1

        std::string left_str = in.substr(0, left);
        std::string right_str = in.substr(right + SEP_LEN);
        if (left_str.empty() || right_str.empty())
            return false;

        x = std::stoi(left_str);
        y = std::stoi(right_str);
        op = in[left + SEP_LEN];
#else
        Json::Value root; // 序列化后的结果需要被存放
        Json::Reader reader; // Reader类是用作读取的，里面提供了parse（解析）方法，可以将对应的序列化结果string转化成Value对象
        reader.parse(in, root);

        x = root["first"].asInt();// 按照KV结构的模式将存放的内容提取出来，提取出来的结果的类型是Json内部的，要使用的时候需要指定类型
        y = root["second"].asInt();
        op = root["oper"].asInt();
#endif
        return true;
    }

public:
    int x;
    int y;
    char op;
};

class Response // 服务器响应数据
{
public:
    bool serialize(std::string *out) // 序列化
    {
#ifdef MYSELF
        // "exitcode result"
        *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["first"] = exitcode;
        root["second"] = result;
        Json::FastWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }
    bool deserialize(std::string &in) // 反序列化 "exitcode result"
    {
#ifdef MYSELF
        auto pos = in.find(SEP);
        if (pos == std::string::npos)
            return false;
        std::string ec_string = in.substr(0, pos);
        std::string res_string = in.substr(pos + 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["first"].asInt();
        result = root["second"].asInt();
#endif
        return true;
    }

public:
    int exitcode;
    int result;
};

/**
 * sock:读取对应套接字的报文
 * inbuffer:接收缓冲区，这里存放接收到的所有数据
 * req_text:输出型参数，如果读到完整报文就将报文内容存放到req_text中
 * 返回值:读取成功返回true，失败返回false
*/
bool recvPackage(int sock, std::string &inbuffer, std::string *req_text)
{
    char buffer[1024];
    while (true)
    {
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 接收数据
        if (n > 0)
        {
            buffer[n] = 0;      // 当前本次接收的数据
            inbuffer += buffer; // 放在inbuffer后面，处理整个inbuffer
            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 + 2 * LINE_SEP_LEN + text_len_string.size(); // 报文总长度

            if (inbuffer.size() < total_len)
            {
                // 收到的信息不是一个完整的报文
                continue;
            }
            // 到这里就拿到了一个完整的报文
            *req_text = inbuffer.substr(0, total_len);
            inbuffer.erase(0, total_len); // 在缓冲区中删除拿到的报文
            return true;
        }
        else
            return false;
    }
}
/*calClient.hpp*/
#pragma once
#include 
#include 
#include 
#include 

#include 

#include "log.hpp"
#include "protocol.hpp"

namespace Client
{
    class tcpClient
    {
    public:
        tcpClient(uint16_t &port, std::string &IP) : _serverPort(port), _serverIP(IP), _sockfd(-1) {}

        void initClient()
        {
            // 1. 创建socket
            _sockfd = socket(AF_INET, SOCK_STREAM, 0);
            if (_sockfd == -1)
            {
                std::cerr << "create socket error" << std::endl;
                exit(2);
            }
        }

        void run()
        {
            struct sockaddr_in server;
            server.sin_family = AF_INET;
            server.sin_port = htons(_serverPort);
            server.sin_addr.s_addr = inet_addr(_serverIP.c_str());

            if (connect(_sockfd, (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); // 序列化结果存放的content中

                    std::string send_string = enLength(content); // 添加报头
                    send(_sockfd, send_string.c_str(), send_string.size(), 0);

                    std::string package, text;
                    if (!recvPackage(_sockfd, inbuffer, &package))
                        continue;
                    if (!deLength(package, &text))
                        continue;
                    // text中的结果就是 "exitcode result"
                    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; // 0 操作符之前 1 操作符 2 操作符之后
            int i = 0, size = line.size();
            char op;
            std::string left, right;
            while (i < size)
            {
                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;
                }
            }
            return Request(std::stoi(left), std::stoi(right), op);
        }

        ~tcpClient()
        {
            if (_sockfd >= 0)
                close(_sockfd); // 使用完关闭，防止文件描述符泄露（当然这里也可以不写，当进程结束之后一切资源都将被回收）
        }

    private:
        uint16_t _serverPort;
        std::string _serverIP;
        int _sockfd;
    };

} // namespace Client
/*calClient.cc*/
#include 
#include 

#include "calClient.hpp"
using namespace Client;

static void Usage(const char *proc)
{
    std::cout << "\n\tUsage:" << proc << " server_ip server_port\n";
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string IP = argv[1];
    uint16_t port = atoi(argv[2]);
    std::unique_ptr<tcpClient> tclt(new tcpClient(port, IP));
    tclt->initClient();
    tclt->run();

    return 0;
}
/*log.hpp*/
#include 
#include 
#include 
#include 
#include 

// 这里是日志等级对应的宏
#define DEBUG (1 << 0)
#define NORMAL (1 << 1)
#define WARNING (1 << 2)
#define ERROR (1 << 3)
#define FATAL (1 << 4)

#define NUM 1024 // 日志行缓冲区大小
#define LOG_NORMAL "log.normal" // 日志存放的文件名
#define LOG_ERR    "log.error"

const char *logLevel(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 "UNKNOW";
    }
}
//[日志等级][时间][pid]日志内容
void logMessage(int level, const char *format, ...) // 核心调用
{
    char logprefix[NUM]; // 存放日志相关信息
    time_t now_ = time(nullptr);
    struct tm *now = localtime(&now_);
    snprintf(logprefix, sizeof(logprefix), "[%s][%d年%d月%d日%d时%d分%d秒][pid:%d]",
             logLevel(level), now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec, getpid());

    char logcontent[NUM];
    va_list arg; // 声明一个变量arg指向可变参数列表的对象
    va_start(arg, format); // 使用va_start宏来初始化arg，将它指向可变参数列表的起始位置。
    // format是可变参数列表中的最后一个固定参数，用于确定可变参数列表从何处开始
    vsnprintf(logcontent, sizeof(logcontent), format, arg); // 将可变参数列表中的数据格式化为字符串，并将结果存储到logcontent中

    FILE *log =  fopen(LOG_NORMAL, "a");
    FILE *err = fopen(LOG_ERR, "a");
    if(log != nullptr && err != nullptr)
    {
        FILE *curr = nullptr;
        if(level == DEBUG || level == NORMAL || level == WARNING) curr = log;
        if(level == ERROR || level == FATAL) curr = err;
        if(curr) fprintf(curr, "%s%s\n", logprefix, logcontent);

        fclose(log);
        fclose(err);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409
    • 410
    • 411
    • 412
    • 413
    • 414
    • 415
    • 416
    • 417
    • 418
    • 419
    • 420
    • 421
    • 422
    • 423
    • 424
    • 425
    • 426
    • 427
    • 428
    • 429
    • 430
    • 431
    • 432
    • 433
    • 434
    • 435
    • 436
    • 437
    • 438
    • 439
    • 440
    • 441
    • 442
    • 443
    • 444
    • 445
    • 446
    • 447
    • 448
    • 449
    • 450
    • 451
    • 452
    • 453
    • 454
    • 455
    • 456
    • 457
    • 458
    • 459
    • 460
    • 461
    • 462
    • 463
    • 464
    • 465
    • 466
    • 467
    • 468
    • 469
    • 470
    • 471
    • 472
    • 473
    • 474
    • 475
    • 476
    • 477
    • 478
    • 479
    • 480
    • 481
    • 482
    • 483
    • 484
    • 485
    • 486
    • 487
    • 488
    • 489
    • 490
    • 491
    • 492
    • 493
    • 494
    • 495
    • 496
    • 497
    • 498
    • 499
    • 500
    • 501
    • 502
    • 503
    • 504
    • 505
    • 506
    • 507
    • 508
    • 509
    • 510
    • 511
    • 512
    • 513
    • 514
    • 515
    • 516
    • 517
    • 518
    • 519
    • 520
    • 521
    • 522
    • 523
    • 524
    • 525
    • 526
    • 527
    • 528
    • 529
    • 530
    • 531
    • 532
    • 533
    • 534
    • 535
    • 536
    • 537
    • 538
    • 539
    • 540
    • 541
    • 542
    • 543
    • 544
    • 545
    • 546
    • 547
    • 548
    • 549
    • 550
    • 551
    • 552
    • 553
    • 554
    • 555
    • 556
    • 557
    • 558
    • 559
    • 560
    • 561
    • 562
    • 563
    • 564
    • 565
    • 566
    • 567
    • 568
    • 569
    • 570
    • 571
    • 572
    • 573
    • 574
    • 575
    • 576
    • 577
    • 578
    • 579
    • 580
    • 581
    • 582
    • 583
    • 584
    • 585
    • 586
    • 587
    • 588
    • 589
    • 590
    • 591
    • 592
    • 593
    • 594
    • 595
    • 596
    • 597
    • 598
    • 599
    • 600
    • 601
    • 602
    • 603
    • 604
    • 605
    • 606
    • 607
    • 608
    • 609
    • 610
    • 611
    • 612
    • 613
    • 614
    • 615
    • 616
    • 617
    • 618
    • 619
    • 620
    • 621
    • 622
    • 623
    cc=g++

.PHONY:all
all:Server Client

Server:calServer.cc
	$(cc) -o $@ $^ -lpthread -ljsoncpp -std=c++11

Client:calClient.cc
	$(cc) -o $@ $^ -ljsoncpp -std=c++11

.PHONY:clean
clean:
	rm -f Server Client

.PHONY:cleanlog
cleanlog:
	rm -f log.error log.normal

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    image-20240227195945695

    本节完…

  • 相关阅读:
    Spring系列文章：Bean的获取⽅式
    Spark 面试题（十六）
    羧酸-COOH功能化修饰红色荧光聚苯乙烯AIE微球的产品组成和保存条件
    ubuntu突然进不了图形界面解决方案
    基于DeOldify的给黑白照片、视频上色
    祝所有的程序猿们2023年的1024节快乐~
    【ACM数论】和式变换技术，也许是最好的讲解之一
    ubuntu中/etc/rc.local和/etc/init.d/rc.local的区别是什么
    Node 版本切换
    康托展开与逆康托展开
  • 原文地址：https://blog.csdn.net/weixin_63249832/article/details/136330776