目录
- 一. 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
{
// 绑定 socket
int 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
{
// 绑定 socket
int 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
{
// 绑定 socket
int 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
{
// 绑定 socket
int 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
{
// 绑定 socket
int 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;
else
res = x / y;
}
break;
case '%':
{
if (y == 0)
code = 2;
else
res = 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
{
// 绑定 socket
int 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;
};
