使用模板方法设计模式封装 socket 套接字并实现Tcp服务器和客户端 简单工厂模式设计

文章目录

  • 使用模板方法设计模式封装套接字
  • 使用封装后的套接字实现Tcp服务器和客户端
    • 实现Tcp服务器
    • 实现Tcp客户端
  • 工厂模式

在这里插入图片描述

使用模板方法设计模式封装套接字

可以使用模块方法设计模式来设计套接字 socket 的封装

模板方法（Template Method）设计模式是一种行为设计模式，它在一个方法中定义了一个算法的骨架，并允许子类为一个或多个步骤提供实现。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

  1. 抽象类（Abstract Class）：定义了一个或多个抽象操作，以及一个模板方法。这个模板方法调用了一个或多个抽象操作。
  2. 具体子类（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;
            else
                return 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）：负责创建具体产品的实例，它通常包含一个工厂方法，用于创建产品对象。
    优点：
  1. 解耦：将对象的创建与使用分离，降低了客户端与具体产品之间的耦合度。
  2. 灵活性和可扩展性：通过引入抽象层，可以轻松地创建新的具体产品类，而无需修改客户端代码。
  3. 代码复用：通过封装对象的创建过程，可以在多个客户端之间复用相同的创建逻辑。

简易的工厂模式：一个请求类，一个回应类，一个工厂类。

#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 y
    int _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;
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/752139.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

CORE Mobility Errorr的调试

CORE Mobility Errorr的调试

在运行CORE tutorial 3中的mobility示例时&#xff0c;出现如下错误&#xff1a; 当看到这个问题的时候&#xff0c;并没有仔细去分析日志和现象&#xff0c;在core-daemon的进程打印界面只看了一下最后的出错堆栈&#xff1a; 2024-06-27 10:43:48,614 - ERROR - _server:_ca…
阅读更多...
微信小程序毕业设计-线上教育商城系统项目开发实战(附源码+论文)

微信小程序毕业设计-线上教育商城系统项目开发实战(附源码+论文)

大家好&#xff01;我是程序猿老A&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。 &#x1f49e;当前专栏&#xff1a;微信小程序毕业设计 精彩专栏推荐&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb; &#x1f380; Python毕业设计…
阅读更多...
无敌“水刊”，沾稿就收！5本机械工程方向SCI，100%录用，不退稿~评职/毕业首选~

无敌“水刊”，沾稿就收！5本机械工程方向SCI，100%录用，不退稿~评职/毕业首选~

在众多理工科专业中&#xff0c;计算机科学与人工智能、电子电气工程、机械工程、医学、土木工程、生物科学、化学工程以及数学与统计学等八个专业最吃香。 对于这些专业领域的毕业生和寻求职业晋升的在职人士而言&#xff0c;如何在学术界和工业界展现自己的研究成果和实力&am…
阅读更多...
Type-C接口快充取电的优势及LDR6328的应用探讨

Type-C接口快充取电的优势及LDR6328的应用探讨

在当今这个快节奏的社会&#xff0c;电子设备已经成为我们生活中不可或缺的一部分。随着科技的不断发展&#xff0c;对于电子设备充电速度和效率的要求也越来越高。Type-C接口快充取电技术应运而生&#xff0c;以其独特的优势&#xff0c;成为了市场中的一股新势力。而LDR6328作…
阅读更多...
家电品牌如何利用3D数字化技术，突破转型瓶颈？

家电品牌如何利用3D数字化技术，突破转型瓶颈？

家电行业正经历着从增量市场向存量市场的转变&#xff0c;用户的消费观念也日趋成熟&#xff0c;更加注重产品的体验和服务质量。无论是线上购物平台还是线下实体门店&#xff0c;提供个性化和增强体验感的产品与服务已成为家电市场未来发展的核心驱动力。 51建模网依托“3D数字…
阅读更多...
手机如何录屏？小白也能秒变高手

手机如何录屏？小白也能秒变高手

随着智能手机的普及&#xff0c;手机录屏已经成为一种越来越普遍的需求。无论是录制游戏过程、分享操作教程&#xff0c;还是保留重要信息&#xff0c;手机录屏都发挥着重要作用。可是很多人不知道手机如何录屏&#xff0c;本文将介绍三种手机录屏方法&#xff0c;帮助大家轻松…
阅读更多...
Java获取class对象3种方式，不同点解析。

Java获取class对象3种方式，不同点解析。

Java获取class对象3种方式&#xff0c;不同点解析。 前言 Java获取class对象3种方式&#xff0c;不同点解析&#xff0c;他们是有区别的 创建目标类Apple进行演示&#xff01;&#xff01;&#xff01; OK&#xff01;结束&#xff01;我们就可以看出区别。
阅读更多...
PH计仪器校准内容，以及相关注意事项内容

PH计仪器校准内容，以及相关注意事项内容

ph计大家一定不陌生&#xff0c;在日常生活中和实验场所&#xff0c;经常会有看到这种计量器具&#xff0c;作为测定ph值的常用仪器&#xff0c;其运用领域可谓十分广泛&#xff0c;不过因为其结构的特殊性&#xff0c;加上传感器的原理问题&#xff0c;其自身的计量校准也需要…
阅读更多...
使用函数open()的例子

使用函数open()的例子

代码&#xff1a; #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdio.h> int main(void) {int fd-1;char filename[]"test.txt";fdopen(filename,O_RDWR);if(-1fd){printf("Open file %s failure!,fd…
阅读更多...
六西格玛项目实战：数据驱动，手机PCM率直线下降

六西格玛项目实战：数据驱动，手机PCM率直线下降

在当前智能手机市场日益竞争激烈的背景下&#xff0c;消费者对手机质量的要求达到了前所未有的高度。PCM&#xff08;可能指生产过程中的某种不良率或缺陷率&#xff09;作为影响手机质量的关键因素&#xff0c;直接关联到消费者满意度和品牌形象。为了应对这一挑战&#xff0c…
阅读更多...
事务的概念-事务的概念、事务的定义（BEGIN TRANSACTION、COMMIT、ROLLBACK）

事务的概念-事务的概念、事务的定义（BEGIN TRANSACTION、COMMIT、ROLLBACK）

数据库系统中的事务&#xff0c;是保证系统在发生故障后或存在并发操作的情况下&#xff0c;数据库中的数据与企业业务结果相一致 一、事务的概念 在许多数据库应用系统中&#xff0c;数据库用来存储现实世界中一些企业的状态信息或其管理的数据 1、概念一 &#xff08;1&a…
阅读更多...
OpenGL3.3_C++_Windows(22)

OpenGL3.3_C++_Windows(22)

材质&#xff1a; 决定物体在渲染过程中最终视觉呈现的关键因素之一&#xff0c;它通过一系列光学&#xff08;投光物&#xff09;和物理参数&#xff08;反光度&#xff0c;反照率、金属度&#xff0c;折射率……&#xff09;准确模拟现实世界中的材料特性&#xff0c;从而增…
阅读更多...
MySQL高级-索引-使用规则-单列索引联合索引

MySQL高级-索引-使用规则-单列索引联合索引

文章目录 1、单列索引2、联合索引3、查看表索引4、创建 name 和 phone 索引5、查询 phone17799990010 and name韩信6、执行计划 phone17799990010 and name韩信7、创建联合唯一索引 idx_user_phone_name8、再次执行计划 phone17799990010 and name韩信9、使用了USE INDEX提示来…
阅读更多...
echarts/自定义 环形进度条，源码+图片 复制运行 自取

echarts/自定义 环形进度条，源码+图片 复制运行 自取

进度图1&#xff1a; <!--* FilePath: index.vue* Author: 是十九呐* Date: 2024-06-26 17:56:34* LastEditTime: 2024-06-27 10:16:20 --> <template><div class"pieChartProgress-container"><div class"pieChartProgress-chart" :…
阅读更多...
【Python机器学习】自动化特征选择——基于模型的特征选择

【Python机器学习】自动化特征选择——基于模型的特征选择

基于模型的特征选择使用一个监督机器学习模型来判断每个特征的重要性&#xff0c;并且仅保留最重要的特征。用于特征学习的监督模型不需要与用于最终建模的模型相同。特征选择模型需要为每个特征提供某种重要性度量&#xff0c;以便用这个度量对特征进行排序。决策树和基于决策…
阅读更多...
3D立体卡片动效（附源码）

3D立体卡片动效（附源码）

3D立体卡片动效 欢迎关注&#xff1a;xssy5431 小拾岁月参考链接&#xff1a;https://mp.weixin.qq.com/s/9xEjPAA38pRiIampxjXNKQ 效果展示 思路分析 需求含有立体这种关键词&#xff0c;我们第一反应是采用动画中的平移、倾斜等实现。如果是立体&#xff0c;必然产生阴影&…
阅读更多...
哈喽GPT-4o，对GPT-4o 数据分析Data Analysis的思考与看法

哈喽GPT-4o，对GPT-4o 数据分析Data Analysis的思考与看法

目录 上传一个Excel给Data Analysis。Prompt&#xff1a;请问这个数据集是做什么的Prompt&#xff1a;请问书籍的定价如何&#xff0c;请用合适的图表展示它的售价情况Prompt&#xff1a;请统计书名列中出现最多的名称&#xff0c;然后使用词云将其可视化。Prompt&#xff1a;请…
阅读更多...
FastGPT部署和OneAPI部署

FastGPT部署和OneAPI部署

FastGPT模型管理 FastGPT只支持openai 格式的restful 的api接口。 就是 chat/completion那个接口。如果不理解可以参考这个文章 https://zhuanlan.zhihu.com/p/656959227 。 支持Python 。JAVA 等后端语言或者 http 访问 因此如果想访问大模型&#xff0c;有以下几种方案&…
阅读更多...
软件需求管理规程（DOC原件）

软件需求管理规程（DOC原件）

软件需求管理规程是确保软件开发过程中需求清晰、一致、可追踪的关键环节&#xff1a; 明确需求&#xff1a;项目初期&#xff0c;与利益相关者明确项目目标和需求&#xff0c;确保需求完整、无歧义。需求评审&#xff1a;组织专家团队对需求进行评审&#xff0c;识别潜在风险和…
阅读更多...
C++ 矩阵的最小路径和解法

C++ 矩阵的最小路径和解法

描述 给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。 数据范围: 1≤𝑛,𝑚≤5001≤n,m≤500，矩阵中任意值都满足 0≤𝑎𝑖,𝑗≤1000≤ai,j​≤100 要求…
阅读更多...
最新文章

Copyright @ 2022~2023