目录
网络“协议”的概念
结构化数据传输方案
序列化和反序列化
相关概念
序列化反序列化图解
穿插理解
Jsoncpp
序列化操作
反序列化操作
网络版计算器
核心实现
Socket套接字模板化封装
服务端代码
客户端代码
自定义协议
完整代码地址
网络“协议”的概念
网络协议是通信双方必须共同遵从的一套约定标准,通信双方约定了怎样建立链接,怎样封装数据,怎样呢去解封数据,如何识别对方发来的数据等具有共识的一些约定。
简单来讲进行网络通信的主机必须都遵循一套相同的标准,这套标准我们称为“协议”,而这些协议本质是通过结构化计算机数据表示出来的,只有通信双方都遵循这套协议,计算机之间才能互相通信交流。
结构化数据传输方案
方案:通信双方通信时,发送方需要把自己结构化数据转化为字符串的形式通过网络发送出去。
为什么要把结构化数据转化为字符串才能发送?
我们知道实际上在网络中进行通信发,发送方 发送数据基本都是发送自己的结构化数据,但如果发送方通过网络发送自己的结构化数据,对于结构化的数据内容只能一个个的进行发送,那么接收端获取数据的时候,不能明确如何把这些数据进行有效组合,也不清楚组合完的数据是否为一个完整数据。所以我们规定在通信时,发送方需要把自己结构化数据转化为字符串形式通过网络发送给接收端。
序列化和反序列化
相关概念
对于上述通信双方进行通信时,发送方需要把自己的结构化数据转化为字符串,接收方又需要把收到的字符串转化为结构化数据,这个操作我们可以使用序列化和反序列化来进行。
- 序列化:将数据结构或对象转换为一种字节序列格式,以便在网络上传输。
-
反序列化:序列化后的数据重新转换为原来的数据结构或对象。
序列化反序列化图解

穿插理解
在osi七层模型中:
应用层作用:针对特定应用的协议。其实就是定义一些固定的结构化数据。
表示层作用:设备固有数据格式和网络标准数据格式的转换。
设备固有数据格式其实就是在应用层的机构化数据,转化的网络标准数据是指 把应用层固有数据格式序列化之后可以进行网络传输的格式。
总结:在osi七层模型中序列化和反序列化在表示层进行。
Jsoncpp
Jsoncpp时用于处理JSON数据的C++库,提供将JSON数据序列化为字符串,以及将字符串反序列化为JSON数据。
序列化操作
#include<iostream>
#include<string>
using namespace std;
#include<jsoncpp/json/json.h>
int main(){
//序列化
Json::Value root;
root["name"]="lv";
root["sex"]="男";
root["age"]=18;
// string s=root.toStyledString();
// cout<<s<<endl;
// Json::FastWriter fastwrite;
// string s=fastwrite.write(root);
Json::StyledWriter Write;
string s=Write.write(root);
cout<<s<<endl;
return 0;
}
反序列化操作
#include<iostream>
#include<string>
using namespace std;
#include<jsoncpp/json/json.h>
int main(){
//反序列化
string json_string="{\\"name\\":\\"张三\\",\\"age\\":30,\\"city\\":\\"北京\\"}";//要序列化的字符串
Json::Value root;
Json::Reader reader;
bool OK=reader.parse(json_string,root);
string name=root["name"].asString();
int age=root["age"].asInt();
string city=root["city"].asString();
cout<<name<<endl;
cout<<age<<endl;
cout<<city<<endl;
return 0;
}
网络版计算器
大概思路:我们实现一个服务器版本的计算器,客户端把要极端的两个数发送给服务端,服务端根据客户端的运算请求对客户端传来的两个数进行运算,然后再把结果返回给客户端。
约定方案:
- 定义结构来表示我们需要交互的信息。一般是客户端定义要操作数和符合,整体发送给客户端
- 发送数据时将这个结构体按照一个规则转换为字符串,接收数据时再按相同规则转化为结构体
核心实现
Socket套接字模板化封装
说明:我们把Socket套接字常用的接口进行模板化封装实现,便于服务端和客户端进行使用。
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Common.hpp"
#include "Log.hpp"
#include "InetAddr.hpp"
using namespace std;
static const int defaultfd = 0;
// 本类对Socket进行模板化封装
int gbacklog = 8;
class Socket
{
// 基类实现一些虚方法
public:
// 定义一些虚函数
virtual ~Socket() {}
virtual void SocketOrDie() = 0;
virtual void BindOrDie(uint16_t port) = 0;
virtual void ListenOrDie(int backlog) = 0;
virtual shared_ptr<Socket> Accept(InetAddr *client) = 0;
virtual void Close() = 0;
virtual int Recv(string *out) = 0;
virtual int Send(const string &s) = 0;
virtual bool ConnectOrDie(string ip,uint16_t port)=0;
public:
// 实现一些函数
void BuildTcpSocketMethod(uint16_t port, int backlog = gbacklog)
{
// 实现一些虚函数
SocketOrDie();
BindOrDie(port);
ListenOrDie(backlog);
}
void BuildTcpClientMethod(){
SocketOrDie();
}
};
class TcpSocket : public Socket
{
public:
TcpSocket(int fd = defaultfd) : _sockfd(fd) {}
void SocketOrDie() override
{
_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (_sockfd < 0)
{
LOG(LogLevel::DEBUG) << "socket error!!!";
exit(SOCKERR);
}
LOG(LogLevel::INFO) << "socket sucess!!!";
}
void BindOrDie(uint16_t port) override
{
InetAddr local(port);
int n = bind(_sockfd, CONV(local.NetAddr()), local.NetAddrLen());
if (n < 0)
{
LOG(LogLevel::DEBUG) << "bind error!!!";
exit(BINDERR);
}
LOG(LogLevel::INFO) << "bind sucess!!!";
}
void ListenOrDie(int backlog) override
{
int n = listen(_sockfd, backlog);
if (n < 0)
{
LOG(LogLevel::DEBUG) << "listen error!!!";
exit(LISTENERR);
}
LOG(LogLevel::INFO) << "listen sucess!!!";
}
shared_ptr<Socket> Accept(InetAddr *client) override
{
sockaddr_in peer;
socklen_t len = sizeof(peer);
int fd = accept(_sockfd, CONV(peer), &len); // fd:进行通信的文件描述符
if (fd < 0)
{
LOG(LogLevel::DEBUG) << "accept false!!!";
return nullptr;
}
// 创建成功
// 把数据返回给client,带出去即可客户端信息
client->SetAddr(peer); // 把client信息带出去
return make_shared<TcpSocket>(fd);
}
bool ConnectOrDie(string ip,uint16_t port) override
{
InetAddr server(ip,port);
int n=connect(_sockfd,CONV(server.NetAddr()),server.NetAddrLen());
if(n<0){
LOG(LogLevel::WARNING)<<"connect error";
return false;
}
LOG(LogLevel::INFO)<<"connect sucess!!!";
return true;
}
int Recv(string *out) override
{
// 进行读取信息 out:输出行参数,可以把他认为是缓冲区
char buffer[1024];
ssize_t n = recv(_sockfd, buffer, sizeof(buffer) – 1, 0);
if (n > 0)
{
// 读取成功
buffer[n] = 0;
*out += buffer;
}
return n;
}
int Send(const string &s) override
{
// 发送信息
return send(_sockfd, s.c_str(), s.size(), 0);
}
void Close() override
{
if (_sockfd > 0)
{
close(_sockfd);
}
}
~TcpSocket()
{
}
private:
int _sockfd;
};
服务端代码
说明:服务端server,主要创建socket链接,等待客户端的请求链接,对客户端发来的请求通过
_ioservice函数回调处理。
#pragma once
#include <iostream>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/wait.h>
#include <functional>
#include "Socket.hpp"
#include "Common.hpp"
using namespace std;
using ioservice_t = function<void(shared_ptr<Socket> &sock, InetAddr &client)>;
class TcpServer
{
public:
TcpServer(uint16_t port, ioservice_t ioservice) : _port(port), _listensockptr(make_unique<TcpSocket>()), _isrunning(false), _ioservice(ioservice)
{
// 直接去调用Socket,完成创建,绑定监听
_listensockptr->BuildTcpSocketMethod(_port);
}
void Start()
{
// 启动服务进行accept
_isrunning = true;
while (true)
{
InetAddr client;
auto sock = _listensockptr->Accept(&client); // 进行accept后需要知道两个东西,一个是通信时的sockfd,一个时client的信息
if (sock == nullptr)
{
continue;
}
LOG(LogLevel::INFO) << "[" << client.StringAddr() << "] " << "accept sucess!!!";
// 建立完成之后开始进行业务处理//多进程模式进行处理
pid_t pid = fork();
if (pid < 0)
{
LOG(LogLevel::ERROR) << "fork error";
exit(FORKERR);
}
else if (pid == 0)
{
// 子进程,需要关闭监听sockfd
_listensockptr->Close();
if (fork() > 0)
{
exit(OK);
}
// 孙子进程去执行对应的任务
_ioservice(sock, client); // 进行回调处理
sock->Close();
exit(OK);
}
else
{
sock->Close();
waitpid(pid, nullptr, 0);
}
// sleep(20);
}
_isrunning = false;
}
~TcpServer() {}
private:
unique_ptr<Socket> _listensockptr;
uint16_t _port;
bool _isrunning;
ioservice_t _ioservice;
};
服务端回调处理代码
说明:核心逻辑就是对传来数据进行解封之后,计算传来的两个数。
// 该类主要实现功能的实现—计算功能的实现
#pragma once
#include <iostream>
#include <string>
#include "Log.hpp"
#include "Common.hpp"
#include "Protocol.hpp"
using namespace std;
class Netcal
{
public:
Netcal(){}
Response Excute(Request &rest)
{
// 进行计算任务
Response resp(0, 0); // 初始化:result:0 code:0
switch (rest.OPER())
{
case '+':
resp.RESULT((rest.X()+rest.Y()));
break;
case '-':
resp.RESULT((rest.X()-rest.Y()));
break;
case '*':
resp.RESULT((rest.X()*rest.Y()));
break;
case '/':
if(rest.Y()==0){
resp.CODE(1);
}else{
resp.RESULT((rest.X()/rest.Y()));
}
break;
default:
resp.CODE(2);//非法操作
break;
}
return resp;
}
};
客户端代码
说明:客户端发送计算请求,接收来自服务端的回应。
#include <iostream>
#include "Log.hpp"
#include "Socket.hpp"
#include "Protocol.hpp"
using namespace std;
void GetDataFromStdin(int *x, int *y, char *oper)
{
cout << "please enter x:";
cin >> *x;
cout << "please enter y:";
cin >> *y;
cout << "please enter oper:";
cin >> *oper;
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
LOG(LogLevel::ERROR) << "./client ip port";
exit(-1);
}
string ip = argv[1];
uint16_t port = stoi(argv[2]);
// 创建socket 并进行链接
shared_ptr<Socket> sock = make_shared<TcpSocket>();
sock->BuildTcpClientMethod();
if(sock->ConnectOrDie(ip,port)<0){
LOG(LogLevel::ERROR)<<"connect error";
exit(CONNECTERR);
}
//这里就一定连接成功了
unique_ptr<Protocol> pto = make_unique<Protocol>();
string resp_buffer; // 客户端收到服务端回显信息的缓冲区
while (true)
{
//能发送的数据包格式:50 \\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
// 发送一个请求字符串 客户端进行输入
int x, y;
char oper;
GetDataFromStdin(&x, &y, &oper); // 重键盘获取输入x,y,z数据
string req_str = pto->BuildRequestString(x, y, oper);
cout<<"—对发送数据进行封装—–"<<endl;
cout<<req_str;
cout<<"—对发送数据进行封装—–"<<endl;
//req_str:50 \\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
// req_str:就是可以直接进行发送的字符产数据报文了
int n=sock->Send(req_str);
if(n<0){
//没有发送成功
continue;
}
// 成功发送后要获取服务的回答
Response resp;//构建的一个请求
//resp_buffer:客户端接收缓冲区,所有接收数据都会放在resp_buffer缓冲区中,然后再区处理
if(pto->GetResponse(sock, resp_buffer, &resp)==false){
resp.ShowResult();
break;
}
// 这个我们可以获得respon内容
resp.ShowResult(); //打印出计计算结果
}
sock->Close();
return 0;
}
自定义协议
说明:规定一些协议,对发送请求和应答设置一套约定好的形式。对请求和应答分别进行序列和反序列化。
// 该类实现一些协议
#pragma once
#include <iostream>
#include <string>
#include <functional>
#include "Socket.hpp"
#include "InetAddr.hpp"
#include <jsoncpp/json/json.h>
using namespace std;
// Request —>client发消息给服务 端
const string sep = "\\r\\n";
class Request
{
public:
Request() {}
Request(int x, int y, char oper) : _x(x), _y(y), _oper(oper)
{
}
string Serialization()
{
// 序列化—>发消息时,结构化数据转为字符串
Json::Value Root;
Root["x"] = _x;
Root["y"] = _y;
Root["oper"] = _oper;
Json::FastWriter Write;
string s = Write.write(Root);
return s;
}
bool Deserialization(string &in)
{
// 反序列化–>接收消息时需要进行反序列化
Json::Value Root;
Json::Reader reader;
bool OK = reader.parse(in, Root);
// 把字符串读取到Root中
_x = Root["x"].asInt();
_y = Root["y"].asInt();
_oper = Root["oper"].asInt();
return OK;
}
int X() { return _x; }
int Y() { return _y; }
char OPER() { return _oper; }
~Request() {}
private:
int _x;
int _y;
char _oper;
};
// Response —->server返回请求结果
class Response
{
public:
Response() {}
Response(int result, int code) : _result(result), _code(code) {}
string Serialization()
{
// 序列化—>发消息时,结构化数据转为字符串
// TCP全双工,也会进行收发操作
Json::Value root;
root["_result"] = _result;
root["_code"] = _code;
Json::FastWriter Write;
string s = Write.write(root);
return s;
}
bool Deserialization(string &s)
{
// 反序列化–>接收消息时需要进行反序列化
Json::Value root;
Json::Reader reader;
bool OK = reader.parse(s, root);
_result = root["_result"].asInt();
_code = root["_code"].asInt();
return OK;
}
void ShowResult(){
cout<<"计算结果是:"<<_result<<"["<<_code<<"]"<<endl;
}
void RESULT(int result) { _result = result; }
void CODE(int code) { _code = code; }
~Response() {}
private:
int _result; // 只有结果还不行,可能计算的结果并不是符合要求的
int _code; // 设置0:正常 1,2,3,4,5异常退出
};
// 以上操作是对消息传送进行的序列化和反序列化
// 接下来就是要去指定一些协议,如何拿到完整的报文,并且解析报文
// 假设我们规定我传的数据报是:// 50\\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
using func_t = function<Response(Request &rest)>;
class Protocol
{
public:
Protocol(){}
Protocol(func_t func) : _func(func) {}
// 序列化的时候如何进行封装
string Encode(const string &jsonstr)
{
// jsonstr={"x": 10, "y" : 20, "oper" : '+'} //sep \\r\\n 50:代表长度
string jsonstr_len = to_string(jsonstr.size());
string s = jsonstr_len + sep + jsonstr+sep;
return s; // s=50\\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
}
// 如何进行解封装 50 \\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
bool Decode(string &buffer, string *packet)
{
// buffer::从缓冲区读取的所有内容 packet:数据报的输出参数,输出完整数据报
// 首先先找到分隔符
cout<<"—–Decode模块,进行数据提取——"<<endl;
ssize_t pos = buffer.find(sep);
if (pos == string::npos)
{
// 没有分隔符,代表没有数据
return false;
}
// 找到了分隔符,代表bufer有长度,但是buffer有长度但不一定有完整的报文,所以我们约定提取出一组完整报文
string packet_len = buffer.substr(0, pos);
int packet_len_int = stoi(packet_len);
int target_len = packet_len.size() + packet_len_int + 2 * sep.size(); // 完整报文的长度;
if (buffer.size() < target_len)
{
// 证明没有完整报文
return false;
}
// 说明存在完整报文
*packet = buffer.substr(pos + sep.size(), packet_len_int);
buffer.erase(0, target_len);
return true;
}
void GetRequest(shared_ptr<Socket> &sock, InetAddr &client)
{
// shared_ptr<Socket> &sock:进行通信的网络套接字
// InetAddr &client:传来的客户端
// 作为回调函数去处理、
cout<<"—-protocol模块,处理client传来的请求—-"<<endl;
string buffer_queue; // 定义的缓冲区
while (true)
{
// 进行读取来自客户端的信息,读取的信息放在buffer_queue中
int n = sock->Recv(&buffer_queue);
if (n > 0)
{
// 证明成功读到内容,仅仅是读取到了数据
// 读取到数据先进性提取完整报文,然后再进行反序列化
cout<<"——-reques_buffer_queue——-"<<endl;
cout<<buffer_queue;
cout<<"——-reques_buffer_queue——-"<<endl;
string packet;
bool ret = Decode(buffer_queue, &packet); // 进行提取完整报文
if (!ret)
{
// 没有完整报文继续读取内容·
continue;
}
// 成功读取到了完整的报文
cout<<"——-json_str——-"<<endl;
cout<<packet;
cout<<"——-json_str——-"<<endl;
// 进行反序列化
Request req;
bool ok = req.Deserialization(packet);
if (!ok)
{
// 证明没有反序列化成功,继续反序列化
continue;
}
cout<<"{\\r\\n"<<req.X()<<"\\r\\n"<<req.Y()<<"\\r\\n"<<req.OPER()<<"\\r\\n}"<<endl;
// 这里已经是反序列化成功,成功之后拿到相对应的数据,就开始进行处理数据
// 这里处理数据我们依旧用回调函数去处理
Response reps = _func(req); // 这里计算请求发出去,肯定会有计算返回结果,
// 接收到请求后,还要发送计算结果返回给客户端
// 先进行序列化
string json_str = reps.Serialization();
cout<<"—–respon_json_str—–"<<endl;
cout<<json_str;
cout<<"—–respon_json_str—–"<<endl;
// 然后进行添加报文长度
string Encode_str = Encode(json_str);
cout<<"—–respon_Encode_str—–"<<endl;
cout<<Encode_str;
cout<<"—–respon_Encode_str—–"<<endl;
// 然后进行发包
sock->Send(Encode_str);
}
else if (n == 0)
{
// 客户端关闭了
LOG(LogLevel::WARNING) << "client quite!!!";
exit(RECVERR);
}
else
{
// 读取出错
LOG(LogLevel::ERROR) << "发送失败";
exit(RECVERR);
}
}
}
bool GetResponse(shared_ptr<Socket> &sock, string &respon_str,Response *repon){
//sock:从哪个网络中接收信息 respon_str:接收信息的缓冲区,repon:输出型参数把最后从缓冲区读取的信息进行反序列化处理后,返回最后结果给客户端
while(true){
//从缓冲区中提取信息
sock->Recv(&respon_str);//信息被读取到了respin_str中
string json_packet;//这个作为输出型参数,存放结构化数据
//进行解码
bool ret=Decode(respon_str,&json_packet);
if(!ret)
{
//证明没有完整·的报文
continue;//继续读取数据
}
//到这里已已经提取出至少一种完整的结构化数据
cout<<"—-对数据进行解包—–"<<endl;
cout<<json_packet;
cout<<"—-对数据进行解包—–"<<endl;
//进行反序列哈
return repon->Deserialization(json_packet);//接收的信息 resulr /code
}
}
string BuildRequestString(int x,int y,char oper){
//构建出一个序列化后的,添加完整报文的字符串
//计算任务 x oper y 进行构建一个直接可以进行发的字符串
cout<<"—–进入BuildRequestString模块—–"<<endl;
Request res(x,y,oper);
//对数据进行序列化
string json_str=res.Serialization();
cout<<"—–对发送数据进行序列化—-"<<endl;
cout<<json_str;
cout<<"—–对发送数据进行序列化—-"<<endl;
//json_str:{"x": 10, "y" : 20, "oper" : '+'}
//序列化之后,对数据进行封装一下
return Encode(json_str);
//Encoed封装::50 \\r\\n{"x": 10, "y" : 20, "oper" : '+'}\\r\\n
}
~Protocol() {}
private:
func_t _func;
};
完整代码地址
https://gitee.com/lvpanhao/2026/commit/19e4cf0624689ebb4d2d749fbc7c12f10bcebd5b


