【Socket 编程】应用层自定义协议与序列化

再谈协议

协议就是约定，协议的内容就是约定好的某种结构化数据。比如，我们要实现一个网络版的计算器，客户端发送一个算术式子，服务端根据算术式子计算出结果，再把结果返回给客户端。在此之前，客户端和服务端可以做出如下两种方案的约定：

• 方案一：
  • 客户端发送一个形如“1+1"的字符串
  • 这个字符串中有两个操作数，都是整型
  • 两个数字之间会有一个字符是运算符，运算符只能是+
  • 数字和运算符之间没有空格
  • 等等
• 方案二：
  • 定义一个结构体表示一个请求信息，信息内容包括两个整数，和一个操作符
  • 发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时候再按照相同的规则把字符串转化回结构体;
  • 定义一个结构体表示一个服务器的响应，响应的信息包括，计算结果、错误码、错误信息等

为什么要做出诸如此类的约定呢？ 一切交给服务器去处理不就行了吗？

做约定的本质就是为了方便读取数据和发送数据。假使客户端和服务端没有做任何约定，在我们这个网络版计算器中，客户端就有可能发送很多无效的信息，比如随便输入一段字符串。很显然，如果客户端不做任何处理直接发送给服务端，服务端虽然也能做一些手段去检测数据的合法性，但是那样太浪费时间了。

所以，为了能让整个交互过程有序且高效，客户端一定要与服务端达成某种协议，即规定发送时数据的格式与接收数据的格式。这样一来，客户端发送数据时按照约定好的格式打包好再发送，客户端就不需要考虑服务端怎么读取数据了，因为已经约定好了。相反，服务端接收数据包时按照约定，正确的实施解包的步骤就能读取到正确的数据，因为已经约定好了，客户端发送过来的数据一定是按照约定的格式存储的。
这就是约定，这就是协议。

序列化和反序列化

在上面我们谈到，协议是客户端与服务端约定好的某种存储数据的结构，说白了就是一个特定的结构体。但是无论是发送请求还是发送响应，都是需要通过网络来传输的，具体地说，在将传输给网络之前，我们要把上述包含数据的结构体进一步转换成可供网络传输的格式。同样的，从网络读取到数据后，在应用层还需要将其转换回来。前者就叫序列化，后者叫反序列化。
简单理解，序列化，就是网络化，就是把数据转换成某种在网络中传输的格式。反序列化，就是逆序列化过程

其中Jsoncpp库中提供了一些供序列化和反序列化的方法。

• 创建JSON对象

Json::Value root;

• 设置值

root["name"] = "John Doe";
root["age"] = 30;

• 访问值

td::string name = root["name"].asString();
int age = root["age"].asInt();

• 将数据序列化为字符串：

Json::Value root;
root["name"] = "joe";
root["sex"] = "男";
Json::FastWriter writer;
std::string s = writer.write(root);

理解 read、write、recv、send 和 tcp 为什么支持全双工

• 在每台主机上，TCP连接维护了两个缓冲区，分别用来发送数据和读取数据。所以发送数据和读取数据可以同时进行。因为这俩操作不是在同一个缓冲区进行的
• sockfd描述符本质就是一个文件描述符，但是它对应着读写两个缓冲区，操作系统会自动区分读和写操作，所以tcp通过一个sockfd就能进行读和写两种操作。
• 实际数据什么时候发，发多少，处理错误，由TCP协议控制，所以TCP叫做传输控制协议。

自定义协议网络计算器

根据前面的学习，我们可以自己简单模式一个用户层的协议，来实现网络版的计算器。
对于服务端，事件流程如下：

• 创建套接字
• 进入监听状态
• 获取连接
• 获取请求，将其反序列化，得到一个包含客户端数据的结构体
• 处理业务
• 将应答消息序列化，得到一个字符串，发送给客户端
• 上述步骤重复执行
• 关闭连接，关闭套接字

对于客户端，事件如下：

• 创建套接字
• 连接服务端
• 将序列化后的数据打包成一个请求发送给服务端
• 获取服务端的应答，将应答反序列化获取结果
• 关闭连接，关闭套接字

既然是自定义协议，那么我们可以规定请求和应答的数据格式为：len\r\n{json}\r\n。json其实就是一个用Json库处理序列化后的一个字符串（该字符串包含有效数据），len表示的是json字符串的长度。

中间的换行符用于区分字节流读取进度。假设读取到的数据流有一个换行符，说明该数据流一定包含len信息，拿到len信息后就可以再判断该数据流是否包含json字符串。

于是，在请求之前，我们需要先把有效数据转换成一个Json处理过的字符串，这叫做序列化。由于是网络中是字节流传输数据，为了辨别拿到的数据是否完整，我们还需要添加一些”标识“数据，这就是报头,整合起来就是一个报文。
完整代码可以去我gitee上去获取：点击查看
下面只给出序列化和反序列化实现模块

序列化和反序列化

#pragma once
#include <iostream>
#include <memory>
#include <string>
#include <jsoncpp/json/json.h>

static const std::string sep = "\r\n";

// 报文格式 len\r\n{joson}\r\n

// 将jsonstr格式的字符串加上报头
std::string Encode(const std::string &jsonstr)
{
    int len = jsonstr.size();
    std::string lenstr = std::to_string(len);
    return lenstr + sep + jsonstr + sep;
}

// 将接收到的数据中的joson段提取出来
std::string Decode(std::string &packagestream)
{
    // 分析
    auto pos = packagestream.find(sep);
    if (pos == std::string::npos)
    {
        return std::string();
    }

    std::string lenstr = packagestream.substr(0, pos);
    int len = std::stoi(lenstr);
    // 计算一个完整的报文应该多长
    int total = lenstr.size() + 2 * sep.size() + len;
    if (packagestream.size() < total)
    {
        return std::string();
    }
    // 提取
    std::string josonstr = packagestream.substr(pos + sep.size(), len);
    packagestream.erase(0, total);
    return josonstr;
}

class Request
{

public:
    Request() {}
    ~Request() {}

    Request(int x, int y, char oper)
        : _x(x), _y(y), _oper(oper)
    {
    }

    // 序列化
    bool Serialize(std::string *out)
    {
        // 使用joson库
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["oper"] = _oper;
        Json::FastWriter write;
        std::string s = write.write(root);
        *out = s;
        return true;
    }
    // 反序列化
    bool Deserialize(const std::string &josonstr)
    {
        Json::Value root;
        Json::Reader reader;
        bool res = reader.parse(josonstr, root); // 将josonstr的内容提取到root中
        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _oper = root["oper"].asInt();
        return res;
    }

    void Print()
    {
        std::cout << _x << std::endl;
        std::cout << _y << std::endl;
        std::cout << _oper << std::endl;
    }

    int X()
    {
        return _x;
    }
    int Y()
    {
        return _y;
    }
    char Oper()
    {
        return _oper;
    }

    void SetValue(int x, int y, char oper)
    {
        _x = x;
        _y = y;
        _oper = oper;
    }

private:
    int _x;
    int _y;
    char _oper;
};

// 应答
class Response
{
public:
    ~Response() {}
    Response()
        : _result(0), _code(0), _desc("success")
    {
    }
    // 序列化
    bool Serialize(std::string *out)
    {
        // 使用joson库
        Json::Value root;
        root["result"] = _result;
        root["code"] = _code;
        root["desc"] = _desc;
        Json::FastWriter write;
        std::string s = write.write(root);
        *out = s;
        return true;
    }
    // 反序列化
    bool Deserialize(const std::string &josonstr)
    {
        Json::Value root;
        Json::Reader reader;
        bool res = reader.parse(josonstr, root); // 将josonstr的内容提取到root中
        _result = root["result"].asInt();
        _code = root["code"].asInt();
        _desc = root["desc"].asString();
        return res;
    }
    void PrintResult()
    {
        std::cout << "result: " << _result << " code: " << _code << " desc: " << _desc << std::endl;
    }

    int _result;
    int _code;
    std::string _desc;
};

class Factory
{
public:
    static std::shared_ptr<Request> BuildRequestDefault()
    {
        return make_shared<Request>();
    }

    static std::shared_ptr<Response> BuildResponseDefault()
    {
        return make_shared<Response>();
    }
};