使用模板方法設計模式封裝 socket 套接字并實現Tcp服務器和客戶端簡單工廠模式設計

文章目錄

使用模板方法設計模式封裝套接字
使用封裝后的套接字實現Tcp服務器和客戶端
- 實現Tcp服務器
- 實現Tcp客戶端
工廠模式

在這里插入圖片描述

使用模板方法設計模式封裝套接字

可以使用模塊方法設計模式來設計套接字 socket 的封裝

模板方法（Template Method）設計模式是一種行為設計模式，它在一個方法中定義了一個算法的骨架，并允許子類為一個或多個步驟提供實現。模板方法使得子類可以不改變一個算法的結構即可重新定義該算法的某些特定步驟。

抽象類（Abstract Class）：定義了一個或多個抽象操作，以及一個模板方法。這個模板方法調用了一個或多個抽象操作。
具體子類（Concrete Subclass）：實現抽象類中的抽象操作，從而完成算法中特定步驟的具體實現。

抽象類定義了一個模板方法，這個方法通常包含對具體方法的調用，抽象類還定義了一些抽象方法，這些方法會在模板方法中被調用，但具體的實現由子類來提供（抽象類，也就是父類中，將這些方法都設置為純虛函數，子類要重寫純虛函數），子類通過繼承抽象類并提供抽象方法的實現，從而可以自定義模板方法中的某些步驟，當模板方法被調用時，它會按照定義的順序依次調用抽象類中的抽象方法和具體方法。

#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};// 封裝一個基類, 套接字對應的接口類// 一旦一個類中有純虛函數, 只有被繼承并且實現此方法后, 才能創建對象// ::close 使用系統的接口函數// 設計模式：模板方法class Socket{public:virtual ~Socket() {}virtual void CreateSocketOrDie() = 0;            // 創建套接字virtual void BindSocketOrDie(uint16_t port) = 0; // 綁定virtual void ListenSocketOrDie(int backlog) = 0; // 監聽// 獲取連接, 拿到tcp所需的新的文件描述符 newsockfd, 并返回并 create 一個 tcp 套接字, 并將客戶端信息通過輸出型參數返回virtual Socket* AcceptConnection(std::string* peerip, uint16_t* peerport) = 0;virtual bool ConnetServer(std::string& serverip, uint16_t serverport) = 0;virtual int GetSockFd() = 0;virtual void SetSockFd(int sockfd) = 0;virtual void CloseSockfd() = 0;public:// 下面這些方法會被子類繼承下去void BulidListenSocketMethod(uint16_t port, int backlog) // 創建監聽套接字, 給 Server 用的{CreateSocketOrDie();BindSocketOrDie(port);ListenSocketOrDie(backlog);}bool BulidConnectSocketMethod(std::string& serverip, uint16_t serverport) // 創建連接套接字, 給Client 用{CreateSocketOrDie();return ConnetServer(serverip, serverport); // connet 有可能會失敗}void BulidNormalSocketMethod(int sockfd){SetSockFd(sockfd);}};// 成員函數用 override 修飾后, 派生類必須重載基類的同名虛函數, 否則編譯不能通過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 ConnetServer(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;elsereturn false;}int GetSockFd() override{return _sockfd;}void SetSockFd(int sockfd) override{_sockfd = sockfd;}void CloseSockfd() override{if (_sockfd > defaultsockfd)::close(_sockfd);}private:int _sockfd;};
}

使用封裝后的套接字實現Tcp服務器和客戶端

實現Tcp服務器

#pragma once
#include "Socket.hpp"
#include <iostream>
#include <pthread.h>
#include <functional>// void 表示返回值為空, ()里面是參數
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->BulidListenSocketMethod(_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->CloseSockfd(); // 再關閉文件描述符delete td->_sockp;delete td;}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;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;func_t _handler_request;
};

實現Tcp客戶端

#include "Protocol.hpp"
#include "Socket.hpp"
#include <unistd.h>
#include <iostream>
#include <string>
#include <memory>int main(int argc, char* argv[])
{if (argc != 3){std::cout << "Usage: " << argv[0] << " serverip serverport" << std::endl;return 0;}std::string serverip = argv[1];uint16_t serverport = std::stoi(argv[2]);Net_Work::Socket* s = new Net_Work::TcpSocket();if (!s->BulidConnectSocketMethod(serverip, serverport)){std::cerr << "connect " << serverip << ":" << serverport << "failed" << std::endl;}std::cout << "connect " << serverip << ":" << serverport << " success" << std::endl;std::unique_ptr<Factory> factory = std::make_unique<Factory>();std::shared_ptr<Request> req = factory->BuildRequest(10, 20, '+');while (true){req->Inc();send(s->GetSockFd(), &(*req), sizeof(*req), 0);sleep(1);}s->CloseSockfd();return 0;
}

工廠模式

工廠設計模式是一種創建型設計模式，它提供了一種靈活的方式來實例化和組織對象的創建。工廠設計模式是一種創建對象的軟件設計模式，它通過一個公共接口或基類來創建對象，而無需暴露對象的具體實現。這種設計模式的主要作用是將對象的創建與使用分離，從而降低耦合度，使代碼更易于理解和維護。

抽象產品（Abstract Product）：定義了一個產品的接口或抽象類，它描述了產品的共同屬性和方法。
具體產品（Concrete Product）：實現了抽象產品接口或繼承自抽象產品類的具體類，代表了具體的對象。
工廠類（Factory Class）：負責創建具體產品的實例，它通常包含一個工廠方法，用于創建產品對象。
優點：

解耦：將對象的創建與使用分離，降低了客戶端與具體產品之間的耦合度。
靈活性和可擴展性：通過引入抽象層，可以輕松地創建新的具體產品類，而無需修改客戶端代碼。
代碼復用：通過封裝對象的創建過程，可以在多個客戶端之間復用相同的創建邏輯。

簡易的工廠模式：一個請求類，一個回應類，一個工廠類。

#include <iostream>
#include <memory>// 請求
class Request
{
public:Request(){}Request(int x, int y, char op) :_data_x(x), _data_y(y), _oper(op){}
private:// 約定好的 x _oper yint _data_x;int _data_y;char _oper; // + - * / %
};// 相應
class Response
{
public:Response(){}Response(int result, int code) :_result(result), _code(code){}
private:int _result; // 計算結果int _code; // 運算狀態
};// 工廠模式
class Factory
{
public:std::shared_ptr<Request> BuildRequest(){std::shared_ptr<Request> req = std::make_shared<Request>();return req;}std::shared_ptr<Request> BuildRequest(int x, int y, char op){std::shared_ptr<Request> req = std::make_shared<Request>(x, y, op);return req;}std::shared_ptr<Response> BuildResponse(){std::shared_ptr<Response> resp = std::make_shared<Response>();return resp;}std::shared_ptr<Response> BuildResponse(int result, int code){std::shared_ptr<Response> resp = std::make_shared<Response>(result, code);return resp;}
};