自定义协议（应用层协议）——网络版计算机基于TCP传输协议

应用层：自定义网络协议：序列化和反序列化，如果是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 万能类型
在这里插入图片描述

那么我们序列化和反序列化就可以用这样的：
在这里插入图片描述

总结：发送的数据为结构体，这个结构体就是我们自定义的协议，他的序列化反序列化 这些都是应用层的协议

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

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

相关文章

力扣高频SQL 50题（基础版）第十七题

力扣高频SQL 50题（基础版）第十七题

文章目录 力扣高频SQL 50题&#xff08;基础版&#xff09;第十七题1075. 项目员工 I题目说明思路分析实现过程准备数据实现方式结果截图 力扣高频SQL 50题&#xff08;基础版&#xff09;第十七题 1075. 项目员工 I 题目说明 项目表 Project&#xff1a; ----------------…
阅读更多...
Hadoop、HDFS、MapReduce 大数据解决方案

Hadoop、HDFS、MapReduce 大数据解决方案

本心、输入输出、结果 文章目录 Hadoop、HDFS、MapReduce 大数据解决方案前言HadoopHadoop 主要组件的Web UI端口和一些基本信息MapReduceMapReduce的核心思想MapReduce的工作流程MapReduce的优缺点Hadoop、HDFS、MapReduce 大数据解决方案 编辑 | 简简单单 Online zuozuo 地址…
阅读更多...
建投数据人力资源系列产品获得欧拉操作系统及华为鲲鹏技术认证书

建投数据人力资源系列产品获得欧拉操作系统及华为鲲鹏技术认证书

近日&#xff0c;经欧拉生态创新中心和华为技术有限公司测评&#xff0c;建投数据自主研发的人力资源管理系统、招聘管理系统、绩效管理系统、培训管理系统&#xff0c;完成了基于欧拉操作系统openEuler 22.03、华为鲲鹏Kunpeng 920&#xff08;Taisha 200&#xff09;的兼容性…
阅读更多...
43 华三AC登录Web页面

43 华三AC登录Web页面

一 无线上WEB页面 1 创建vlan 56 [AC-KongZhi]vlan 56 2 退出 [AC-KongZhi-vlan56]quit 3 进入vlan三层口 配置IP地址 [AC-KongZhi]interface Vlan-interface 56 [AC-KongZhi-Vlan-interface56]ip address 192.168.56.55 24 4 在AC控制器与Host主机的接口上能通关vlan 5…
阅读更多...
Adobe Photoshop(Ps)安装包软件下载

Adobe Photoshop(Ps)安装包软件下载

一、Adobe Photoshop简介 Adobe Photoshop&#xff08;简称PS&#xff09;是由Adobe Systems公司开发的图像处理软件&#xff0c;它是一款集图像扫描、编辑修改、图像制作、广告创意、图像输入与输出于一体的图形图像处理软件。广泛应用于专业测评、平面设计、广告摄影、影像创…
阅读更多...
Java面试八股之Spring-boot-starter-parent的作用是什么

Java面试八股之Spring-boot-starter-parent的作用是什么

Spring-boot-starter-parent的作用是什么 spring-boot-starter-parent 是Spring Boot项目中的一个特殊POM&#xff08;Project Object Model&#xff09;&#xff0c;它主要的作用是提供一系列默认的配置和依赖管理&#xff0c;以便简化项目的构建过程。以下是spring-boot-sta…
阅读更多...
PACS系统，PACS源码，强大的影像处理和分析功能

PACS系统，PACS源码，强大的影像处理和分析功能

PACS系统覆盖医院现有放射、CT、MR、核医学、超声、内镜、病理、心电等绝大部分DICOM和非DICOM检查设备&#xff0c;与医院HIS、集成平台的有效集成和融合&#xff0c;帮助医院实现了全院医学影像和报告的信息共享&#xff0c;提升了医院的服务质量和效率。 医学影像归档与传输…
阅读更多...
【LLM】-08-搭建问答系统-语言模型，提问范式与 Token

【LLM】-08-搭建问答系统-语言模型，提问范式与 Token

目录 1、语言模型 1.1、训练过程&#xff1a; 1..2、大型语言模型分类&#xff1a; 1.3、指令微调模型训练过程&#xff1a; 2、Tokens 3、Helper function辅助函数 (提问范式) 4、计算token数量 1、语言模型 大语言模型&#xff08;LLM&#xff09;是通过预测下一个词…
阅读更多...
matlab gui下的tcp client客户端编程框架

matlab gui下的tcp client客户端编程框架

GUI界面 函数外定义全局变量 %全局变量 global TcpClient; %matlab作为tcpip客户端 建立连接 在“连接”按钮的回调函数下添加以下代码&#xff1a; global TcpClient;%全局变量 TcpClient tcpip(‘192.168.1.10’, 7, ‘NetworkRole’,‘client’); %连接到服务器地址和端…
阅读更多...
Windows配置Qt+VLC

Windows配置Qt+VLC

文章目录 前言下载库文件提取文件编写qmakeqtvlc测试代码 总结 前言 在Windows平台上配置Qt和VLC是开发多媒体应用程序的一个重要步骤。Qt作为一个强大的跨平台应用开发框架&#xff0c;为开发人员提供了丰富的GUI工具和库&#xff0c;而VLC则是一个开源的多媒体播放器&#x…
阅读更多...
小猪佩奇.js

小猪佩奇.js

闲着没事 使用js 画一个小猪佩奇把 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Document</tit…
阅读更多...
敏捷CSM证书国家认可嘛？有什么价值？

敏捷CSM证书国家认可嘛？有什么价值？

CSM证书&#xff0c;全称为Certified Scrum Master&#xff0c;是由Scrum Alliance&#xff08;敏捷联盟&#xff09;颁发的一项国际公认的敏捷管理领域认证。该证书不仅在全球范围内受到广泛认可&#xff0c;也在国内得到了业界的广泛关注和重视。 CSM证书的背景 CSM证书是基…
阅读更多...
爬虫学习4：爬取王者荣耀技能信息

爬虫学习4：爬取王者荣耀技能信息

爬虫&#xff1a;爬取王者荣耀技能信息&#xff08;代码和代码流程&#xff09; 代码 # 王者荣耀英雄信息获取 import time from selenium import webdriver from selenium.webdriver.common.by import By if __name__ __main__:fp open("./honorKing.txt", "…
阅读更多...
PHP基础语法-Part1

PHP基础语法-Part1

脚本格式 PHP脚本以<?php开头&#xff0c;以?>结尾&#xff1b; PHP语句以分号结尾&#xff08;;&#xff09; PHP是解释型语言&#xff1b; 输入和输出 获取用户的输入&#xff1a; $input readline("input:"); echo $input; echo "input:";…
阅读更多...
Spark内核的设计原理

Spark内核的设计原理

导读&#xff1a; 本期是DataFun深入浅出Apache Spark第一期的分享&#xff0c;主讲老师耿嘉安开场介绍了自己的从业经历&#xff0c;当前就职的数新网络与Spark相关的两款产品赛博数智引擎CyberEngine和赛博数据智能平台CyberData。 本次分享题目为《Spark内核的设计原理》&…
阅读更多...
Java面试八股之什么是spring boot starter

Java面试八股之什么是spring boot starter

什么是spring boot starter Spring Boot Starter是Spring Boot项目中的一个重要概念。它是一种依赖管理机制&#xff0c;用于简化Maven或Gradle配置文件中的依赖项声明。Spring Boot Starter提供了一组预定义的依赖关系&#xff0c;这些依赖关系被封装在一个单一的包中&#x…
阅读更多...
如何使用C#自制一个Windows安装包

如何使用C#自制一个Windows安装包

原文链接&#xff1a;https://www.cnblogs.com/zhaotianff/p/17387496.html 以前都在用InstallShield制作安装包&#xff0c;基本需求是能满足的&#xff0c;但也有一些缺点&#xff1a; 1、界面不能完全定制 2、不能直接调用代码里的功能 平常使用一些其它软件&#xff0c;…
阅读更多...
【宝藏系列】模/数转换十大常用滤波算法

【宝藏系列】模/数转换十大常用滤波算法

【宝藏系列】模/数转换十大常用滤波算法 文章目录 【宝藏系列】模/数转换十大常用滤波算法&#x1f468;‍&#x1f3eb;ADC&#xff08;Analog-to-Digital Converter&#xff0c;模数转换器&#xff09;1️⃣限幅滤波法2️⃣中位值滤波法3️⃣算术平均滤波法4️⃣递推平均滤波…
阅读更多...
AI学习记录 - 图像识别的基础入门

AI学习记录 - 图像识别的基础入门

代码实现&#xff0c;图像识别入门其实非常简单&#xff0c;这里使用的是js&#xff0c;其实就是把二维数组进行公式化处理&#xff0c;处理方式如上图&#xff0c;不同的公式代表的不同的意义&#xff0c;这些意义网上其实非常多&#xff0c;这里就不细讲了。 const getSpecif…
阅读更多...
Webshell管理工具：AntSword（中国蚁剑）

Webshell管理工具：AntSword（中国蚁剑）

中国蚁剑是一款开源的跨平台网站管理工具&#xff0c;它主要面向于合法授权的渗透测试安全人员以及进行常规操作的网站管理员。 通俗的讲&#xff1a;中国蚁剑是 一 款比菜刀还牛的shell控制端软件。 一、中国蚁剑下载 1. 下载 AntSword-Loader https://github.com/AntSwordP…
阅读更多...
最新文章

Copyright @ 2022~2023