目录
- 一. TCP 网络程序
- 简易计算器
- 1. 核心功能
- 2. 程序结构
- 3. 服务器初始化
- 4. 服务器启动
- 5. 业务处理
- 6. 客户端初始化
- 7. 客户端启动
- 二. 序列化与反序列化
- 1. 协议
- 2. 序列化与反序列化
一. TCP 网络程序
简易计算器
1. 核心功能
客户端向服务器发送数据, 服务器进行计算并返回结果;
2. 程序结构
程序由 Socket.hpp, InetAddr.hpp, Server.hpp, Server.cc, Client.hpp, Client.cc, Calculate.hpp 组成;
Socket.hpp套接字头文件 套接字的封装实现
#pragma once
#include "Log.hpp"
#include "InetAddr.hpp"
#include <iostream>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <memory>class Socket
{
};class TcpSocket : public Socket
{
public:private:int _sockfd; // socket 文件描述符
};
InetAddr.hppsockaddr_in 结构体头文件 存储 IP地址和端口号
#pragma once
#include <iostream>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>class InetAddr
{
private:void GetAddr(){_ip = inet_ntoa(_addr.sin_addr);_port = ntohs(_addr.sin_port);}public:InetAddr() {}// 传参构造InetAddr(const string& ip, const uint16_t& port): _ip(ip), _port(port){bzero(&_addr, sizeof(_addr)); // 置零_addr.sin_family = AF_INET; // 设置 16 位地址类型_addr.sin_addr.s_addr = inet_addr(_ip.c_str()); // 设置 IP地址, 转类型和网络字节序_addr.sin_port = htons(_port); // 设置 端口号, 转网络字节序}// 拷贝构造InetAddr(const sockaddr_in &addr) : _addr(addr){GetAddr();}// 返回 IP地址string Ip() const{return _ip;}// 返回 端口号 uint16_t Port() const{return _port;}// 返回 sockaddr_in 结构体const sockaddr_in &Addr() const{return _addr;}~InetAddr(){}private:sockaddr_in _addr;string _ip;uint16_t _port;
};
Server.hpp服务端头文件 服务端的实现
#include "Socket.hpp" class TpcServer
{
public:// 初始化TpcServer() : _running(0){}// 运行void Start(){}~TpcServer(){}private:bool _isrunning; // 状态
};
Server.cc服务端源文件 启动并运行服务器
#include "Server.hpp"int main(int argc, char *argv[])
{TpcServer tpc();tpc.Start();return 0;
}
Client.hpp客户端头文件 客户端的实现
#pragma once
#include "Socket.hpp"class TpcClient
{
public:TpcClient() : _running(0){}void Start(){}~TpcClient(){}private:bool _running = 0;
};
Client.cc客户端源文件 启动并运行客户端
#include "Client.hpp"int main(int argc, char* argv[])
{TpcClient client();client.Start();return 0;
}
Calculate.hpp计算器头文件 实现计算器功能
#pragma once
#include <iostream>
#include <string> class Calculate
{
public:};
3. 服务器初始化
使用 TCP 协议实现的网络程序需要创建套接字, 绑定 IP地址 和端口号;
那么在 Socket 头文件声明并实现方法;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0){close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}private:int _sockfd; // socket 文件描述符
};
注: TCP 协议是面向字节流的, 套接字在创建时, 第二个参数应为 SOCK_STREAM;
并且 TCP 协议是面向连接的, 服务器在初始化时, 需要设置服务器为监听状态, 使用 listen() 函数;
#include <sys/types.h>
#include <sys/socket.h>int listen(int sockfd, int backlog);
-
参数:
sockfd: 监听的套接字;
backlog: 全连接队列最大长度(通常为16, 32, 64… 等整数); -
返回值:
若成功, 返回 0; 若失败, 返回 -1;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;// 设置监听状态virtual void Listen() = 0;
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0) // 关闭套接字{close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}// 设置监听状态virtual void Listen() override{int n = listen(_sockfd, 16);if (n < 0) // 若失败{LOG(FATAl, "listen fail");exit(1);}}private:int _sockfd; // socket 文件描述符
};
至此套接字的初始化的已经准备好了, 并且将初始化相关函数封装为一个函数;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;// 设置监听状态virtual void Listen() = 0;// 服务端创建 TCP 套接字virtual void CreateTcpServer(const InetAddr &addr){Create();Bind(addr);Listen();}
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0) // 关闭套接字{close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}// 设置监听状态virtual void Listen() override{int n = listen(_sockfd, 16);if (n < 0) // 若失败{LOG(FATAl, "listen fail");exit(1);}}private:int _sockfd; // socket 文件描述符
};
那么就可以初始化服务端了;
在 服务端类 中包含 TcpSocket 套接字, 并且初始化时需要设置 InetAddr 地址信息;
Server.hpp服务端头文件
#include "Socket.hpp" class TpcServer
{
public:// 服务端初始化 _localaddr的 "0" 相当于 INADDR_ANY 绑定任意可用IP地址;TpcServer(InetAddr addr = {"0", 8888}):_localaddr(addr), _listensock(make_unique<TcpSocket>()), _isrunning(0){_listensock->CreateTcpServer(_localaddr); // 套接字初始化cout << " seccess " << endl; }void Start(){}~TpcServer(){}private:InetAddr _localaddr; // 本地地址信息std::unique_ptr<Socket> _listensock;// Tpc 套接字bool _isrunning; // 服务器状态
};
就可以创建服务器了;
Server.cc服务端源文件
#include "Server.hpp"int main(int argc, char *argv[])
{// 创建服务器TpcServer tpc();return 0;
}
4. 服务器启动
TCP 是面向连接的, 当客户端发起连接请求时, TCP 服务端需要处理连接请求; 当连接成功后, 就可以进行通信, 使用 accept 函数进行连接;
#include <sys/types.h>
#include <sys/socket.h>int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
-
参数:
sockfd: 服务端设置监听状态的套接字;
addr: 输出型参数, 客户端的 sockaddr 结构体信息; 若不在意, 可以设置为空;
addrlen: 输出型参数, 客户端的 sockaddr 结构体长度; 若不在意, 可以设置为空; -
返回值:
若成功, 返回一个用于通信的 socket 套接字(文件描述符); 若失败, 返回 -1;
通过 accept 可以得知, 服务端一开始初始化的套接字并非用于通信, 而是处理连接请求的, 也被称为监听套接字;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;// 设置监听状态virtual void Listen() = 0;// 处理连接请求virtual shared_ptr<Socket> Accept() = 0;virtual shared_ptr<Socket> Accept(InetAddr& peer) = 0;// 服务端创建 TCP 套接字virtual void CreateTcpServer(const InetAddr &addr){Create();Bind(addr);Listen();}
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0) // 关闭套接字{close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}// 设置监听状态virtual void Listen() override{int n = listen(_sockfd, 16);if (n < 0) // 若失败{LOG(FATAl, "listen fail");exit(1);}}// 处理连接请求virtual shared_ptr<Socket> Accept() override{int fd = accept(_sockfd, nullptr, nullptr);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}return make_shared<TcpSocket>(fd);}virtual shared_ptr<Socket> Accept(InetAddr& peer) override{sockaddr_in addr; // sockaddr 结构socklen_t len = sizeof(addr);int fd = accept(_sockfd, (sockaddr *)&addr, &len);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}peer = addr;// cout << peer.Ip() << " " << peer.Port() << endl;return make_shared<TcpSocket>(fd);}private:int _sockfd; // socket 文件描述符
};
Server.hpp服务端头文件
#include "Socket.hpp" class TpcServer
{
public:// 服务端初始化 _localaddr的 "0" 相当于 INADDR_ANY 绑定任意可用IP地址;TpcServer(InetAddr addr = {"0", 8888}):_localaddr(addr), _listensock(make_unique<TcpSocket>()), _isrunning(0){_listensock->CreateTcpServer(_localaddr); // 套接字初始化cout << " seccess " << endl; }// 服务端启动void Start(){_isrunning = 1;while (_isrunning){// InetAddr scr; // 对端结构体;// shared_ptr<Socket> fd = _listensock->Accept(scr);shared_ptr<Socket> fd = _listensock->Accept();if (fd == nullptr) continue; // 若连接失败, 继续连接// Serve(fd); // 功能模块}}~TpcServer(){}private:InetAddr _localaddr; // 本地地址信息std::unique_ptr<Socket> _listensock;// Tpc 套接字bool _isrunning; // 服务器状态
};
5. 业务处理
当服务器启动后, 需要获取数据, 进行业务处理, 返回结果;
TCP 协议是面向字节流的, 并且通过 accept() 函数返回的 socket 套接字(文件描述符) 进行通信, 所以可以使用文件相关接口进行通信;
在 套接字 头文件中增加接收, 发送函数的声明实现;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;// 设置监听状态virtual void Listen() = 0;// 处理连接请求virtual shared_ptr<Socket> Accept() = 0;virtual shared_ptr<Socket> Accept(InetAddr& peer) = 0;// 接收数据virtual int Recv(std::string& out) = 0;// 发送数据virtual int Send(std::string& in) = 0;// 服务端创建 TCP 套接字virtual void CreateTcpServer(const InetAddr &addr){Create();Bind(addr);Listen();}
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0) // 关闭套接字{close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}// 设置监听状态virtual void Listen() override{int n = listen(_sockfd, 16);if (n < 0) // 若失败{LOG(FATAl, "listen fail");exit(1);}}// 处理连接请求virtual shared_ptr<Socket> Accept() override{int fd = accept(_sockfd, nullptr, nullptr);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}return make_shared<TcpSocket>(fd);}virtual shared_ptr<Socket> Accept(InetAddr& peer) override{sockaddr_in addr; // sockaddr 结构socklen_t len = sizeof(addr);int fd = accept(_sockfd, (sockaddr *)&addr, &len);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}peer = addr;// cout << peer.Ip() << " " << peer.Port() << endl;return make_shared<TcpSocket>(fd);}// 接收数据virtual int Recv(std::string& out) override{char buf[1024];int n = recv(_sockfd, buf, sizeof(buf)-1, 0);buf[n] = 0;out = buf;return n;}// 发送数据virtual int Send(std::string& in) override{int n = send(_sockfd, in.c_str(), in.size(), 0);if (n < 0) // 若失败{LOG(FATAl, "send fail");}return n;}private:int _sockfd; // socket 文件描述符
};
在 服务端 源文件中添加业务处理函数, 用于接收数据, 业务处理和发送结果;
Server.cc服务端源文件
#include "Server.hpp"// 业务处理
void Serve(shared_ptr<Socket> &sockfd)
{// 缓冲区string buf;while (1){// 接收数据int n = sockfd->Recv(buf);if (n <= 0){LOG(FATAl, "Recv fail");break;}// 回调具体的处理模块buf = calculate(buf);// 发送结果sockfd->Send(buf);}
}int main(int argc, char *argv[])
{// 创建服务器TpcServer tpc();return 0;
}
那么真正的计算模块在 计算器 头文件中;
对于计算器的输入和输出, 这里就先规定:
- 输入的字符串共三个参数, 以空格为分隔, 前两个为操作数, 第三个为操作符;
- 输出的字符串共两个参数, 第一个表示计算结果, 第二个表示错误码(结果是否正确);
Calculate.hpp计算器头文件
#pragma once
#include <iostream>
#include <string> class Calculate
{
public:std::string Excute(const std::string &msg){// 获取操作数和操作符int pos1 = msg.find(' ');int pos2 = msg.rfind(' ');int x = atoi(msg.substr(0, pos1).c_str());int y = atoi(msg.substr(pos1+1, pos2).c_str());char oper = msg[pos2+1];// 计算结果 和 状态int res, code = 0;switch (oper){case '+':res = x + y;break;case '-':res = x - y;break;case '*':res = x * y;break;case '/':{if (y == 0)code = 1;elseres = x / y;}break;case '%':{if (y == 0)code = 2;elseres = x % y;}break;default:code = 3;break;}return std::to_string(res) + " " + std::to_string(code);}~Calculate(){}
};
至此, 就可以在 服务端 源文件中, 将回调函数传参至 服务端 类中;
Server.cc服务端源文件
#include "Server.hpp"
#include "Calculate.hpp"using call_back = function<string(string)>;
// 业务处理
void Serve(call_back cb, shared_ptr<Socket> &sockfd)
{// 缓冲区string buf;while (1){// 接收数据// int n = sockfd->Recv(buf);// if (n <= 0)// {// LOG(FATAl, "Recv fail");// break;// }// 测试getline(cin, buf);// 回调具体的处理模块buf = cb(buf);// 测试cout << buf << endl;exit(0);// 发送结果// sockfd->Send(buf);}
}int main(int argc, char *argv[])
{// 创建计算模块Calculate c;call_back cb = bind(&Calculate::Excute, &c, placeholders::_1);// 创建服务器TpcServer tpc(bind(&Serve, cb, placeholders::_1));tpc.Start();return 0;
}
Server.hpp服务端头文件
#include "Socket.hpp" class TpcServer;
using func_t = function<void(shared_ptr<Socket>&)>;class TpcServer
{
public:// 服务端初始化 _localaddr的 "0" 相当于 INADDR_ANY 绑定任意可用IP地址;TpcServer(func_t func, InetAddr addr = {"0", 8888}): _localaddr(addr), _listensock(make_unique<TcpSocket>()), _isrunning(0), _func(func){_listensock->CreateTcpServer(_localaddr); // 套接字初始化cout << " seccess " << endl; }// 服务端启动void Start(){_isrunning = 1;while (_isrunning){// shared_ptr<Socket> fd = _listensock->Accept();// if (fd == nullptr) continue; // 若连接失败, 继续连接// 测试shared_ptr<Socket> fd;_func(fd); // 功能模块}}~TpcServer(){}private:InetAddr _localaddr; // 本地地址信息std::unique_ptr<Socket> _listensock;// Tpc 套接字bool _isrunning; // 服务器状态func_t _func; // 业务处理
};
6. 客户端初始化
客户端的初始化就简单许多, 客户端只需要创建套接字, 申请连接即可, 不需要显示绑定端口号;
并且由于客户端是主动申请连接的, 所以不需要设置监听状态;
客户端需要使用 connect() 函数向服务端发送连接申请;
#include <sys/types.h>
#include <sys/socket.h>int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
-
参数:
sockfd: 申请连接的套接字(当前客户端套接字);
addr: 服务端的 sockaddr 结构体;
addrlen: 服务端的 sockaddr 结构体长度; -
返回值:
若成功, 返回 0; 若失败, 返回 -1;
同样在 Socket 头文件封装客户端的初始化;
Socket.hpp套接字头文件
class Socket
{
public:// 创建套接字virtual void Create() = 0;// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) = 0;// 设置监听状态virtual void Listen() = 0;// 处理连接请求virtual shared_ptr<Socket> Accept() = 0;virtual shared_ptr<Socket> Accept(InetAddr& peer) = 0;// 发出连接请求virtual bool Connect(const InetAddr &addr) = 0;// 接收数据virtual int Recv(std::string& out) = 0;// 发送数据virtual int Send(std::string& in) = 0;// 服务端创建 TCP 套接字virtual void CreateTcpServer(const InetAddr &addr){Create();Bind(addr);Listen();}// 客户端创建 TCP 套接字virtual bool CreateTcpClient(const InetAddr &addr){Create();return Connect(addr);}
};// Tcp 套接字
class TcpSocket : public Socket
{
public:TcpSocket(int fd = -1) : _sockfd(fd) {}virtual ~TcpSocket() override{if (_sockfd >= 0) // 关闭套接字{close(_sockfd);_sockfd = -1;}// cout << " ~TcpSocket " <<endl;}// 创建套接字virtual void Create() override{// 创建 socket 文件描述符_sockfd = socket(AF_INET, SOCK_STREAM, 0);if (_sockfd < 0) // 若创建失败{LOG(FATAl, "socket fail");exit(1);}}// 绑定 IP地址 端口号virtual void Bind(const InetAddr &addr) override{// 绑定 socketint n = bind(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "bind fail"); // 打印日志exit(1);}}// 设置监听状态virtual void Listen() override{int n = listen(_sockfd, 16);if (n < 0) // 若失败{LOG(FATAl, "listen fail");exit(1);}}// 处理连接请求virtual shared_ptr<Socket> Accept() override{int fd = accept(_sockfd, nullptr, nullptr);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}return make_shared<TcpSocket>(fd);}virtual shared_ptr<Socket> Accept(InetAddr& peer) override{sockaddr_in addr; // sockaddr 结构socklen_t len = sizeof(addr);int fd = accept(_sockfd, (sockaddr *)&addr, &len);if (fd < 0) // 若失败{LOG(FATAl, "accept fail");return nullptr;}peer = addr;// cout << peer.Ip() << " " << peer.Port() << endl;return make_shared<TcpSocket>(fd);}// 发出连接请求virtual bool Connect(const InetAddr &addr) override{int n = connect(_sockfd, (sockaddr *)&addr.Addr(), sizeof(addr.Addr()));if (n < 0) // 若失败{LOG(FATAl, "connect fail");return 0;}return 1;}// 接收数据virtual int Recv(std::string& out) override{char buf[1024];int n = recv(_sockfd, buf, sizeof(buf)-1, 0);buf[n] = 0;out = buf;return n;}// 发送数据virtual int Send(std::string& in) override{int n = send(_sockfd, in.c_str(), in.size(), 0);if (n < 0) // 若失败{LOG(FATAl, "send fail");}return n;}private:int _sockfd; // socket 文件描述符
};
Client.hpp客户端头文件
#pragma once
#include "Socket.hpp"class TpcClient
{
public:TpcClient(const InetAddr &addr = {"127.0.0.1", 8888}) // 端口号: _hostaddr(addr), _listensock(make_unique<TcpSocket>()), _running(0){_listensock->CreateTcpClient(_hostaddr);}void Start(){}~TpcClient(){}private:InetAddr _hostaddr;std::unique_ptr<Socket> _listensock;bool _running = 0;
};
Client.cc客户端源文件
#include "Client.hpp"int main(int argc, char* argv[])
{TpcClient client();// client.Start();return 0;
}
7. 客户端启动
客户端的启动只需要从用户输入获取数据, 发送至服务端, 获取结果即可, 套接字同样可以使用 write(), read() 进行通信;
Client.hpp客户端头文件
#pragma once
#include "Socket.hpp"class TpcClient
{
public:TpcClient(const InetAddr &addr = {"127.0.0.1", 8888}) // 端口号: _hostaddr(addr), _listensock(make_unique<TcpSocket>()), _running(0){_listensock->CreateTcpClient(_hostaddr);}void Start(){// 缓冲区string buf;while (1){// 获取数据getline(cin, buf);// 发送数据int n = _listensock->Send(buf);// 接收结果_listensock->Recv(buf);if (n <= 0){LOG(FATAl, "Recv fail");break;}cout << buf << endl;}}~TpcClient(){}private:InetAddr _hostaddr;std::unique_ptr<Socket> _listensock;bool _running = 0;
};
Client.cc客户端源文件
#include "Client.hpp"int main(int argc, char* argv[])
{TpcClient client();client.Start();return 0;
}
至此就实现了 TCP 协议的简易计算器;
二. 序列化与反序列化
1. 协议
协议是通信的基础, 是通信的双方必须遵守的"约定";
上文 计算器的输入和输出的规定, 就类似协议, 只有按照特定的格式输入或读取, 数据才是有效的;
2. 序列化与反序列化
序列化是指将一个或多个需要传递的数据, 按照一定的格式, 拼接为一条数据; 反序列化则是将收到的数据按照格式解析; 类似上文 从字符串中获取操作数和操作符 的操作;
由于上文中的协议关于简单, 并且 TCP 协议 不同于 UDP 协议, UDP 协议是面向数据报的, 当多次发送时, 发送的是多个数据报, 并不影响接收或读取;
而 TCP 协议多次发送数据时, 数据会堆积在缓冲区当中, 无法得知单次接收数据的大小;
在此新增一个 Protocol.hpp 文件, 规范协议和序列化与反序列化;
Protocol.hpp协议头文件
#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>// 协议
class Protocol
{
public:// 添加前缀和后缀std::string Encode(const std::string& json_str){}// 删除前缀和后缀std::string Decode(std::string& json_str){}};class Request : public Protocol
{
public:// 构造函数Request() {}Request(int x, int y, char oper) : _x(x), _y(y), _oper(oper) {}// 序列化bool Serialize(std::string& out){}// 反序列化bool DeSerialize(std::string& in){}int _x; // 操作数int _y; // 操作数char _oper; // 操作符
};class Response : public Protocol
{
public:Response() {}Response(int result, int code) : _result(result), _code(code) {}// 序列化bool Serialize(std::string& out){}// 反序列化bool DeSerialize(std::string& in){}int _result; // 结果int _code; // 错误码
};
Request 类 包含操作数和操作符;
Response 类 包含结果和错误码;
Serialization(): 将类中的成员根据协议要求, 拼接成一个字符串;
Deserialization(): 将字符串根据格式进行拆解;
可以使用 json, protobuf, xml 等序列化协议帮助实现序列化与反序列化;
Protocol.hpp协议头文件
#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>// 协议
class Protocol
{
public:// 添加报头和分隔符std::string Encode(const std::string& json_str){}// 删除报头和分隔符std::string Decode(std::string& json_str){}};class Request : public Protocol
{
public:// 构造函数Request() {}Request(int x, int y, char oper) : _x(x), _y(y), _oper(oper) {}// 序列化bool Serialize(std::string& out){Json::Value value;value["x"] = _x;value["y"] = _y;value["oper"] = _oper;Json::FastWriter writer;out = writer.write(value);return true;}// 反序列化bool DeSerialize(std::string& in){Json::Value value;Json::Reader reader;if (!reader.parse(in, value))return false;_x = value["x"].asInt();_y = value["y"].asInt();_oper = value["oper"].asInt();return true;}int _x; // 操作数int _y; // 操作数char _oper; // 操作符
};class Response : public Protocol
{
public:Response() {}Response(int result, int code) : _result(result), _code(code) {}// 序列化bool Serialize(std::string& out){Json::Value value;value["result"] = _result;value["code"] = _code;Json::FastWriter writer;out = writer.write(value);return true;}// 反序列化bool DeSerialize(std::string& in){Json::Value value;Json::Reader reader;if (!reader.parse(in, value))return false;_result = value["result"].asInt();_code = value["code"].asInt();return true;}int _result; // 结果int _code; // 错误码
};
至此, 序列化与反序列化依旧封装完毕, 但依旧未解决接收的问题;
所以对于序列化后的字符串进一步规定:
数据在发送前, 添加数据长度, 并且以 “\r\n” 为分隔, 进一步封装, 添加报头和分隔符;
在接收后, 删除报头和分隔符;
Protocol.hpp协议头文件
#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>// 协议
class Protocol
{const std::string SEP = "\r\n"; // 分隔符
public:// 添加报头和分隔符std::string Encode(const std::string& json_str){int n = json_str.size();std::string ret = std::to_string(n) + SEP + json_str + SEP;return ret;}// 删除报头和分隔符std::string Decode(std::string& json_str){int total = json_str.size();int pos = json_str.find(SEP);// 当未找到分隔符时, 返回if (pos == std::string::npos) return {};auto str_len = json_str.substr(0, pos);int packlen = atoi(str_len.c_str());// 当报头, 分隔符, 有效载荷的大小 大于 接收数据的总大小时, 返回if (str_len.size()+packlen+SEP.size()*2 > total) return {};std::string ret = json_str.substr(pos+SEP.size(), packlen);json_str.erase(0, total);return ret;}};class Request : public Protocol
{
public:// 构造函数Request() {}Request(int x, int y, char oper) : _x(x), _y(y), _oper(oper) {}// 序列化bool Serialize(std::string& out){Json::Value value;value["x"] = _x;value["y"] = _y;value["oper"] = _oper;Json::FastWriter writer;out = writer.write(value);return true;}// 反序列化bool DeSerialize(std::string& in){Json::Value value;Json::Reader reader;if (!reader.parse(in, value))return false;_x = value["x"].asInt();_y = value["y"].asInt();_oper = value["oper"].asInt();return true;}int _x; // 操作数int _y; // 操作数char _oper; // 操作符
};class Response : public Protocol
{
public:Response() {}Response(int result, int code) : _result(result), _code(code) {}// 序列化bool Serialize(std::string& out){Json::Value value;value["result"] = _result;value["code"] = _code;Json::FastWriter writer;out = writer.write(value);return true;}// 反序列化bool DeSerialize(std::string& in){Json::Value value;Json::Reader reader;if (!reader.parse(in, value))return false;_result = value["result"].asInt();_code = value["code"].asInt();return true;}int _result; // 结果int _code; // 错误码
};
注: 在接收数据时, 若数据大小 小于 报头+分隔符+有效载荷的大小, 那么说明接收的数据不完整, 继续接收;
那么 套接字 的 接收函数就需要小改动, 需要将 out = buf, 更改为 out += buf;
Socket.hpp套接字头文件
// 接收数据
virtual int Recv(std::string& out) override
{char buf[1024];int n = recv(_sockfd, buf, sizeof(buf)-1, 0);buf[n] = 0;out += buf;return n;
}
并且将 Calculate.hpp 添加 Protocol.hpp, 参数和返回值分别更改为 Request 和 Response;
Calculate.hpp计算器头文件
#include "Protocol.hpp"class Calculate
{
public:Response Excute(const Request &req){Response resp(0, 0);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;}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;}~Calculate(){}
};
服务端源文件的业务处理函数修改;
Server.cc服务端源文件
#include "Server.hpp"
#include "Calculate.hpp"
#include "Protocol.hpp"using call_back = function<Response(Request)>;
// 业务处理
void Serve(call_back cb, shared_ptr<Socket> &sockfd)
{// 缓冲区Request req;string buf;while (1){// 接收数据int n = sockfd->Recv(buf);if (n <= 0){LOG(FATAl, "Recv fail");break;}// 反序列化string package = req.Decode(buf);if (package.empty())continue;cout << package << endl;req.DeSerialize(package);// 回调Response resp = cb(req);// 序列化resp.Serialize(package);package = resp.Encode(package);// 发送sockfd->Send(package);}
}int main(int argc, char *argv[])
{// 创建计算模块Calculate c;call_back cb = bind(&Calculate::Excute, &c, placeholders::_1);// 创建服务器TpcServer tpc(bind(&Serve, cb, placeholders::_1));tpc.Start();return 0;
}
客户端的业务处理函数修改;
Client.hpp客户端头文件
#pragma once
#include "Socket.hpp"
#include "Protocol.hpp"class TpcClient
{
public:TpcClient(const InetAddr &addr = {"127.0.0.1", 8888}) // 端口号: _hostaddr(addr), _listensock(make_unique<TcpSocket>()), _running(0){_listensock->CreateTcpClient(_hostaddr);}void Start(){_running = 1;// 缓冲区string buf;int x, y;char oper;while (1){// 输入cin >> x >> y >> oper;Request req(x, y, oper);// 序列化string package;req.Serialize(package);package = req.Encode(package);// 发送_listensock->Send(package);// 接收package.clear();int n = _listensock->Recv(package);if (n <= 0){LOG(FATAl, "Recv fail");break;}// 反序列化Response resp;package = resp.Decode(package);if (package.empty())continue;resp.DeSerialize(package);// 输出cout << package << endl;}}~TpcClient(){}private:InetAddr _hostaddr;std::unique_ptr<Socket> _listensock;bool _running = 0;
};
