首页 前端知识 【计网】从零开始掌握序列化 --- JSON实现协议 设计 传输\会话\应用 三层结构

【计网】从零开始掌握序列化 --- JSON实现协议 设计 传输\会话\应用 三层结构

2024-09-27 09:09:32 前端知识 前端哥 145 983 我要收藏

在这里插入图片描述

唯有梦想才配让你不安, 唯有行动才能解除你的不安。 --- 卢思浩 ---

从零开始掌握序列化

  • 1 知识回顾
  • 2 序列化与编写协议
    • 2.1 使用Json进行序列化
    • 2.2 编写协议
  • 3 封装IOService
  • 4 应用层 --- 网络计算器
  • 5 总结

1 知识回顾

上一篇文章我们讲解了协议的本质是双方能够看到的结构化数据。并通过传输层的底层理解了为什么read系列函数时全双工支持同时读写的:TCP传输层有两个缓冲区,分别接收和发送。最重要的是我们将TCP通信的代码进行的重构:

  1. 我们将Socket通信单独封装为一个类,负责Socket套接字的创建,bind绑定服务器端口号,进入监听模式…工作,基类Socket并不进行定义,只进行声明!具体实现由派生类TcpServer和UdpServer来进行
  2. TcpServer继承Socket类的所有方法,然后进行具体的函数定义!
  3. 上层的TcpServer直接底层使用TcpSocket对象就可以完成Socket系列操作,十分方便!

接下来我们要实现是这样的一个结构:
在这里插入图片描述
通信过程整体分为三层

  1. 传输层TcpServer:负责从Socket文件中获取链接,传输层不需要进行IO,获取到连接就让会话层通过连接获取数据!
  2. 会话层Service:根据传输层给的连接,从Sockfd文件中读取数据,解析出报文结构中的数据字符串,然后通过协议分离出结构化数据。该层只负责数据的解析,数据的处理交给应用层进行!
  3. 应用层Process:应用层是具有的业务逻辑,根据会话层解析出的数据,进行数据处理!

这样是一个非常非常优雅的封装操作!!!

2 序列化与编写协议

2.1 使用Json进行序列化

协议是IO的基础,只有协议确定下来,才可以进行通信。
我们这里想要实现一个网络计算器的应用,所以协议分为了两个类:Request和Response。分别作为传入的数据和传出的数据:

  1. Request:两个数字和一个运算符
  2. Response:结果数字 , 错误码 ,退出信息

他们是作为结构化的数据进行传输,那么想要进行传输就来到了最重要的部分序列化与反序列化!序列化与反序列化可以使用第三方库也可以自己进行编写。这里我们先使用第三方的Json库进行实现:

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

  1. 简单易用: Jsoncpp 提供了直观的 API, 使得处理 JSON 数据变得简单。
  2. 高性能: Jsoncpp 的性能经过优化, 能够高效地处理大量 JSON 数据。
  3. 全面支持: 支持 JSON 标准中的所有数据类型, 包括对象、 数组、 字符串、 数字、 布尔值和 null。
  4. 错误处理: 在解析 JSON 数据时, Jsoncpp 提供了详细的错误信息和位置, 方便开发者调试

在Linux中使用需要进行安装对应的JSON库:

ubuntu:sudo apt-get install libjsoncpp-dev
Centos: sudo yum install jsoncpp-devel

安装之后就可以进行使用了:

使用起来是十分方便的:

  1. Json::Value是最重要的类,这是对Json数据结构进程操作和表示的关键类
  2. 建立好类Json::Value之后就可以通过[ ]操作root["x"] = _x;,像这样就可以进行赋值
  3. 将Json数据结构转换为字符串依靠 Json::FastWriter 或 Json::StreamWriter都可以转换成字符串
Json::StyledWriter writer;
std::string s = writer.write(root)
  1. 通过Json::Reader可以快速将字符串反序列化得到Json结构!
bool parsingSuccessful = reader.parse(json_string,root);
// 访问 JSON 数据 
std::string name = root["name"].asString();
int age = root["age"].asInt(); std::string city =
root["city"].asString();

通过这样就就可以简洁的完成序列化与反序列化的工作!

2.2 编写协议

根据我们的需求在加入Json操作我们就可以把协议写出来,代码虽然很长但是很好理解:

  1. Request类中需要根据 int x , int y , char oper进行序列化生成字符串,也要能够通过字符串反序列化得到三个变量
  2. Response类中需要根据 int res , int code , std::string desc进行序列化生成字符串,也要能够通过字符串反序列化得到三个变量
#pragma once
#include <jsoncpp/json/json.h>
#include <string>
// 协议就是双方都认识的结构化数据
// "len"\r\n"{json}"\r\n
const std::string sep = "\r\n";

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

    bool Serialize(std::string *out)
    {
        // 使用现成的 Json 库
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["oper"] = _oper;
        Json::FastWriter writer;

        std::string s = writer.write(root);
        *out = s;
        return true;
    }
    bool Deserialize(std::string &in)
    {
        Json::Value root;    // 创建json对象
        Json::Reader reader; // 读取
        bool res = reader.parse(in, root);
        if (res == false)
            return false;
        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _oper = root["oper"].asInt();
        return true;
    }
    int X() { return _x; }
    int Y() { return _y; }
    char Oper() { return _oper; }

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

struct Response
{
    Response() {}
    Response(int res, int code, std::string desc) : _res(res), _code(code), _desc(desc)
    {
    }
    ~Response()
    {
    }
    bool Serialize(std::string *out)
    {
        // 使用现成的 Json 库
        Json::Value root;
        root["res"] = _res;
        root["code"] = _code;
        root["desc"] = _desc;
        Json::FastWriter writer;

        std::string s = writer.write(root);
        *out = s;
        return true;
    }
    bool Deserialize(std::string &in)
    {
        Json::Value root;    // 创建json对象
        Json::Reader reader; // 读取
        bool res = reader.parse(in, root);
        if (res == false)
            return false;
        _res = root["res"].asInt();
        _code = root["code"].asInt();
        _desc = root["desc"].asInt();
        return true;
    }
    int _res;
    int _code; // 退出码 0:success 1:div zero 2:非法操作
    std::string _desc;
};

看一下效果:
在这里插入图片描述

完成了基础的序列化和反序列化之后,我们就可以做到从sockfd流中读取数据了吗??不可以!因为不知道Json字符串的长度,就不知道应该读取多少字节!这样可就做不到正确的从数据中获取json字符串!

所以我们还有做一步特殊处理:

  • 需要对生成的Json字符串加入报头len记录json字符串的长度,中间以sep分隔符分割!
  • 需要对获得到的数据进行解析,去除报头得到一个Json字符串!
// "len"\r\n"{json}"\r\n
const std::string sep = "\r\n";
// 加入报头
std::string Encode(const std::string &jsonstr)
{
    int len = jsonstr.size();
    std::string lenstr = std::to_string(len);
    return lenstr + sep + jsonstr + sep;
}

std::string Decode(std::string &packagestream)
{
    auto pos = packagestream.find(sep);
    if (pos == std::string::npos)
        return std::string();
    // 获取到len
    std::string lenstr = packagestream.substr(0, pos);
    int len = std::stoi(lenstr);
    //算上报头的完整长度!
    int total = lenstr.size() + len + 2 * sep.size();
    if (total > packagestream.size())
        return std::string();
    // 到这里说明可以读取完整数据
    std::string jsonstr = packagestream.substr(pos + sep.size(), len);
    packagestream.erase(total);
    return jsonstr;
}

经过这样的操作,可以保证:

  • 上层想要发送数据时,可以将数据包装为json字符串,并加入报头形成完整报文!
  • 上层获取数据进行反序列化时可以获取到完整的json字符串!并成功解析为数据

3 封装IOService

将来我们的线程会执行将会执行这个回调函数方法,现在我们不再需要TcpServer来进行IO操作,TcpServer只负责进行获取链接,获取到连接后通过ThreadData结构体将数据传到线程中的回调函数中:

	class ThreadData
    {
    public:
        SockSPtr _sockfd;
        InetAddr _addr;
        TcpServer *_this;

    public:
        ThreadData(SockSPtr sockfd, InetAddr addr, TcpServer *p) : _sockfd(sockfd),
                                                                   _this(p),
                                                                   _addr(addr)
        {
        }
    };

在回调函数Execute中:

// 注意设置为静态函数 , 不然参数默认会有TcpServer* this!!!
    static void *Execute(void *args)
    {
        pthread_detach(pthread_self()); // 线程分离!!!
        // 执行Service函数
        TcpServer::ThreadData *td = static_cast<TcpServer::ThreadData *>(args);
        td->_this->_service(td->_sockfd, td->_addr);
        td->_sockfd->Close();
        delete td;
        return nullptr;
    }

就可以解析出来套接字文件描述符和客户端信息了!解析出信息之后就去执行会话层的回调函数进行IO操作:

  1. Service内部只有一个成员变量,就是应用层的回调函数,Service解析出来数据之后就可以传入到应用层中进行使用
  2. IO中主要需要进行从sockfd文件中获取数据,然后通过协议进行解析,获取到真正的数据。再调用回调函数对数据进行操作!得到结果之后就可以进行序列化,加入报头,再发送给客户端!
  3. 应用层的操作逻辑,Service并不关心,只要回调函数可以传回需要的结构体就可以!
class Service
{
public:
    Service(process_t process) : _process(process)
    {
    }
    void IOExecute(SockSPtr sock, InetAddr &addr)
    {
        LOG(INFO, "service start!!!\n");
        std::string message;
        while (true)
        {
            // 1. 进行读取
            ssize_t n = sock->Recv(&message);
            if (n < 0)
            {
                LOG(ERROR, "read error: %s\n", addr.AddrStr().c_str());
                break;
            }
            // 此时获取到客户端发送的数据
            // 但是不能保证是否是完整的报文
            // 2.报文解析
            std::string str = Decode(message); // 通过去报头获取报文
            if (str.empty())
                continue; // 说明没有完整的报文!
            // 到这里说明有完整的报文!!!
            auto req = Factory::BuildRequestDefault();
            // 3.反序列化初始化Request
            req->Deserialize(str);
            auto res = Factory::BuildResponseDefault();
            // 4.业务处理
            res = _process(req);
            // 5.进行序列化处理
            std::string ret;
            res->Serialize(&ret);
            // 6.加入报头
            Encode(ret);
            // 7.将获取的数据发送回去
            sock->Send(ret);
        }
    }
    ~Service()
    {
    }

private:
    process_t _process;
};

4 应用层 — 网络计算器

应用层根据具体需要可以随时改变,我这里以网络计算器为例子进行书写:

#include "Protocol.hpp"
class NetCal
{
public:
    NetCal() {}
    std::shared_ptr<Response> Calculator(std::shared_ptr<Request> req)
    {
        std::shared_ptr<Response> res = Factory::BuildResponseDefault();

        switch (req->Oper())
        {
        case '+':
            res->_res = req->X() + req->Y();
            res->_code = 0;
            res->_desc = "success";
            break;
        case '-':
            res->_res = req->X() - req->Y();
            res->_code = 0;
            res->_desc = "success";
            break;
        case '*':
            res->_res = req->X() * req->Y();
            res->_code = 0;
            res->_desc = "success";
            break;
        case '/':
        {
            if (req->Y() == 0)
            {
                res->_code = 1;
                res->_desc = "div zero";
            }
            res->_res = req->X() / req->Y();
            res->_code = 0;
            res->_desc = "success";
        }
        break;
        case '%':
        {
            if (req->Y() == 0)
            {
                res->_code = 1;
                res->_desc = "mod zero";
            }
            res->_res = req->X() % req->Y();
            res->_code = 0;
            res->_desc = "success";
        }
        break;
        default:
            res->_code = 2;
            res->_desc = "illegal operations";
            break;
        }
        return res;
    }
    ~NetCal() {}
};

逻辑很简单不在多加赘述!

5 总结

现在我们的程序分为了三层结构:
在这里插入图片描述
我们做到了最大程度的解耦!

  • 传输层只负责获取链接,我们应用层要进行什么工作,只要是进行网络通信传输层的工作就是唯一的!
  • 会话层进行IO操作!只要传输层提供了链接,会话层就可以获取数据,然后根据具体的协议进行数据的解析工作。协议根据实际情况改变,但是会话层的工作逻辑是不变的!
  • 应用层只管进行数据处理即可,什么但不不需要考虑!完成工作后返回给会话层数据即可!

这样的结构逻辑十分清晰,并且解耦的非常优雅,值得反复品味!!!

转载请注明出处或者链接地址:https://www.qianduange.cn//article/18612.html
标签
评论
发布的文章
大家推荐的文章
会员中心 联系我 留言建议 回顶部
复制成功!