网站前置审批类型,wordpress背景图片下载,东营建设网站公司电话,WordPress只能ssl✨个人主页#xff1a; 熬夜学编程的小林
#x1f497;系列专栏#xff1a; 【C语言详解】 【数据结构详解】【C详解】【Linux系统编程】【Linux网络编程】
目录
1、Protocol.hpp
1.1、Request类
1.1.1、基本结构
1.1.2、构造析构函数
1.1.3、序列化函数
1.1.4、反…✨个人主页 熬夜学编程的小林
系列专栏 【C语言详解】 【数据结构详解】【C详解】【Linux系统编程】【Linux网络编程】
目录
1、Protocol.hpp
1.1、Request类
1.1.1、基本结构
1.1.2、构造析构函数
1.1.3、序列化函数
1.1.4、反序列化函数
1.1.5、获取成员变量函数
1.1.6、设置成员变量值函数
1.2、Response类
1.2.1、基本结构
1.2.2、构造析构函数
1.2.3、序列化函数
1.2.4、反序列化函数
1.2.5、打印函数
1.3、Factory类
1.4、添加报头
1.5、解析报头
2、Service.hpp
2.1、构造析构函数
2.2、IOExcute()
2.3、Recv()
3、NetCal.hpp
3.1、构造析构函数
3.2、Calculator()
4、ClientMain.cc
5、完整代码
5.1、Protocol.hpp
5.2、Service.hpp
5.3、ClientMain.cc
5.4、Makefile 上一弹已经写好服务端代码并讲解了序列化使用到的json库这弹开始写协议并完成网络计算器的代码 1、Protocol.hpp 该文件实现序列化与反序列使用到的类和相关函数(加报头解报头) 1.1、Request类 该类是向服务器发送请求的类需要三个成员变量_x_y_oper(运算符号)统一的计算格式是 _x _oper _y内部主要是序列化(发送)和反序列化(接受)函数 1.1.1、基本结构 该类有三个成员变量_x_y_oper(运算符号)序列化反序列化构造析构及其他获取成员变量与打印的函数 class Request
{
public:Request(){}// 序列化 将结构化转成字符串bool Serialize(std::string *out);// 反序列化 将字符串转成结构化bool Deserialize(const std::string in);void Print();~Request();int X();int Y();char Oper();
private:int _x;int _y;char _oper; // - * / % // x oper y
};
1.1.2、构造析构函数 为了方便后面的使用此处实现两个构造函数一个无参一个带参函数析构函数无需处理 Request()
{}
Request(int x,int y,char oper):_x(x),_y(y),_oper(oper)
{}~Request()
{}
1.1.3、序列化函数 序列化即将结构化转成字符串并将字符串以输出型参数传出 // 序列化 将结构化转成字符串
bool Serialize(std::string *out)
{// 1.自己做: x oper y (麻烦)// 2.使用现成的库, xml,json(jsoncpp库), protobufJson::Value root;root[x] _x;root[y] _y;root[oper] _oper;Json::FastWriter writer;std::string s writer.write(root);*out s;return true;
} 1.1.4、反序列化函数 反序列化即将字符串转成结构化参数传入字符串 // 反序列化 将字符串转成结构化
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;
} 1.1.5、获取成员变量函数 因为成员变量是私有的外部访问使用成员函数 int X()
{return _x;
}
int Y()
{return _y;
}
char Oper()
{return _oper;
}
1.1.6、设置成员变量值函数
void SetValue(int x, int y, char oper)
{_x x;_y y;_oper oper;
}
1.2、Response类 该类是向客户端发送结果的类需要三个成员变量_result(计算结果)_code(自定义错误码[0: success 1: div error 2: 非法操作])_desc(错误码描述)内部主要是序列化(发送)和反序列化(接受)函数 1.2.1、基本结构 该类有三个成员变量_result(计算结果)_code(自定义错误码)_desc(错误码描述)序列化反序列化构造析构和打印函数 注意为了方便类外访问该类成员变量该成员变量是公有的
class Response
{
public:Response();// 序列化 将结构化转成字符串bool Serialize(std::string *out);// 反序列化 将字符串转成结构化bool Deserialize(const std::string in);~Response();
public:int _result;int _code; // 0: success 1: div error 2: 非法操作std::string _desc;
};
1.2.2、构造析构函数 构造函数直接手动初始化(结果和错误码初始化为0描述默认初始化为success)析构函数无需处理 Response():_result(0),_code(0),_desc(success)
{}~Response()
{}
1.2.3、序列化函数 序列化即将结构化转成字符串并将字符串以输出型参数传出 // 序列化 将结构化转成字符串
bool Serialize(std::string *out)
{// 使用现成的库, xml,json(jsoncpp库), protobufJson::Value root;root[result] _result;root[code] _code;root[desc] _desc;Json::FastWriter writer;std::string s writer.write(root);*out s;return true;
}
1.2.4、反序列化函数 反序列化即将字符串转成结构化参数传入字符串 // 反序列化 将字符串转成结构化
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;
} 1.2.5、打印函数 将成员变量以字符串形式打印出来即可 void PrintResult()
{std::cout result: _result , code: _code , desc: _desc std::endl;
}
1.3、Factory类 因为Request类和Response类可能频繁创建因此我们可以设计一个工厂类内部设计两个创建类的静态函数(没有this指针外部直接调用函数即可) class Factory
{
public:static std::shared_ptrRequest BuildRequestDefault(){return std::make_sharedRequest();}static std::shared_ptrResponse BuildResponseDefault(){return std::make_sharedResponse();}
};
1.4、添加报头 在实际的网络通信中传的不仅仅是序列化之后的字符串还会有报头信息此处我们也设计一下报头信息格式如下 1、len\r\n{json}\r\n --- 完整的报文 2、len 有效载荷的长度 3、\r\n(第一个): 区分len 和 json 串 4、\r\n(第二个): 暂时没有其他用打印方便debug static 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;
}
1.5、解析报头 将发送过来的有报头的信息解析成有效信息即去掉前面的长度和分割符与有效信息后面的分隔符 注意可能没有一个有效信息或者有多个有效信息
static const std::string sep \r\n; // 分隔符// 不能带const
// le
// len\r\n{j [)
// len\r\n{json}\r\n
// len\r\n{json}\r\nlen\r\n
// len\r\n{json}\r\nlen\r\n{json}\r\n
// len\r\n{json}\r\nlen\r\n{json}\r\nlen\r\n{json}\r\nstd::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); // json长度// 计算一个完整的报文应该是多长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); // 从0位置删除total长度return jsonstr;
}
2、Service.hpp Service.hpp中的 IOService类 是用于通信的类而且内部需要执行传入的回调函数因此该类需要加一个执行方法的成员 执行方法的声明 参数是请求类的指针返回值是应答类的指针 using process_t std::functionstd::shared_ptrResponse(std::shared_ptrRequest);
2.1、构造析构函数 构造函数需要传入函数对象用于初始化成员变量析构函数无需处理 IOService(process_t process) :_process(process)
{}~IOService()
{}
2.2、IOExcute() IOExcute()函数进行客户端与服务端的通信并处理发送过来的信息(调用执行方法)有以下7个主要步骤 1、接收消息 2、报文解析(保证获取至少获得一条有效信息没有则继续接受消息) 3、反序列化(将字符串转成结构化) 4、业务处理(调用构造函数传入的回调函数) 5、序列化应答 6、添加len长度(报头) 7、发送回去 void IOExcute(SockSPtr sock, InetAddr addr)
{std::string packagestreamqueue; // 写在while循环外存储信息while (true){// 1.负责读取ssize_t n sock-Recv(packagestreamqueue);if(n 0){LOG(INFO, client %s quit or recv error\n, addr.AddrStr().c_str());break;}std::cout -------------------------------------------- std::endl;std::cout packagestreamqueue: \n packagestreamqueue std::endl;// 我们能保证读到的是完整的报文 不能// 2.报文解析提取报头和有效载荷std::string package Decode(packagestreamqueue);if(package.empty()) continue;// 我们能保证读到的是一个完整的报文auto req Factory::BuildRequestDefault();std::cout package: \n package std::endl;// 3.反序列化req-Deserialize(package); // 反序列化 将字符串转成结构化// 4.业务处理auto resp _process(req); // 业务处理(通过请求得到应答)// 5.序列化应答std::string respjson;resp-Serialize(respjson); // 序列化std::cout respjson: \n respjson std::endl;// 6.添加len长度respjson Encode(respjson);std::cout respjson add header done: \n respjson std::endl;// 7.发送回去sock-Send(respjson);}
此处有一个问题如果第一次接收消息没有读到完整的报文就会继续接受消息但是以我们前面写的接收消息函数会清空内容因此我们需要做稍微的修改
2.3、Recv() Recv()函数是Socket.hpp文件中TcpServer类的成员函数接收消息成功之后需要该为拼接旧的内容 // 接收消息
ssize_t Recv(std::string *out) override
{char inbuffer[4096];ssize_t n ::recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);if (n 0){inbuffer[n] 0;// *out inbuffer;*out inbuffer; // 调整(可能一次读取不成功 | 读取多次)}return n;
}
3、NetCal.hpp NetCal.hpp文件中的NetCal类包含回调函数的具体实现 3.1、构造析构函数 该类没有成员变量构造析构函数无需处理 NetCal()
{}~NetCal()
{}
3.2、Calculator() Calculator() 函数用于网络计算器的计算逻辑 std::shared_ptrResponse Calculator(std::shared_ptrRequest req)
{auto resp Factory::BuildResponseDefault();switch (req-Oper()){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;resp-_desc divc zero;}else{resp-_result req-X() / req-Y();}}break;case %:{if(req-Y() 0){resp-_code 2;resp-_desc mod zero;}else{resp-_result req-X() % req-Y();}}break;default:{resp-_code 3;resp-_desc illegal operation;}break;}return resp;
} 4、ClientMain.cc 该文件用户创建TcpServer类对象并调用执行函数运行客户端 通信操作主要包括以下七步 1、序列化 2、添加长度报头字段 3、发送数据 4、读取应答response 5、报文解析提取报头和有效载荷 6、反序列化 7、打印结果 #include iostream
#include ctime
#include Socket.hpp
#include Protocol.hppusing namespace socket_ns;int main(int argc, char *argv[])
{if (argc ! 3){std::cerr Usage: argv[0] server-ip server-port std::endl;exit(0);}std::string serverip argv[1];uint16_t serverport std::stoi(argv[2]);SockSPtr sock std::make_sharedTcpSocket();if (!sock-BuildClientSocket(serverip, serverport)){std::cerr connect error std::endl;exit(1);}srand(time(nullptr) ^ getpid());const std::string opers -*/%^!;std::string packagestreamqueue;while (true){// 构建数据int x rand() % 10;usleep(x * 1000);int y rand() % 10;usleep(x * y * 100);char oper opers[y % opers.size()];// 构建请求auto req Factory::BuildRequestDefault();req-SetValue(x, y, oper);// 1.序列化std::string reqstr;req-Serialize(reqstr);// 2.添加长度报头字段reqstr Encode(reqstr);std::cout #################################### std::endl;std::cout requset string: \n reqstr std::endl;// 3.发送数据sock-Send(reqstr);while (true){// 4.读取应答responsessize_t n sock-Recv(packagestreamqueue);if (n 0){break;}// 我们能保证读到的是完整的报文 不能// 5.报文解析提取报头和有效载荷std::string package Decode(packagestreamqueue);if (package.empty())continue;std::cout package: \n package std::endl;// 6.反序列化auto resp Factory::BuildResponseDefault();resp-Deserialize(package);// 7.打印结果resp-PrintResult();break;}sleep(1);}sock-Close();return 0;
} 5、完整代码
5.1、Protocol.hpp
#pragma once
#include iostream
#include memory
#include string
#include jsoncpp/json/json.hstatic 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\r\n{j [)
// len\r\n{json}\r\n
// len\r\n{json}\r\nlen\r\n
// len\r\n{json}\r\nlen\r\n{json}\r\n
// len\r\n{json}\r\nlen\r\n{json}\r\nlen\r\n{json}\r\nstd::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); // json长度// 计算一个完整的报文应该是多长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); // 从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.自己做: x oper y (麻烦)// 2.使用现成的库, xml,json(jsoncpp库), protobufJson::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(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
};// class request resp {30,0}
class Response
{
public:Response() : _result(0), _code(0), _desc(success){}// 序列化 将结构化转成字符串bool Serialize(std::string *out){// 使用现成的库, xml,json(jsoncpp库), protobufJson::Value root;root[result] _result;root[code] _code;root[desc] _desc;Json::FastWriter 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 error 2: 非法操作std::string _desc;
};class Factory
{
public:static std::shared_ptrRequest BuildRequestDefault(){return std::make_sharedRequest();}static std::shared_ptrResponse BuildResponseDefault(){return std::make_sharedResponse();}
};5.2、Service.hpp
#pragma once
#include iostream
#include functional
#include InetAddr.hpp
#include Socket.hpp
#include Log.hpp
#include Protocol.hppusing namespace socket_ns;
using namespace log_ns;using process_t std::functionstd::shared_ptrResponse(std::shared_ptrRequest);class IOService
{
public:IOService(process_t process) :_process(process){}void IOExcute(SockSPtr sock, InetAddr addr){std::string packagestreamqueue; // 写在while循环外存储信息while (true){// 1.负责读取ssize_t n sock-Recv(packagestreamqueue);if(n 0){LOG(INFO, client %s quit or recv error\n, addr.AddrStr().c_str());break;}std::cout -------------------------------------------- std::endl;std::cout packagestreamqueue: \n packagestreamqueue std::endl;// 我们能保证读到的是完整的报文 不能// 2.报文解析提取报头和有效载荷std::string package Decode(packagestreamqueue);if(package.empty()) continue;// 我们能保证读到的是一个完整的报文auto req Factory::BuildRequestDefault();std::cout package: \n package std::endl;// 3.反序列化req-Deserialize(package); // 反序列化 将字符串转成结构化// 4.业务处理auto resp _process(req); // 业务处理(通过请求得到应答)// 5.序列化应答std::string respjson;resp-Serialize(respjson); // 序列化std::cout respjson: \n respjson std::endl;// 6.添加len长度respjson Encode(respjson);std::cout respjson add header done: \n respjson std::endl;// 7.发送回去sock-Send(respjson);}}// 测试// void IOExcute(SockSPtr sock, InetAddr addr)// {// while (true)// {// std::string message;// ssize_t n sock-Recv(message);// if(n 0)// {// LOG(INFO, get message from client [%s],message: %s\n, addr.AddrStr().c_str(), message.c_str());// std::string hello hello;// sock-Send(hello);// }// else if(n 0)// {// LOG(INFO, client %s quit\n, addr.AddrStr().c_str());// break;// }// else // {// LOG(ERROR, read error\n, addr.AddrStr().c_str());// break;// }// }// }~IOService(){}
private:process_t _process;
};
5.3、ClientMain.cc
#include iostream
#include ctime
#include Socket.hpp
#include Protocol.hppusing namespace socket_ns;int main(int argc, char *argv[])
{if (argc ! 3){std::cerr Usage: argv[0] server-ip server-port std::endl;exit(0);}std::string serverip argv[1];uint16_t serverport std::stoi(argv[2]);SockSPtr sock std::make_sharedTcpSocket();if (!sock-BuildClientSocket(serverip, serverport)){std::cerr connect error std::endl;exit(1);}srand(time(nullptr) ^ getpid());const std::string opers -*/%^!;std::string packagestreamqueue;while (true){// 构建数据int x rand() % 10;usleep(x * 1000);int y rand() % 10;usleep(x * y * 100);char oper opers[y % opers.size()];// 构建请求auto req Factory::BuildRequestDefault();req-SetValue(x, y, oper);// 1.序列化std::string reqstr;req-Serialize(reqstr);// 2.添加长度报头字段reqstr Encode(reqstr);std::cout #################################### std::endl;std::cout requset string: \n reqstr std::endl;// 3.发送数据sock-Send(reqstr);while (true){// 4.读取应答responsessize_t n sock-Recv(packagestreamqueue);if (n 0){break;}// 我们能保证读到的是完整的报文 不能// 5.报文解析提取报头和有效载荷std::string package Decode(packagestreamqueue);if (package.empty())continue;std::cout package: \n package std::endl;// 6.反序列化auto resp Factory::BuildResponseDefault();resp-Deserialize(package);// 7.打印结果resp-PrintResult();break;}sleep(1);}sock-Close();return 0;
}
5.4、Makefile
.PHONY:all
all:calserver calclientcalserver:ServerMain.cc g -o $ $^ -stdc14 -ljsoncppcalclient:ClientMain.cc g -o $ $^ -stdc14 -ljsoncpp.PHONY:clean
clean:rm -rf calserver calclient
