阅读量:0
应用层：自定义网络协议：序列化和反序列化，如果是TCP传输的：还要关心区分报文边界（在序列化设计的时候设计好）——粘包问题
——两个问题：粘包、序列化反序列化
1、首先想要使用TCP协议传输的网络，服务器和客户端都应该要创建自己的套接字，因为两个都要创建，所以我们把套接字封装为一个类：
封装方法：设计模式：模版方法：先写一个模版类（基类），里面有各种函数，然后再写一个派生类里面有各种方法的实现，创建对象的时候
#pragma once #include <iostream> #include <string> #include <cstring> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #define Convert(addrptr) ((struct sockaddr *)addrptr) namespace Net_Work { const static int defaultsockfd = -1; const int backlog = 5; enum { SocketError = 1, BindError, ListenError, }; // 封装一个基类，Socket接口类 // 设计模式：模版方法类 class Socket { public: virtual ~Socket() {} virtual void CreateSocketOrDie() = 0; virtual void BindSocketOrDie(uint16_t port) = 0; virtual void ListenSocketOrDie(int backlog) = 0; virtual Socket *AcceptConnection(std::string *peerip, uint16_t *peerport) = 0; virtual bool ConnectServer(std::string &serverip, uint16_t serverport) = 0; virtual int GetSockFd() = 0; virtual void SetSockFd(int sockfd) = 0; virtual void CloseSocket() = 0; virtual bool Recv(std::string *buffer, int size) = 0; // TODO public: // 创建服务器端的套接字，并设置为监听状态监听套接字 void BuildListenSocketMethod(uint16_t port, int backlog) { CreateSocketOrDie(); BindSocketOrDie(port); ListenSocketOrDie(backlog); } // 创建客户端的套接字，并且申请链接 bool BuildConnectSocketMethod(std::string &serverip, uint16_t serverport) { CreateSocketOrDie(); return ConnectServer(serverip, serverport); } void BuildNormalSocketMethod(int sockfd) { SetSockFd(sockfd); } }; class TcpSocket : public Socket { public: TcpSocket(int sockfd = defaultsockfd) : _sockfd(sockfd) { } ~TcpSocket() { } void CreateSocketOrDie() override // 创建套接字 { _sockfd = ::socket(AF_INET, SOCK_STREAM, 0); if (_sockfd < 0) exit(SocketError); } void BindSocketOrDie(uint16_t port) override // 绑定套接字 { struct sockaddr_in local; memset(&local, 0, sizeof(local)); local.sin_family = AF_INET; local.sin_addr.s_addr = INADDR_ANY; local.sin_port = htons(port); int n = ::bind(_sockfd, Convert(&local), sizeof(local)); if (n < 0) exit(BindError); } void ListenSocketOrDie(int backlog) override // 设置套接字为监听状态 { int n = ::listen(_sockfd, backlog); if (n < 0) exit(ListenError); } // 获取链接套接字——服务器 Socket *AcceptConnection(std::string *peerip, uint16_t *peerport) override { struct sockaddr_in peer; socklen_t len = sizeof(peer); int newsockfd = ::accept(_sockfd, Convert(&peer), &len); if (newsockfd < 0) return nullptr; *peerport = ntohs(peer.sin_port); *peerip = inet_ntoa(peer.sin_addr); Socket *s = new TcpSocket(newsockfd); return s; } // 申请链接——客户端 bool ConnectServer(std::string &serverip, uint16_t serverport) override { struct sockaddr_in server; memset(&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_addr.s_addr = inet_addr(serverip.c_str()); server.sin_port = htons(serverport); int n = ::connect(_sockfd, Convert(&server), sizeof(server)); if (n == 0) return true; else return false; } int GetSockFd() override { return _sockfd; } void SetSockFd(int sockfd) override { _sockfd = sockfd; } void CloseSocket() override { if (_sockfd > defaultsockfd) ::close(_sockfd); } bool Recv(std::string *buffer, int size)//接收消息到buffer中 { char inbuffer[size]; ssize_t n = recv(_sockfd, inbuffer, size - 1, 0); if (n > 0) { inbuffer[n] = 0; *buffer += inbuffer; return true; } else if (n == 0 || n < 0) return false; } private: int _sockfd; }; } 创建服务器：
1、创建套接字
2、把套接字设置为监听状态
3、获取连接，产生新的套接字
4、把新的套接字作为新线程的参数传到新线程执行的代码中，实现收发消息的操作
代码：
#pragma once #include"Socket.hpp" #include<pthread.h> #include<functional> using func_t=std::function<void(Net_Work::Socket* sockp)>; //服务器类 class TcpServer; class ThreadData { public: ThreadData(TcpServer*tcp_this, Net_Work::Socket *sockp): _this(tcp_this), _sockp(sockp) {} public: TcpServer *_this; Net_Work::Socket *_sockp; }; class TcpServer { public: TcpServer(uint16_t port, func_t handler_request):_port(port),_listensocket(new Net_Work::TcpSocket()),_handler_request(handler_request) { _listensocket->BuildListenSocketMethod(_port,Net_Work::backlog); } static void *ThreadRun(void *args) { pthread_detach(pthread_self());//分离线程 ThreadData *td=static_cast<ThreadData*>(args); td->_this->_handler_request(td->_sockp); td->_sockp->CloseSocket(); delete td->_sockp; delete td; return nullptr; } void Loop() { while(true) { //获取连接 std::string peerip; uint16_t peerport; Net_Work::Socket* newsock=_listensocket->AcceptConnection(&peerip,&peerport); if(newsock==nullptr) continue;; std::cout<<"获取了一个新链接,sockfd: "<<newsock->GetSockFd()<<"client info:"<< peerip<<":"<<peerport<<std::endl; //创建线程去完成此次sockfd收发 pthread_t tid; ThreadData *td=new ThreadData(this,newsock); pthread_create(&tid,nullptr,ThreadRun,td); } } ~TcpServer() { delete _listensocket; } private: int _port; Net_Work::Socket *_listensocket; public: func_t _handler_request; }; 客户端：
2、TCP是向字节流（字符串）
序列化、反序列化
自定义协议就是定义双方都认识的结构化字段，并且协议中有序列化和反序列化的实现
先定义一个协议（结构化字段）——双方都能看到
设计模式：工厂模式：
客户端发送的结构体+序列化函数+反序列化函数
服务器反序列化的接收的结构体+反序列函数+序列化函数
代码：
#pragma once #include <iostream> #include <memory> namespace Protocol { const std::string ProtSep = " "; const std::string LineBreakSep = "\n"; // 封装为报文——序列化的一部分 std::string Encode(const std::string &message) //"x op y"或者"_result _code" { std::string len = std::to_string(message.size()); std::string package = len + LineBreakSep + message + LineBreakSep; //"len\n""x op y\n" return package; } // 解报——反序列化的一部分 bool Decode(std::string &package, std::string *message) //"len\n""x op y\n" { // 除了解报，我们还要判断是否认正确 auto pos = package.find(LineBreakSep); if (pos == std::string::npos) return false; std::string lens = package.substr(0, pos); int messagelen = std::stoi(lens); int total = lens.size() + messagelen + 2 * LineBreakSep.size(); if (package.size() < total) return false; // 至少有一个完整报文 *message = package.substr(pos + LineBreakSep.size(), messagelen); // 收到的报文可能是"len\n""x op y\n""len\n""x op y\n""len\n""x op y\n" // 所以我解报一个报文后，要删除这个报文，让后面的继续Dcode解报 package.erase(0, total); return true; } class Requset { public: Requset() : _data_x(0), _data_y(0), _oper(0) { } Requset(int x, int y, int op) : _data_x(x), _data_y(y), _oper(op) { } ~Requset() { } void Debug() { std::cout << "_data_x:" << _data_x << std::endl; std::cout << "_data_y:" << _data_y << std::endl; std::cout << "_oper:" << _oper << std::endl; } void Inc() { _data_x++; _data_y++; } // 自定义序列化协议：结构体数据->字符串 bool Serialize(std::string *out) { //"x op y" *out = std::to_string(_data_x) + ProtSep + _oper + ProtSep + std::to_string(_data_y); return true; } // 反序列化 : 字符串->结构体数据 bool Deserialize(std::string &in) //"x op y" { auto left = in.find(ProtSep); if (left == std::string::npos) return false; auto right = in.rfind(ProtSep); if (right == std::string::npos) return false; //[) _data_x = std::stoi(in.substr(0, left)); _data_y = std::stoi(in.substr(right + ProtSep.size())); std::string oper = in.substr(left + ProtSep.size(), right - (left + ProtSep.size())); if (oper.size() == 1) return false; _oper = oper[0]; return true; } int Getx() { return _data_x; } int Gety() { return _data_y; } char GetOper() { return _oper; } //_data_x+_data_y // 报文的自描述 //"len\n""x op y\n" private: int _data_x; // 第一个参数 int _data_y; // 第二个参数 char _oper; //+ - * / % }; class Response { public: Response(): _rseult(0), _code(0) { } Response(int result, int code) : _result(result), _code(code) { } // 自定义序列化协议：结构体数据->字符串 bool Serialize(std::string *out) { //"_result _code" *out = std::to_string(_result) + ProtSep + std::to_string(_code); return true; } // 反序列化：字符串->数据架构数据 bool Deserialize(std::string &in) //"_result _code" { auto pos = in.find(ProtSep); if (pos == std::string::npos) return false; _result = std::stoi(in.substr(0, pos)); _code = std::stoi(in.substr(pos + ProtSep.size())); return true; } void SetResult(int res) { _result = res; } void SetCode(int code){ _code=code;} private: int _result; // 运算结果 int _code; // 运算状态 }; // 简单的工厂模式，建造类设计模式 class Factory { public: std::shared_ptr<Requset> BulidRequest() { std::shared_ptr<Requset> req = std::make_shared<Requset>(); return req; } std::shared_ptr<Requset> BulidRequest(int x, int y, int op) { std::shared_ptr<Requset> req = std::make_shared<Requset>(x, y, op); return req; } std::shared_ptr<Response> BulidResponse() { std::shared_ptr<Response> resp = std::make_shared<Response>(); return resp; } std::shared_ptr<Response> BulidResponse(int result, int code) { std::shared_ptr<Response> resp = std::make_shared<Response>(result, code); return resp; } }; } 成熟的序列化反序列化：
Json:Value 万能类型
那么我们序列化和反序列化就可以用这样的：
总结：发送的数据为结构体，这个结构体就是我们自定义的协议，他的序列化反序列化 这些都是应用层的协议
