应用层自定义协议与序列化

一、理解应用层

上一篇文章http://t.csdnimg.cn/931k6简单介绍了如何写tcp / udp 网络服务，但是其实始终是在应用层。

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

二、再谈协议

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

但是协议能像字符串一样，直接发送结构体吗？

不行，从技术上，每一种操作系统，语言对于结构体的定义是不一样的。从业务上，协议随时可能更改，可扩展性不好。

三、tcp协议总结结论

1、tcp：传输控制协议，决定了数据什么时候发，怎么发的问题。

2、accept函数返回一个sockfd, 代表一个链接，一个链接有两个缓冲区。

3、read, write, recv, send 本质都是拷贝缓冲区内容。

4、发送数据的本质：从发送方的发送缓冲区把数据通过协议栈和网络拷贝到接收方的接受缓冲区。

5、有人发数据，有人收数据，本质就是生产消费模型

6、tcp支持全双工的本质：读写数据在不同缓冲区

7、为什么IO会阻塞？本质维护缓冲区读写规则，维护同步关系。

8、面向字节流：客户端发的不一定是服务器收的。如何保证读到一个完整的请求？分割完整报文

四、简单实现tcp协议

1、实现思路

实现一个协议我们需要考虑两个部分：定协议（设计协议结构体）和设计协议报头和报文完整格式

（1）定协议需要我们明确请求和应答的结构体中具体的字段。并对请求和应答报文进行序列化和反序列化。包括服务器对于客户端发来请求的反序列化，服务器要发送给客户端应答的序列化，客户端对于服务器发来的应答的反序列化和客户端发给服务器请求的序列化。

（2）为了完整地分割报文，报头一定要有报文正文的长度，报头与报文正文的分隔符。

2、序列化反序列化库 Jsoncpp

Jsoncpp 是一个用于处理 JSON 数据的 C++ 库。它提供了将 JSON 数据序列化为字 符串以及从字符串反序列化为 C++ 数据结构的功能。Jsoncpp 是开源的，广泛用于各种需要处理 JSON 数据的 C++ 项目中。

安装：ubuntu：sudo apt-get install libjsoncpp-dev

3、序列化

序列化指的是将数据结构或对象转换为一种格式，以便在网络上传输或存储到文件中。

最简单的Json序列化方式：

（1）定义 Value 对象 root

（2）把属性和属性内容填入 root

（3）定义 FastWriter 对象 writer

（4）调用 writer 对象方法 write(root)，把 root 中的内容自动序列化，用 s 接受。

4、反序列化

反序列化指的是将序列化后的数据重新转换为原来的数据结构或对象。

最简单的Json反序列化方式：
（1）定义 Value 对象 root

（2）定义 Reader 对象 reader

（3）调用 reader 对象方法 parse(in, root)，把序列化之后的字符串 in 反序列化给 root 

（4）读取 root 中的属性和属性内容

root 是能接受任何类型的万能对象

5、举例

#pragma once

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

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

// 设计一下协议的报头和报文的完整格式
// "len"\r\n"{json}"\r\n --- 完整的报文， len 有效载荷的长度！
// \r\n: 区分len 和 json 串
// \r\n: 暂是没有其他用，打印方便，debug
// 添加报头
std::string Encode(const std::string &jsonstr)
{
    int len = jsonstr.size();
    std::string lenstr = std::to_string(len);
    return lenstr + sep + jsonstr + sep;
}
// 不能带const
// "le
// "len"
// "len"\r\n
// "len"\r\n"{json}"\r\n (]
// "len"\r\n"{j
// "len"\r\n"{json}"\r\n"len"\r\n"{
// "len"\r\n"{json}"\r\n
// "len"\r\n"{json}"\r\n"len"\r\n"{json}"\r\n"len"\r\n"{json}"\r\n"len"\r\n"{json}"\r
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() + len + 2 * sep.size();
    if (packagestream.size() < total)
        return std::string();

    // 提取
    std::string jsonstr = packagestream.substr(pos + sep.size(), len);
    packagestream.erase(0, total);
    return jsonstr;
}

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

    // 客户端发请求做序列化
    bool Serialize(std::string *out)
    {
        // 1. 使用现成的库, xml, json(jsoncpp), protobuf
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["oper"] = _oper;
        Json::FastWriter writer;
        // Json::StyledWriter writer;
        std::string s = writer.write(root);
        *out = s;
        return true;
    }

    // 服务器接受请求做反序列化
    bool Deserialize(const std::string &in)
    {
        Json::Value root;
        Json::Reader reader;
        bool res = reader.parse(in, root);

        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _oper = root["oper"].asInt();

        return true;
    }
    void Print()
    {
        std::cout << _x << std::endl;
        std::cout << _y << std::endl;
        std::cout << _oper << std::endl;
    }
    ~Request()
    {
    }
    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; // + - * / % // x oper y
};

// struct request resp={30, 0};
class Response
{
public:
    Response() : _result(0), _code(0), _desc("success")
    {
    }

    // 服务器发送应答做序列化
    bool Serialize(std::string *out)
    {
        // 1. 使用现成的库, xml, json(jsoncpp), protobuf
        Json::Value root;
        root["result"] = _result;
        root["code"] = _code;
        root["desc"] = _desc;
        Json::FastWriter writer;
        // Json::StyledWriter writer;
        std::string s = writer.write(root);
        *out = s;
        return true;
    }

    // 客户端接受应答做反序列化
    bool Deserialize(const std::string &in)
    {
        Json::Value root;
        Json::Reader reader;
        bool res = reader.parse(in, root);
        if (!res)
            return false;
        _result = root["result"].asInt();
        _code = root["code"].asInt();
        _desc = root["desc"].asString();

        return true;
    }
    void PrintResult()
    {
        std::cout << "result: " << _result << ", code: " << _code << ", desc: " << _desc << std::endl; 
    }
    ~Response()
    {
    }

public:
    int _result;
    int _code; // 0: success, 1: div zero 2. 非法操作
    std::string _desc;
};

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