【网络】自定义协议——序列化和反序列化

news2024/11/26 0:57:48

> 作者:დ旧言~
> 座右铭:松树千年终是朽,槿花一日自为荣。

> 目标:了解什么是序列化和分序列,并且自己能手撕网络版的计算器。

> 毒鸡汤:有些事情,总是不明白,所以我不会坚持。早安!

> 专栏选自:网络

> 望小伙伴们点赞👍收藏✨加关注哟💕💕

​​

 一、前言

前面我们已经学习了网络的基础知识,对网络的基本框架已有认识,算是初步认识到网络了,如果上期我们的学习网络是步入基础知识,那么这次学习的板块就是基础知识的实践,我们今天的板块是学习网络重要之一,学习完这个板块对虚幻的网络就不再迷茫!!!

 二主体

学习【网络】自定义协议——序列化和反序列化咱们按照下面的图解:

2.1 自定义协议(应用层)

概念:

网络协议:是通信计算机双方必须共同遵从的一组约定,为了使数据在网络上能够从源地址到目的地址,网络通信的参与方必须遵循相同的规则,因此我们将这套规则称为协议,协议最终需要通过计算机语言的方式表示出来。

应用层和传输层的概述:

  • 应用层:位于网络协议的最高层,直接为用户提供服务。这一层的协议如HTTP、FTP、SMTP等,负责处理特定应用程序的数据传输和通信。
  • 传输层:位于应用层之下,网络层之上。它提供端到端的通信服务,确保数据在网络中的可靠传输。传输层协议如TCP和UDP,管理数据包的顺序和流量控制。

应用层和传输层的区别:

  • 目的:应用层的目的是为了支持各种应用程序的特定需求,而传输层则致力于提供通用的通信服务。
  • 可靠性:应用层协议可以根据应用程序的需求提供可靠或不可靠的服务。而传输层协议,如TCP,保证数据包的顺序和完整性,提供可靠的端到端通信。
  • 数据传输方式:应用层协议如HTTP、FTP等,通常基于TCP或UDP传输数据。而传输层协议则负责管理这些数据包的发送和接收。
  • 服务类型:应用层协议服务于各种类型的应用,如网页浏览、电子邮件、文件传输等。而传输层协议主要为应用程序提供通用的数据传输服务。

应用层和传输层的关系:

应用层和传输层在网络通信中是紧密相关的。传输层提供了一种可靠的数据传输机制,确保数据在网络中的正确传输,而应用层协议定义了特定应用程序的数据格式和通信规则。两者之间的协同工作使得应用程序能够有效地进行数据交换和通信。

例如,当我们使用浏览器访问一个网页时,HTTP(应用层协议)定义了请求和响应的格式,而TCP(传输层协议)确保了数据的可靠传输。两者共同作用,使得我们能够顺利地浏览网页。

2.2 序列化和反序列化


2.2.1 结构化数据

概念说明:

如果需要传输的数据是字符串,那么我们可以直接将这个字符串发送到网络当中。但是如果我们传输的是一些结构化的数据,此时就不能直接将这些数据发送到网络当中。

如果服务器将这些结构化的数据单独一个一个发送到网络当中,那么服务器从网络当中获取这些数据时也只能一个一个获取,并且结构化的数据往往具有特定的格式和规范,例如数据库表格或者特定的数据模型。如果直接将这些数据发送到网络,服务端可能需要处理大量复杂的格式转换和数据清洗工作,而且还有可能会影响数据的正确性。所以客户端最好把这些结构化的数据打包后统一发送到网络当中,此时服务端每次从网络当中获取到的就是一个完整的请求数据。

常见的打包方式:

  •  将结构化的数据组合成一个字符串

 客户端可以按照某种方式将这些结构化的数据组合成一个字符串,然后将该字符串发送到网络当中,当服务器接收到这个字符串时,以相同的方式将这个字符串进行解析。就可以从这个字符串中提取出这些结构化的数据。 

  • 定制结构体 + 序列化与反序列化

 客户端可以定制一个结构体,将需要交互的信息定义到这个结构体当中。客户端发送数据时先对数据进行序列化,服务端接收到数据后在对其进行反序列化,此时服务端就能得到客户端发送过来的结构体了。  

2.2.2 序列化和反序列化

概念:

  • 序列化: 将对象的状态信息转换为可以存储或传输的形式的过程。
  • 反序列化: 将字节序列恢复为的过程。

补充说明:

OSI七层模型中表示层的作用就是,实现设备固有数据格式和网络标准数据格式的转换。其中设备固有的数据格式指的是数据在应用层上的格式,而网络标准数据格式则指的是序列化之后可以进行网络传输的数据格式。

序列化和反序列化的目的:

  • 序列化的目的是方便网络数据的发送和接收,无论何种类型的数据,经过序列化后都变成了二进制序列,此时底层在进行网络传输时看到的都是二进制序列。
  • 序列化后的二进制序列只有在网络传输时能够被底层识别,上层应用是无法识别序列化后的二进制数据的,因此需要将从网络中获取到的数据进行反序列化,将二进制序列的数据转换成应用层能够识别的数据格式。

  

2.3 网络版计算器


2.3.1 协议定制

请求数据和响应数据:(实现一个请求结构体和一个响应结构体)

  • 请求数据结构体:包含两个操作数和一个操作符,操作数表示需要进行计算的两个数,操作符表示是要进行 +-*/ 中的哪一个操作。
  • 响应数据结构体:需要包含一个计算结果和一个状态码,表示本次计算的结果和计算状态。

态码所表示的含义:

  • 0 表示计算成功
  • 1 表示出现除0错误
  • 2 表示模0错误
  • 3 表示非法计算

因为协议定制好以后要被客户端和服务端同时遵守,所以需要将它写到一个头文件中,同时被客户端和服务端包含该头文件:

// 请求
class Request
{
public:
	Request()
	{}
	Request(int x, int y, char op):_x(x), _y(y), _op(op)
	{}
public:	
	int _x;
	int _y;
	char _op;
};

// 响应
class Response
{
public:
	Response()
	{}
	Response(int result, int code):_result(result), _code(code)
	{}
public:
	int _result;
	int _code;
};

同时,最好还是把协议中的分隔符给定义出来,方便后续统一使用或更改:

#define CRLF "\t"   //分隔符
#define CRLF_LEN strlen(CRLF) //分隔符长度
#define SPACE " "   //空格
#define SPACE_LEN strlen(SPACE) //空格长度
 
#define OPS "+-*/%" //运算符

2.3.2 编码解码

编码的是往字符串的开头添加上长度和分隔符:

长度\t序列化字符串\t

解码就是将长度和分隔符去掉,只解析出序列化字符串:

序列化字符串

编码解码的整个过程在注释里面都写明了 为了方便请求和回应去使用,直接放到外头,不做类内封装:

//参数len为in的长度,是一个输出型参数。如果为0代表err
std::string decode(std::string& in,size_t*len)
{
    assert(len);//如果长度为0是错误的
    
    // 1.确认in的序列化字符串完整(分隔符)
    *len=0;
 
    size_t pos = in.find(CRLF);//查找\t第一次出现时的下标
    //查找不到,err
    if(pos == std::string::npos){
        return "";//返回空串
    }
   
    // 2.有分隔符,判断长度是否达标
    // 此时pos下标正好就是标识大小的字符长度
    std::string inLenStr = in.substr(0,pos);//从下标0开始一直截取到第一个\t之前
 
    //到这里我们要明白,我们这上面截取的是最开头的长度,也就是说,我们截取到的一定是个数字,这个是我们序列化字符的长度
    
    size_t inLen = atoi(inLenStr.c_str());//把截取的这个字符串转int,inLen就是序列化字符的长度
 
    //传入的字符串的长度 - 第一个\t前面的字符数 - 2个\t
    size_t left = in.size() - inLenStr.size()- 2*CRLF_LEN;//原本预计的序列化字符串长度
    if(left<inLen){//真实的序列化字符串长度和预计的字符串长度进行比较
        return ""; //剩下的长度(序列化字符串的长度)没有达到标明的长度
    }
 
    // 3.走到此处,字符串完整,开始提取序列化字符串
    std::string ret = in.substr(pos+CRLF_LEN,inLen);//从pos+CRLF_LEN下标开始读取inLen个长度的字符串——即序列化字符串
 
    *len = inLen;
 
    // 4.因为in中可能还有其他的报文(下一条)
    // 所以需要把当前的报文从in中删除,方便下次decode,避免二次读取
    size_t rmLen = inLenStr.size() + ret.size() + 2*CRLF_LEN;//长度+2个\t+序列字符串的长度
    in.erase(0,rmLen);//移除从索引0开始长度为rmLen的字符串
 
    // 5.返回
    return ret;
}
 
//编码不需要修改源字符串,所以const。参数len为in的长度
std::string encode(const std::string& in,size_t len)
{
    std::string ret = std::to_string(len);//将长度转为字符串添加在最前面,作为标识
    ret+=CRLF;
    ret+=in;
    ret+=CRLF;
    return ret;
}

2.3.3 request(请求)


2.3.3.1 构造

功能说明:

用户可能输入x+y,x+ y,x +y,x + y等等格式

这里还需要注意,用户的输入不一定是标准的X+Y,里面可能在不同位置里面会有空格。为了统一方便处理,在解析之前,最好先把用户输入内的空格给去掉!

代码呈现:

class Request
{
public:
    // 将用户的输入转成内部成员
    // 用户可能输入x+y,x+ y,x +y,x + y等等格式
    // 提前修改用户输入(主要还是去掉空格),提取出成员
    Request(std::string in,bool* status)
        :_x(0),_y(0),_ops(' ')
    {
        rmSpace(in);//删除空格
 
        // 这里使用c的字符串,因为有strtok
        char buf[1024];
 
        // 打印n个字符,多的会被截断
        snprintf(buf,sizeof(buf),"%s",in.c_str());//将报文存到buf里面去,方便使用strtok
 
        char* left = strtok(buf,OPS);//left变成从字符串in的最开始到第一个运算符的这段字符串——即左操作数
        if(!left){//找不到
            *status = false;
            return;
        }
        
        //right变成从第一个运算符开始,到第二个运算符中间的这段字符串——即右操作数
        char*right = strtok(nullptr,OPS);//在上次寻找的基础上继续寻找
        if(!right){//找不到
            *status = false;
            return;
        }
 
        // x+y, strtok会将+设置为\0
        char mid = in[strlen(left)];//截取出操作符
        //这是在原字符串里面取出来,buf里面的这个位置被改成\0了
 
        _x = atoi(left);
        _y = atoi(right);
        _ops = mid;
        *status=true;
    }
 
public:
    int _x;
    int _y;
    char _ops;
};
2.3.3.2 序列化

功能说明:

解析出成员以后,我们要做的就是对成员进行序列化,将其按指定的位置摆成一个字符串。这里采用了输出型参数的方式来序列化字符串,也可以改成用返回值的方式来操作。

代码呈现:

// 序列化 (入参应该是空的)
void serialize(std::string& out)
{
    // x + y
    out.clear(); // 序列化的入参是空的
    out+= std::to_string(_x);
    out+= SPACE;
    out+= _ops;//操作符不能用tostring,会被转成ascii
    out+= SPACE;
    out+= std::to_string(_y);
    // 不用添加分隔符(这是encode要干的事情)
}
2.3.3.3 反序列化

说明:

在客户端和服务端都需要使用request,客户端进行序列化,服务端对接收到的结果利用request进行反序列化。request只关注于对请求的处理,而不处理服务器的返回值。

代码呈现:

// 反序列化
bool deserialize(const std::string &in)
{
    // x + y 需要取出x,y和操作符
    size_t space1 = in.find(SPACE); //第一个空格
    if(space1 == std::string::npos) //没找到
    {
        return false;
    }
 
    size_t space2 = in.rfind(SPACE); //第二个空格
    if(space2 == std::string::npos)  //没找到
    {
        return false;
    }
 
    // 两个空格都存在,开始取数据
    std::string dataX = in.substr(0,space1);
    std::string dataY = in.substr(space2+SPACE_LEN);//默认取到结尾
    
    std::string op = in.substr(space1+SPACE_LEN,space2 -(space1+SPACE_LEN));
    if(op.size()!=1)
    {
        return false;//操作符长度有问题
    }
 
    //没问题了,转内部成员
    _x = atoi(dataX.c_str());
    _y = atoi(dataY.c_str());
    _ops = op[0];
    return true;
}

2.3.4 response(响应)


2.3.4.1 构造

说明:

返回值的构造比较简单,因为是服务器处理结果之后的操作;这些成员变量都设置为了公有,方便后续修改。

代码呈现:

class Response//服务端必须回应
{
    Response(int code=0,int result=0)
        :_exitCode(code),_result(result)
    {}
 
public:
	int _exitCode; //计算服务的退出码
	int _result;  // 结果
};
2.3.4.2 序列化

功能说明:

解析出成员以后,我们要做的就是对成员进行序列化,将其按指定的位置摆成一个字符串。这里采用了输出型参数的方式来序列化字符串,也可以改成用返回值的方式来操作。

代码呈现:

class Response//服务端必须回应
{
    Response(int code=0,int result=0)
        :_exitCode(code),_result(result)
    {}
 
    // 入参是空的
    void serialize(std::string& out)
    {
    // code ret
        out.clear();
        out+= std::to_string(_exitCode);
        out+= SPACE;
        out+= std::to_string(_result);
        out+= CRLF;
    }
 
 
public:
	int _exitCode; //计算服务的退出码
	int _result;  // 结果
};
2.3.4.3 反序列化

说明:

响应的反序列化只需要处理一个空格,相对来说较为简单。

代码呈现:

 
class Response//服务端必须回应
{
    Response(int code=0,int result=0)
        :_exitCode(code),_result(result)
    {}
 
    //序列化
    void serialize(std::string& out)
    {
    // code ret
        out.clear();
        out+= std::to_string(_exitCode);
        out+= SPACE;
        out+= std::to_string(_result);
        out+= CRLF;
    }
    
    // 反序列化
    bool deserialize(const std::string &in)
    {
        // 只有一个空格
        size_t space = in.find(SPACE);//寻找第一个空格的下标
        if(space == std::string::npos)//没找到
        {
            return false;
        }
 
        std::string dataCode = in.substr(0,space);
        std::string dataRes = in.substr(space+SPACE_LEN);
 
        _exitCode = atoi(dataCode.c_str());
        _result = atoi(dataRes.c_str());
        return true;
    }
 
 
public:
	int _exitCode; //计算服务的退出码
	int _result;  // 结果
};

2.3.5 完整的自定义协议代码

使用说明:

 客户端发送的消息是使用Request来进行序列化和反序列化的: 

  • 客户端发消息时:客户端先序列化,再编码
  • 服务端收消息时,服务端先解码,再反序列化

服务端发送的消息是使用Response来进行序列化和反序列化的:

  • 服务端发消息时:客户端先序列化,再编码
  • 客户端收消息时,服务端先解码,再反序列化

代码呈现:Serialization.hpp

#pragma
#define CRLF "\t"               // 分隔符
#define CRLF_LEN strlen(CRLF)   // 分隔符长度
#define SPACE " "               // 空格
#define SPACE_LEN strlen(SPACE) // 空格长度
#define OPS "+-*/%"             // 运算符
 
#include <iostream>
#include <string>
#include <cstring>
#include<assert.h>
 
//参数len为in的长度,是一个输出型参数。如果为0代表err
std::string decode(std::string& in,size_t*len)
{
    assert(len);//如果长度为0是错误的
    
    // 1.确认in的序列化字符串完整(分隔符)
    *len=0;
 
    size_t pos = in.find(CRLF);//查找\t第一次出现时的下标
    //查找不到,err
    if(pos == std::string::npos){
        return "";//返回空串
    }
   
    // 2.有分隔符,判断长度是否达标
    // 此时pos下标正好就是标识大小的字符长度
    std::string inLenStr = in.substr(0,pos);//从下标0开始一直截取到第一个\t之前
 
    //到这里我们要明白,我们这上面截取的是最开头的长度,也就是说,我们截取到的一定是个数字,这个是我们序列化字符的长度
    
    size_t inLen = atoi(inLenStr.c_str());//把截取的这个字符串转int,inLen就是序列化字符的长度
 
    //传入的字符串的长度 - 第一个\t前面的字符数 - 2个\t
    size_t left = in.size() - inLenStr.size()- 2*CRLF_LEN;//原本预计的序列化字符串长度
    if(left<inLen){//真实的序列化字符串长度和预计的字符串长度进行比较
        return ""; //剩下的长度(序列化字符串的长度)没有达到标明的长度
    }
 
    // 3.走到此处,字符串完整,开始提取序列化字符串
    std::string ret = in.substr(pos+CRLF_LEN,inLen);//从pos+CRLF_LEN下标开始读取inLen个长度的字符串——即序列化字符串
 
    *len = inLen;
 
    // 4.因为in中可能还有其他的报文(下一条)
    // 所以需要把当前的报文从in中删除,方便下次decode,避免二次读取
    size_t rmLen = inLenStr.size() + ret.size() + 2*CRLF_LEN;//长度+2个\t+序列字符串的长度
    in.erase(0,rmLen);//移除从索引0开始长度为rmLen的字符串
 
    // 5.返回
    return ret;
}
 
//编码不需要修改源字符串,所以const。参数len为in的长度
std::string encode(const std::string& in,size_t len)
{
    std::string ret = std::to_string(len);//将长度转为字符串添加在最前面,作为标识
    ret+=CRLF;
    ret+=in;
    ret+=CRLF;
    return ret;
}
 
class Request//客户端使用的
{
public:
    // 将用户的输入转成内部成员
    // 用户可能输入x+y,x+ y,x +y,x + y等等格式
    // 提前修改用户输入(主要还是去掉空格),提取出成员
    Request(std::string in, bool *status)
        : _x(0), _y(0), _ops(' ')
    {
        rmSpace(in); // 删除空格
 
        // 这里使用c的字符串,因为有strtok
        char buf[1024];
 
        // 打印n个字符,多的会被截断
        snprintf(buf, sizeof(buf), "%s", in.c_str()); // 将报文存到buf里面去,方便使用strtok
 
        char *left = strtok(buf, OPS); // left变成从字符串in的最开始到第一个运算符的这段字符串——即左操作数
        if (!left)
        { // 找不到
            *status = false;
            return;
        }
 
        // right变成从第一个运算符开始,到第二个运算符中间的这段字符串——即右操作数
        char *right = strtok(nullptr, OPS); // 在上次寻找的基础上继续寻找
        if (!right)
        { // 找不到
            *status = false;
            return;
        }
 
        // x+y, strtok会将+设置为\0
        char mid = in[strlen(left)]; // 截取出操作符
        // 这是在原字符串里面取出来,buf里面的这个位置被改成\0了
 
        _x = atoi(left);
        _y = atoi(right);
        _ops = mid;
        *status = true;
    }
 
    // 删除输入中的空格
    void rmSpace(std::string &in)
    {
        std::string tmp;
        for (auto e : in)
        {
            if (e != ' ')
            {
                tmp += e;
            }
        }
        in = tmp;
    }
 
    // 序列化 (入参应该是空的,会返回一个序列化字符串)
    void serialize(std::string &out)//这个是客户端在发送消息给服务端时使用的,在这之后要先编码,才能发送出去
    {
        // x + y
        out.clear(); // 序列化的入参是空的
        out += std::to_string(_x);
        out += SPACE;
        out += _ops; // 操作符不能用tostring,会被转成ascii
        out += SPACE;
        out += std::to_string(_y);
        // 不用添加分隔符(这是encode要干的事情)
    }
    //序列化之后应该要编码,去加个长度
 
    // 反序列化(解开
    bool deserialize(const std::string &in)//这个是服务端接收到客户端发来的消息后使用的,在这之前要先解码
    {
        // x + y 需要取出x,y和操作符
        size_t space1 = in.find(SPACE);  // 第一个空格
        if (space1 == std::string::npos) // 没找到
        {
            return false;
        }
 
        size_t space2 = in.rfind(SPACE); // 第二个空格
        if (space2 == std::string::npos) // 没找到
        {
            return false;
        }
 
        // 两个空格都存在,开始取数据
        std::string dataX = in.substr(0, space1);
        std::string dataY = in.substr(space2 + SPACE_LEN); // 默认取到结尾
 
        std::string op = in.substr(space1 + SPACE_LEN, space2 - (space1 + SPACE_LEN));
        if (op.size() != 1)
        {
            return false; // 操作符长度有问题
        }
 
        // 没问题了,转内部成员
        _x = atoi(dataX.c_str());
        _y = atoi(dataY.c_str());
        _ops = op[0];
        return true;
    }
 
public:
    int _x;
    int _y;
    char _ops;
};
 
class Response // 服务端必须回应
{
    Response(int code = 0, int result = 0)
        : _exitCode(code), _result(result)
    {
    }
 
    // 序列化
    void serialize(std::string &out)//这个是服务端发送消息给客户端使用的,使用之后要编码
    {
        // code ret
        out.clear();
        out += std::to_string(_exitCode);
        out += SPACE;
        out += std::to_string(_result);
        out += CRLF;
    }
 
    // 反序列化
    bool deserialize(const std::string &in)//这个是客户端接收服务端消息后使用的,使用之前要先解码
    {
        // 只有一个空格
        size_t space = in.find(SPACE);  // 寻找第一个空格的下标
        if (space == std::string::npos) // 没找到
        {
            return false;
        }
 
        std::string dataCode = in.substr(0, space);
        std::string dataRes = in.substr(space + SPACE_LEN);
 
        _exitCode = atoi(dataCode.c_str());
        _result = atoi(dataRes.c_str());
        return true;
    }
 
public:
    int _exitCode; // 计算服务的退出码
    int _result;   // 结果
};

2.3.6 客户端/服务端完整代码

CalculatorClient.cc:

#include "TcpClient.hpp"

static void usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}

enum
{
    LEFT,
    OPER,
    RIGHT
};


Request ParseLine(const std::string &line)
{
    std::string left, right;
    char op;
    int status = LEFT;

    int i = 0;
    while(i < line.size())
    {
        switch (status)
        {
        case LEFT:
            if (isdigit(line[i]))
                left.push_back(line[i++]);
            else
                status = OPER;
            break;
        case OPER:
            op = line[i++];
            status = RIGHT;
            break;
        case RIGHT:
            if (isdigit(line[i]))
                right.push_back(line[i++]);
            break;
        }
    }

    Request req;
    req._x = std::stoi(left);
    req._y = std::stoi(right);
    req._op = op;

    return req;
}

int main(int argc, char* argv[])
{
	if(argc != 3)
	{
		usage(argv[0]);
		exit(USAGE_ERR);
	}

	string serverip = argv[1];
	uint16_t serverport = atoi(argv[2]);

	Sock sock;
	sock.Socket();

	int n = sock.Connect(serverip, serverport);
	if(n != 0) return 1;

	string buffer;
	while(true)
	{
		cout << "Enter# ";
		string line;
		getline(cin, line);

		Request req = ParseLine(line);
		cout << "test:" << req._x << req._op << req._y << endl;

		// 序列化
		string sendString;
		req.Serialize(&sendString);

		// 添加报头
		sendString = AddHeader(sendString);

		// send
		send(sock.Fd(), sendString.c_str(), sendString.size(), 0);

		// 获取响应
		string package;
		int n = 0;
	START:
		n = ReadPackage(sock.Fd(), buffer, &package);
		if(n == 0)
			goto START;
		else if(n < 0)
			break;
		else
		{}

		// 去掉报头
		package = RemoveHeader(package, n);

		// 反序列化
		Response resp;
		resp.Deserialize(package);

		cout << "result: " << resp._result << "[code: " << resp._code << "]" << endl;
	}

	sock.Close();
	return 0;
}

CalculatorServer.cc:

#include "TcpServer.hpp"
#include <memory>
using namespace tcpserver_ns;

Response calculate(const Request &req)
{
    // 走到这里,一定保证req是有具体数据的!

    Response resp(0, 0);
    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._code = 1;
        else
            resp._result = req._x / req._y;
        break;
    case '%':
        if (req._y == 0)
            resp._code = 2;
        else
            resp._result = req._x % req._y;
        break;
    default:
        resp._code = 3;
        break;
    }

    return resp;
}

int main()
{
	uint16_t port = 8080;
	unique_ptr<TcpServer> tsvr(new TcpServer(calculate, port));
	tsvr->InitServer();
	tsvr->Start();
	return 0;
}

Err.hpp:

#pragma once

enum
{
    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR,
    CONNECT_ERR,
    SETSID_ERR,
    OPEN_ERR
};

Log.hpp:

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <ctime>
#include <unistd.h>
#include <sys/types.h>
#include <stdarg.h>
using namespace std;

const string filename = "log/tcpserver.log";

// 枚举日志等级
enum
{
    Debug = 0, // 调试信息
    Info,      // 正常运行
    Warning,   // 报警
    Error,     // 正常错误
    Fatal,     // 严重错误
    Uknown
};

// 字符串形式获取日志等级
static string toLevelString(int level)
{
    switch (level)
    {
    case Debug:
        return "Debug";
    case Info:
        return "Info";
    case Warning:
        return "Warning";
    case Error:
        return "Error";
    case Fatal:
        return "Fatal";
    default:
        return "Uknown";
    }
}

// 获取日志产生时间
static string getTime()
{
    time_t curr = time(nullptr);
    struct tm* tmp = localtime(&curr);

    // 缓冲区
    char buffer[128];
    snprintf(buffer, sizeof buffer, "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
            tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
    
    return buffer;
}

// 日志格式: 日志等级 时间 pid 消息体 —— 日志函数

void logMessage(int level, const char* format, ...)
{
    char logLeft[1024];
    string level_string = toLevelString(level);
    string curr_time = getTime();
    snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());

    char logRight[1024];
    va_list p;
    va_start(p, format);
	vsnprintf(logRight, sizeof(logRight), format, p);
    va_end(p);

    // 打印日志
    printf("%s%s\n", logLeft, logRight);

    // 将日志保存到文件中
    // FILE* fp = fopen(filename.c_str(), "a");
    // if(!fp) return;
    // fprintf(fp, "%s%s\n", logLeft, logRight);
    // fflush(fp);
    // fclose(fp);
}

Protocol.hpp:

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include "Sock.hpp"
#include <jsoncpp/json/json.h>

#include "Util.hpp"
// 给网络版本计算器定制协议

// #define MYSELF 1

// 给网络版本计算器定制协议
namespace protocol_ns
{
	#define SEP " "
    #define SEP_LEN strlen(SEP) // 注意不能写成 sizeof
    #define HEADER_SEP "\r\n"
    #define HEADER_SEP_LEN strlen("\r\n")

	// 添加报头后 —— "长度"\r\n""_x _op _y"\r\n 
	string AddHeader(const string& str)
	{
		std::cout << "AddHeader 之前:\n"
                  << str << std::endl;

		string s = to_string(str.size());
		s += HEADER_SEP;
		s += str;
		s += HEADER_SEP;

		std::cout << "AddHeader 之后:\n"
                  << s << std::endl;

		return s;
	}

	// 去除报头 "长度"\r\n""_x _op _y"\r\n —— _x _op _y
	string RemoveHeader(const std::string &str, int len)
    {
		std::cout << "RemoveHeader 之前:\n"
                  << str << std::endl;

		string res = str.substr(str.size() - HEADER_SEP_LEN - len, len);
		return res;

		std::cout << "RemoveHeader 之后:\n"
                  << res << std::endl;
    }

	int ReadPackage(int sock, string& inbuffer, string*package)
	{
		std::cout << "ReadPackage inbuffer 之前:\n"
                  << inbuffer << std::endl;

		// 边读取
		char buffer[1024];
		ssize_t s = recv(sock, buffer, sizeof(buffer - 1), 0);

		if(s <= 0)
			return -1;
		buffer[s] = 0;
		inbuffer += buffer;

		std::cout << "ReadPackage inbuffer 之中:\n"
                  << inbuffer << std::endl;

		// 边读取边分析, "7"\r\n""10 + 20"\r\n
		auto pos = inbuffer.find(HEADER_SEP); // 查找 \r\n
		if(pos == string::npos)
			return 0;
		
		string lenStr = inbuffer.substr(0, pos); // 获取头部字符串
		int len = Util::toInt(lenStr);

		int targetPackageLen = lenStr.size() + len + 2 * HEADER_SEP_LEN; // 获取到的完整字符串的长度
		if(inbuffer.size() < targetPackageLen)
			return 0;
		*package = inbuffer.substr(0, targetPackageLen);
		inbuffer.erase(0, targetPackageLen);		
		
		std::cout << "ReadPackage inbuffer 之后:\n"
                  << inbuffer << std::endl;

		return len; // 返回有效载荷的长度
	}

	// Request && Response都要提供序列化和反序列化功能——自己手写

	// 请求
	class Request
    {
	public:
		Request()
		{}
		Request(int x, int y, char op):_x(x), _y(y), _op(op)
		{}
		
		// 协议的序列化 struct -> string
		bool Serialize(string* outStr)
		{
			*outStr = "";
#ifdef MYSELF
			string x_string = to_string(_x);
			string y_string = to_string(_y);

			// 手动序列化
			*outStr = x_string + SEP + _op + SEP + y_string;

			std::cout << "Request Serialize:\n"
                      << *outStr << std::endl;
#else
			Json::Value root; // Value 是一种万能对象, 可以接受任意的kv类型
			root["x"] = _x;
			root["y"] = _y;
			root["op"] = _op;

			// Json::FastWriter writer; // Writer 是用来序列化的, struct -> string
			Json::StyledWriter writer;
			*outStr = writer.write(root);
#endif
			return true;
		}

		// 协议的反序列化 string -> struct
		bool Deserialize(const string& inStr)
		{
#ifdef MYSELF
			// 将inStr分隔到数组里面 -> [0]=>10 [1]=>+ [2]=>20
			vector<string> result;
			Util::StringSplit(inStr, SEP, &result);
			if(result.size() != 3)
				return false;
			if(result[1].size() != 1)
				return false;
			
			_x = Util::toInt(result[0]);
			_y = Util::toInt(result[2]);
			_op = result[1][0];
#else
			Json::Value root;
			Json::Reader reader; // Reader是用来进行反序列化的
			reader.parse(inStr, root);

			_x  = root["x"].asInt();
			_y = root["y"].asInt();
			_op = root["op"].asInt();
#endif
			return true;
		}
		~Request()
		{}
	
	public:	
		int _x; // 操作数 _x
		int _y; // 操作数 _y
		char _op;// 操作符 _op
	};

	// 响应
	class Response
	{
	public:
		Response()
		{}
		Response(int result, int code):_result(result), _code(code)
		{}

		bool Serialize(string* outStr)
		{
			*outStr = "";
#ifdef MYSELF
			string res_string = to_string(_result);
			string code_string = to_string(_code);

			// 手动序列化
			*outStr = res_string + SEP + code_string;

			std::cout << "Response Serialize:\n"
                      << *outStr << std::endl;
#else
			Json::Value root;
			root["result"] = _result;
			root["code"] = _code;

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

		bool Deserialize(const string& inStr)
		{
#ifdef MYSELF
			// 将inStr分隔到数组里面 -> [0]=>10 [1]=>+ [2]=>20
			vector<string> result;
			Util::StringSplit(inStr, SEP, &result);
			if(result.size() != 2)
				return false;
			
			_result = Util::toInt(result[0]);
			_code = Util::toInt(result[1]);
#else
			Json::Value root;
			Json::Reader reader;
			reader.parse(inStr, root);
			_result = root["result"].asInt();
			_code = root["code"].asInt();
#endif
			Print();
			return true;
		}

		void Print()
        {
            std::cout << "_result: " << _result << std::endl;
            std::cout << "_code: " << _code << std::endl;
        }

	public:
		int _result;
		int _code;
	};
}

Sock.hpp:

#pragma once

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
#include "Err.hpp"

using namespace std;
static const int gbacklog = 32;
static const int defaultfd = -1;

class Sock
{
public:
	Sock():_sock(defaultfd)
	{}

	Sock(int sock):_sock(sock)
	{}
	
	// 创建套接字
	void Socket()
	{
		_sock = socket(AF_INET, SOCK_STREAM, 0);
		if(_sock < 0)
		{
			logMessage(Fatal, "socket error, code: %d, errstring: %s", errno, strerror(errno));
			exit(SOCKET_ERR);
		}
	}

	// 绑定端口号 和 ip地址
	void Bind(const uint16_t& port)
	{
		struct sockaddr_in local;
		local.sin_addr.s_addr = INADDR_ANY; // 绑定任意IP地址
		local.sin_port = htons(port); // 绑定端口号
		local.sin_family = AF_INET;

		if(bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
		{
			logMessage(Fatal, "bind error, code: %d, errstring: %s", errno, strerror(errno));
			exit(BIND_ERR);
		}
	}

	// 监听
	void Listen()
	{
		if(listen(_sock, gbacklog) < 0)
		{
			logMessage(Fatal, "listen error, code: %d, errstring: %s", errno, strerror(errno));
			exit(LISTEN_ERR);
		}
	}

	// 获取连接
	int Accept(string* clientip, uint16_t* clientport)
	{
		struct sockaddr_in temp;
		socklen_t len = sizeof(temp);

		int sock = accept(_sock, (struct sockaddr*)&temp, &len);
		if(sock < 0)
		{
			logMessage(Warning, "accept error, code: %d, errstring: %s", errno, strerror(errno));
		}
		else
		{
			*clientip = inet_ntoa(temp.sin_addr);
			*clientport = ntohs(temp.sin_port);
		}
		return sock;
	}

	// 客户端和服务器建立连接
	int Connect(const string& serverip, const uint16_t& serverport)
	{
		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());
		
		return connect(_sock, (struct sockaddr*)&server, sizeof(server));
	}

	int Fd()
	{
		return _sock;
	}

	void Close()
	{
		if(_sock != defaultfd)
			close(_sock);
	}
	~Sock()
    {}

private:
	int _sock;
};

TcpClient.hpp:

#pragma once

#include "TcpClient.hpp"
#include "Sock.hpp"
#include "Protocol.hpp"

#include <iostream>
#include <string>

using namespace std;
using namespace protocol_ns;

TcpServer.hpp:

#pragma once
#include <iostream>
#include <functional>
#include <cstring>
#include <pthread.h>
#include "Sock.hpp"
#include "Protocol.hpp"

using namespace std;

namespace tcpserver_ns
{
	using namespace protocol_ns;
	using func_t = function<Response(const Request&)>;
	
	class TcpServer;
	class ThreadData
	{
	public:
		ThreadData(int sock, string ip, uint16_t port, TcpServer* tsvrp)
			:_sock(sock), _ip(ip), _port(port), _tsvrp(tsvrp)
		{}
		~ThreadData()
		{}
	public:
		int _sock;
		string _ip;
		uint16_t _port;
		TcpServer *_tsvrp;
	};

	class TcpServer
	{
	public:
		TcpServer(func_t func, uint16_t port)
		:_func(func), _port(port)
		{}

		// 初始化服务器
		void InitServer()
		{
			_listensock.Socket();
			_listensock.Bind(_port);
			_listensock.Listen();
			logMessage(Info, "init server done, listensock: %d, errstring: %s", errno, strerror(errno));
		}

		// 运行服务器
		void Start()
		{
			while(true)
			{
				string clientip;
				uint16_t clientport;

				int sock = _listensock.Accept(&clientip, &clientport);
				if(sock < 0) continue;
				logMessage(Debug, "get a new client, client info : [%s:%d]", clientip.c_str(), clientport);

				pthread_t tid; // 创建多线程
				ThreadData *td = new ThreadData(sock, clientip, clientport, this);
				pthread_create(&tid, nullptr, ThreadRoutine, td);
			}
		}

		static void* ThreadRoutine(void* args)
		{
			pthread_detach(pthread_self());
			ThreadData *td = static_cast<ThreadData *>(args);

			td->_tsvrp->ServiceIO(td->_sock, td->_ip, td->_port);
			logMessage(Debug, "thread quit, client quit ...");
			delete td;
			return nullptr;
		}

		// 服务器对客户端的数据进行IO处理
		void ServiceIO(int sock, const std::string &ip, const uint16_t &port)
		{
			string inbuffer;
			while(true)
			{
				// 保证自己读到一个完整的字符串报文 "7"\r\n""10 + 20"\r\n
				string package;
				int n = ReadPackage(sock, inbuffer, &package);
				if(n == -1)
					break;
				else if(n == 0)
					continue;
				else
				{
					// 已经得到了一个"7"\r\n""10 + 20"\r\n
					// 1. 提取有效载荷
					package = RemoveHeader(package, n);

					// 2. 已经读到了一个完整的string
					Request req;
					req.Deserialize(package);

					// 3. 直接提取用户的请求数据
					Response resp = _func(req); // 业务逻辑
					
					// 4. 给用户返回响应——序列化
					string send_string;
					resp.Serialize(&send_string);

					// 5. 添加报头
					send_string = AddHeader(send_string);

					// 6. 发送
					send(sock, send_string.c_str(), send_string.size(), 0);
				}
			}
			close(sock);
		}

		~TcpServer()
		{}
	private:
		uint16_t _port; // 端口号
		Sock _listensock; // 监听套接字
		func_t _func;
	};
}

Util.hpp:

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>

using namespace std;

class Util
{
public:
	static bool StringSplit(const string&str, const string& sep, vector<string>* result)
	{
		size_t start = 0;
		while(start < str.size())
		{
			auto pos = str.find(sep, start);
			if(pos == string::npos) break;
			result->push_back(str.substr(start, pos - start));
			start = pos + sep.size();
		}

		if(start < str.size())
			result->push_back(str.substr(start));
		return true;
	}

	static int toInt(const string& s)
	{
		return atoi(s.c_str());
	}
};

makefile:

.PHONY:all
all:calserver calclient

calclient:CalculatorClient.cc
	g++ -o $@ $^ -std=c++11 -ljsoncpp

calserver:CalculatorServer.cc
	g++ -o $@ $^ -std=c++11 -lpthread -ljsoncpp

.PHONY:clean
clean:
	rm -f calclient calserver

三、结束语 

       今天内容就到这里啦,时间过得很快,大家沉下心来好好学习,会有一定的收获的,大家多多坚持,嘻嘻,成功路上注定孤独,因为坚持的人不多。那请大家举起自己的小手给博主一键三连,有你们的支持是我最大的动力💞💞💞,回见。

​​ 

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

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

相关文章

CTFshow之信息收集第1关到10关。详细讲解

得而不惜就该死&#xff01; --章总 开始新的篇章&#xff01; 零、目录 一、实验准备 1、ctf网站&#xff1a;ctf.show 2、工具&#xff1a;chrome浏览器、hackbar插件 3、burpsuite抓包工具 二、实验技巧 &#xff08;一&#xff09;F12摸奖 源码泄露 &#xff08;二…

Redis ——发布订阅

问题引入&#xff1a; 服务器A、B、C、D&#xff0c;客户端&#xff1a;C1&#xff0c;C2&#xff0c;C3&#xff0c;C4&#xff1b; 客户端基于集群聊天服务器的负载均衡分配&#xff1b; C1 被分配到A&#xff0c;C2 被分配到B&#xff0c;C3 被分配到C&#xff0c;C4 被分…

【漏洞复现】某平台-QRcodeBuildAction-LoginSSO-delay-mssql-sql注入漏洞

《Java代码审计》http://mp.weixin.qq.com/s?__bizMzkwNjY1Mzc0Nw&mid2247484219&idx1&sn73564e316a4c9794019f15dd6b3ba9f6&chksmc0e47a67f793f371e9f6a4fbc06e7929cb1480b7320fae34c32563307df3a28aca49d1a4addd&scene21#wechat_redirect 《Web安全》h…

API网关 - JWT认证 ; 原理概述与具体实践样例

API网关主要提供的能力&#xff0c;就是协议转换&#xff0c;安全&#xff0c;限流等能力。 本文主要是分享 如何基于API网关实现 JWT 认证 。 包含了JWT认证的流程&#xff0c;原理&#xff0c;与具体的配置样例 API网关认证的重要性 在现代Web应用和微服务架构中&#x…

Excel:vba实现批量插入图片

实现的效果&#xff1a; 实现的代码&#xff1a; Sub InsertImageNamesAndPictures()Dim PicPath As StringDim PicName As StringDim PicFullPath As StringDim RowNum As IntegerDim Pic As ObjectDim Name As String 防止表格里面有脏数据Cells.Clear 遍历工作表中的每个图…

什么是 OpenTelemetry?

OpenTelemetry 定义 OpenTelemetry (OTel) 是一个开源可观测性框架&#xff0c;允许开发团队以单一、统一的格式生成、处理和传输遥测数据&#xff08;telemetry data&#xff09;。它由云原生计算基金会 (CNCF) 开发&#xff0c;旨在提供标准化协议和工具&#xff0c;用于收集…

电商美工必备神器:千鹿 AI 轻松解决场景图主图尺寸问题

前言 在电商领域&#xff0c;美工在做详情页设计时&#xff0c;常常会为图片尺寸问题而苦恼。而 AI 扩图在此刻就成为了美工们的得力助手。其中&#xff0c;场景图主图太小是一个让人颇为头疼的难题。千鹿 AI 作为一款强大的工具&#xff0c;能够一键将图片改成指定尺寸&#…

关于 PDF 抽取的吐槽

今天一下午写了8&#xff0c;9个 PDF 抽取的脚本。最后又回归最开始简单的模式了&#xff0c;要疯了&#xff0c;谁懂啊。 我是下午的工作是这样的(我是这么疯的) 最开始使用最简单的策略&#xff0c;先使用 PyPDF2.PdfReader(file) 读取文件&#xff0c;然后在每一页使用 pag…

无人机避障——(局部规划方法)DWA(动态窗口法)

传统的DWA算法更加倾向于车辆等差速无人车&#xff0c;旋翼无人机是全速的&#xff0c;全向的。 全局路径是通过A*算法生成的 局部路径规划效果&#xff1a; DWA算法效果&#xff1a; 过程图&#xff1a; 完整过程&#xff1a; PID算法效果&#xff1a; 过程图&#xff1a…

知识吾爱纯净版小程序系统 leibiao SQL注入漏洞复现(XVE-2024-30663)

0x01 产品简介 知识吾爱纯净版小程序系统是一款基于微信小程序平台开发的知识付费应用,旨在帮助用户快速建立自己的知识付费平台,实现支付变现和流量主收益。它提供了简洁明了的用户界面和良好的用户体验,同时注重用户隐私保护,确保用户信息的安全存储和传输。 0x02 漏洞…

基于web的便捷饭店点餐小程序的设计与实现(lw+演示+源码+运行)

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对高校教师成果信息管理混乱&#xff0c;出错率高&#xff0c;信息安全…

全面解析:深度学习技术及其应用

&#x1f493; 博客主页&#xff1a;瑕疵的CSDN主页 &#x1f4dd; Gitee主页&#xff1a;瑕疵的gitee主页 ⏩ 文章专栏&#xff1a;《热点资讯》 全面解析&#xff1a;深度学习技术及其应用 全面解析&#xff1a;深度学习技术及其应用 全面解析&#xff1a;深度学习技术及其应…

项目实战使用gitee

1.创建本地仓库 2.进行提交到本地仓库 创建仓库后在idea中会显示图标&#xff0c;点击绿色的√进行快速提交 3.绑定远程仓库 4.番外篇-创建gitee仓库 注意不要勾选其他

【鸿蒙新闻】10月29日警用鸿蒙开发者大会在北京胜利召开,开启智慧应用新时代!

10月29日&#xff0c;在公安部科技信息化局、公安部装备财务局指导下&#xff0c;由公安部第一研究所主办&#xff0c;鼎桥通信技术有限公司、OpenHarmony生态委员会及公共安全专委会协办的警用鸿蒙开发者大会在北京胜利召开。会议以“拥抱警鸿创新生态 开启智慧应用新时代”为…

Spring Boot 3.3 【九】Redis 的五种数据结构深入浅出(String List Set Hash Zset)

如果觉得本文能够帮到您&#xff0c;请关注&#x1f31f;、点赞&#x1f44d;、收藏&#x1f4da;&#xff0c;让这份美好延续下去&#xff01; 一、Redis 数据结构简介 在现代应用开发中&#xff0c;高效的数据存储和管理是构建强大系统的关键。Redis 作为一种高性能的内存数…

命令行参数、环境变量、地址空间

命令行参数&#xff1a; int main(int argc, char *argv[ ])&#xff0c;main的参数可带可不带。argc参数通常代表后面的char *argv的元素个数有多少。 在linux中会把输入的字符串存到char *argv[ ]中&#xff0c;在数组的结尾为NULL。 命令行参数可以让同一个程序可以通过不同…

持续优化,构建更好地 auto git commit 体验

几个月前&#xff0c;受到一篇推文的启发 https://x.com/mtrainier2020/status/1802941902964277379 &#xff0c;我突然想到可以借助 git alias 添加一些小命令&#xff0c;加速我的 git workflow 流程&#xff0c;于是我花了两个小时的时间进行工程封装&#xff0c;并发布了 …

C#-类:声明类、声明类对象

一&#xff1a;类的声明 class 类名 {//特征——成员变量//行为——成员方法//保护特征——成员属性//构造函数和析构函数//索引器//运算符重载//静态成员 }类名&#xff1a;帕斯卡 同一个语句块中的不同类 不能重名 二&#xff1a;声明类对象 2.1 类的声明 ≠ 类对象的声…

【学习enable_if模板, 学习unqiue_str 删除操作】

enable_if 是 C 标准库中的一个模板结构体&#xff0c;它用于条件编译和 SFINAE&#xff08;Substitution Failure Is Not An Error&#xff09;。enable_if 的主要作用是通过条件编译来控制模板的实例化&#xff0c;从而实现条件编译和 SFINAE。 1. enable_if 的基本用法如下…

AIGC产品经理高频面试题❗️看完的都拿高薪了

&#x1f914;️如果你正在考虑找AI产品经理相关的工作, 建议好好准备这些面试问题, 如果想要更加详细的回答可以直接询问海螺AI哦! 谁用了不说一句: AI真的太适合准备面试啦(&#x1f640;尖叫抛开 之后会分享更多岗位的面试题目, 以及如何用AI准备面试的tips哦! 大模型&A…