Linux网络基础二

LVGL v9的lv_scale控件实战:5分钟打造动态仪表盘(附完整代码) 本文详细介绍了LVGL v9中lv_scale控件的实战应用,通过5个关键步骤快速打造动态仪表盘。文章涵盖核心特性解析、代码实现、样式定制及性能优化,适用于工业HMI、智能家居等场景,并附完整代码示例。 阅读详情

一.应用层

我们程序员写的一个个解决我们实际问题, 满足我们日常需求的网络程序, 都是在应用层。

二.再谈 "协议"

协议是一种 "约定". socket api的接口, 在读写数据时, 都是按 "字符串" 的方式来发送接收的. 如果我们要传输一些"结构化的数据" 怎么办呢?(序列化和反序列化)

序列化:将结构体数据变成字符串的过程

为什么需要序列化:方便网络的发送和接受
反序列化:将字符串变回结构体数据的过程

为什么需要反序列化:方便上层应用程序正常使用数据

三.网络版计算器

客户端发送需计算的数据,服务器进行计算并返回结果.

Sock.hpp:

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include "Log.hpp"

class Sock
{
private:
    const static int gbacklog = 20;

public:
    Sock() {}
    int Socket()
    {
        int listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "create socket error, %d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "create socket success, listensock: %d", listensock);
        return listensock;
    }
    void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &local.sin_addr);
        if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }
    }
    void Listen(int sock)
    {
        if (listen(sock, gbacklog) < 0)
        {
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }

        logMessage(NORMAL, "init server success");
    }
    // 一般经验
    // const std::string &: 输入型参数
    // std::string *: 输出型参数
    // std::string &: 输入输出型参数
    int Accept(int listensock, std::string *ip, uint16_t *port)
    {
        struct sockaddr_in src;
        socklen_t len = sizeof(src);
        int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
        if (servicesock < 0)
        {
            logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
            return -1;
        }
        if(port) *port = ntohs(src.sin_port);
        if(ip) *ip = inet_ntoa(src.sin_addr);
        return servicesock;
    }
    bool Connect(int sock, const std::string &server_ip, const uint16_t &server_port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(server_port);
        server.sin_addr.s_addr = inet_addr(server_ip.c_str());

        if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0) return true;
        else return false;
    }
    ~Sock() {}
};

这个文件封装sock套接字有关接口,方便直接在代码中使用,就没有什么好解释的,,就是把套接字有关的接口进行了封装。

Log.hpp:

#pragma once

#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <string>

// 日志是有日志级别的
#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"
};

#define LOGFILE "./calculator.log"

// 完整的日志功能,至少: 日志等级 时间 支持用户自定义(日志内容, 文件行,文件名)
void logMessage(int level, const char *format, ...)
{
#ifndef DEBUG_SHOW
    if(level== DEBUG) return;
#endif
    // va_list ap;
    // va_start(ap, format);
    // while()
    // int x = va_arg(ap, int);
    // va_end(ap); //ap=nullptr
    char stdBuffer[1024]; //标准部分
    time_t timestamp = time(nullptr);
    // struct tm *localtime = localtime(&timestamp);
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp);

    char logBuffer[1024]; //自定义部分
    va_list args;
    va_start(args, format);
    // vprintf(format, args);
    vsnprintf(logBuffer, sizeof logBuffer, format, args);
    va_end(args);

    //FILE *fp = fopen(LOGFILE, "a");
    printf("%s%s\n", stdBuffer, logBuffer);
    //fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
    //fclose(fp);
}

这个就是一个普通的日志文件,用来关注此时的运行状态。

TcpServer.hpp:

#include "Sock.hpp"
#include <vector>
#include <functional>
#include <pthread.h>


namespace ns_tcpserver
{
    using func_t = std::function<void(int)>;
    class TcpServer;
    class ThreadData
    {
    public:
        ThreadData(int sock, TcpServer *server) : sock_(sock), server_(server)
        {
        }
        ~ThreadData()
        {
        }

    public:
        int sock_;
        TcpServer *server_;
    };
    class TcpServer
    {
    public:
        static void* ThreadRoutine(void* args)
        {
            pthread_detach(pthread_self());
            ThreadData* td=static_cast<ThreadData*>(args);
            td->server_->Excute(td->sock_);
            close(td->sock_);
            return nullptr;
        }
    public:
        TcpServer(const uint16_t port,const std::string ip="")
        {
            listensock_=sock_.Socket();
            sock_.Bind(listensock_,port,ip);
            sock_.Listen(listensock_);
        }
        //bind服务
        void BindService(func_t func)
        {
            func_.push_back(func);
        }
        //执行任务
        void Excute(int sock)
        {
            for(auto f: func_)
            {
                f(sock);
            }
        }
        void Start()
        {
            for(;;)
            {
                uint16_t clientport;
                std::string clientip;
                int sock=sock_.Accept(listensock_,&clientip,&clientport);
                if(sock==-1)
                    continue;
                pthread_t tid;
                ThreadData* td=new ThreadData(listensock_,this);
                pthread_create(&tid,nullptr,ThreadRoutine,td);
            }
        }
        ~TcpServer()
        {
            if(listensock_>=0)
            {
                close(listensock_);
            }
        }
    private:
        int listensock_;
        Sock sock_;
        std::vector<func_t> func_;
    };
}

 这个文件,首先把内容放在一个ns_tcpserver的命名空间里面。

TcpServer:

类成员:首先这个类的成员有三个,listensock_这个用来存储套接字,sock_是一个套接字有关的类,func_是一个用来存储任务的数组。

TcpServer:构造函数,用于创建套接字,bind对应的ip,port,并且进行listen。

~TcpServer:析构函数,用于关闭套接字

BindService:bind一个服务

Excute:执行一个对应的服务任务

Start:首先获取连接,然后创建一个线程去执行对应的任务

ThreadRoutine:线程的回调函数,第一步分离线程,然后执行对应的服务任务

ThreadData:

类成员:这个类有两个成员,sock_存储套接字,server是一个TcpServer的类

这个类的作用是用来方便线程执行对应的服务任务

CalServer.cc:

#include "TcpServer.hpp"
#include "Protocol.hpp"
#include "Daemon.hpp"
#include <memory>
#include <signal.h>

using namespace ns_tcpserver;
using namespace ns_protocol;

static void Usage(const std::string &process)
{
    std::cout << "\nUsage: " << process << " port\n"
              << std::endl;
}

static Response calculatorHelper(const Request &req)
{
    Response resp(0, 0, req.x_, req.y_, req.op_);
    switch (req.op_)
    {
    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 (0 == req.y_)
            resp.code_ = 1;
        else
            resp.result_ = req.x_ / req.y_;
        break;
    case '%':
        if (0 == req.y_)
            resp.code_ = 2;
        else
            resp.result_ = req.x_ % req.y_;
        break;
    default:
        resp.code_ = 3;
        break;
    }
    return resp;
}

void calculator(int sock)
{
    std::string inbuffer;
    while (true)
    {
        // 1. 读取成功
        bool res = Recv(sock, &inbuffer); // 在这里我们读到了一个请求?
        if (!res)
            break;
        // std::cout << "begin: inbuffer: " << inbuffer << std::endl;
        // 2. 协议解析,保证得到一个完整的报文
        std::string package = Decode(inbuffer);
        if (package.empty())
            continue;
        // std::cout << "end: inbuffer: " << inbuffer << std::endl;
        // std::cout << "packge: " << package << std::endl;
        logMessage(NORMAL, "%s", package.c_str());
        // 3. 保证该报文是一个完整的报文
        Request req;
        // 4. 反序列化,字节流 -> 结构化
        req.Deserialized(package); // 反序列化
        // 5. 业务逻辑
        Response resp = calculatorHelper(req);
        // 6. 序列化
        std::string respString = resp.Serialize(); // 对计算结果进行序列化
        // 7. 添加长度信息,形成一个完整的报文
        // "length\r\ncode result\r\n"
        // std::cout << "respString: " << respString << std::endl;
        respString = Encode(respString);
        // std::cout << "encode: respString: " << respString << std::endl;
        // 8. send这里我们暂时先这样写,多路转接的时候,我们再来谈发送的问题
        Send(sock, respString);
    }
}

// void handler(int signo)
// {
//     std::cout << "get a signo: " << signo << std::endl;
//     exit(0);
// }

// ./CalServer port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }
    // 一般经验:server在编写的时候,要有较为严谨性的判断逻辑
    // 一般服务器,都是要忽略SIGPIPE信号的,防止在运行中出现非法写入的问题!
    // signal(SIGPIPE, SIG_IGN);
    MyDaemon();
    std::unique_ptr<TcpServer> server(new TcpServer(atoi(argv[1])));
    server->BindService(calculator);
    server->Start();
    // Request req(123, 456, '+');
    // std::string s = req.Serialize();
    // std::cout << s << std::endl;

    // Request temp;
    // temp.Deserialized(s);
    // std::cout << temp.x_ << std::endl;
    // std::cout << temp.op_ << std::endl;
    // std::cout << temp.y_ << std::endl;
    return 0;
}

 这个是服务端,首先来说一下主函数,首先调用MyDaemon(),然这个进程变成守护进程,这个在后面再仔细说,然后就是创建一个TcpServer对象,然后给他BindService一个服务,然后调用Start(),然后启动服务端。

calculator:这个函数就是对应服务,第一步首下就是要从对应客户端读取数据,然后进行协议解析,然后反序列化,再按正常逻辑计算结果即可,最后序列化和添加报文,然后发送出去即可。

为什么需要协议解析以及添加报文:因为tcp是字节流式的,收到的数据可能并不完整,就是并不是一个数据,有可能是半个,也有可能是一个半,因为send/write这类接口是把数据写到缓冲区,其他的事情都归Tcp管,因为TCP是字节流式的,所以发送次数和接收次数,没有关系,不像udp发多少次就接受多少次。

Makefile:

.PHONY:all
all:client server
client:CalClient.cc
	g++ -o $@ $^ -std=c++11
server:CalServer.cc
	g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -rf client server

CalClient.cc:

#include <iostream>
#include "Sock.hpp"
#include "Protocol.hpp"

using namespace ns_protocol;

static void Usage(const std::string &process)
{
    std::cout << "\nUsage: " << process << " serverIp serverPort\n"
              << std::endl;
}

// ./client server_ip server_port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);
    Sock sock;
    int sockfd = sock.Socket();
    if (!sock.Connect(sockfd, server_ip, server_port))
    {
        std::cerr << "Connect error" << std::endl;
        exit(2);
    }
    bool quit = false;
    std::string buffer;
    while (!quit)
    {
        // 1. 获取需求
        Request req;
        std::cout << "Please Enter # ";
        std::cin >> req.x_ >> req.op_ >> req.y_;

        // 2. 序列化
        std::string s = req.Serialize();
        // std::string temp = s;
        // 3. 添加长度报头
        s = Encode(s);
        // 4. 发送给服务端
        Send(sockfd, s);

        // 5. 正常读取
        while (true)
        {
            bool res = Recv(sockfd, &buffer);
            if (!res)
            {
                quit = true;
                break;
            }
            std::string package = Decode(buffer);
            if (package.empty())
                continue;
            Response resp;
            resp.Deserialized(package);
            std::string err;
            switch (resp.code_)
            {
            case 1:
                err = "除0错误";
                break;
            case 2:
                err = "模0错误";
                break;
            case 3:
                err = "非法操作";
                break;
            default:
                std::cout << resp.x_ << resp.op_ << resp.y_ << " = " << resp.result_ << " [success]" << std::endl;
                break;
            }
            if(!err.empty()) std::cerr << err << std::endl;
            // sleep(1);
            break;
        }
    }
    close(sockfd);
    return 0;
}

CalClient.cc这个是客户端:

main():第一步接收数据(端口号和IP),然后创捷套接字,并且获取连接,然后进入一个正常的死循环,先是从键盘获取数据,然后序列化添加报头,发送给服务器,然后再从服务器读取数据,进行协议解析和反序列化,最后回显到显示器即可。

Daemon.hpp:

#pragma once

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

void MyDaemon()
{
    // 1. 忽略信号,SIGPIPE,SIGCHLD
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);

    // 2. 不要让自己成为组长
    if (fork() > 0)
        exit(0);
    // 3. 调用setsid
    setsid();
    // 4. 标准输入,标准输出,标准错误的重定向,守护进程不能直接向显示器打印消息
    int devnull = open("/dev/null", O_RDONLY | O_WRONLY);
    if(devnull > 0)
    {
        dup2(0, devnull);
        dup2(1, devnull);
        dup2(2, devnull);
        close(devnull);
    }
}

Daemon.hpp:作用是让一个进程变成守护进程

接下来解释一下什么是守护进程:

守护进程:

1.全部都是在前台运行的

2..前台进程:和终端关联的进程,前台进程。

3.任何xshell登陆,只允许一个前台进程和多个后台进程

4.进程除了有自己的pid,ppid,还有一个组ID

5.在命令行中,同时用管道启动多个进程,多个进程是兄弟关系,父进程都是bash -→>可以用匿名管道来进行通信,而同时被创建的多个进程可以成为一个进程组的概念,组长一般是第一个进程

6.任何一次登陆,登陆的用户,需要有多个进程(组)来给这个用户提供服务的(bash),用户自己可以启动很多进程,或者进程组。我们把给用户提供服务的进程或者用户自己启动的所有的进程或者服务,整体都是要属于一个叫做会话的机制中的。

7.如何将自己变成自成会话呢? 调用setsid0

8. setsid要成功被调用,必须保证当前进程不是进程组的组长,怎么保证我不是组长呢?调用fork()

9.守护进程不能直接向显示器打印消息一旦打印,会被暂停、终止

10.如何杀死守护进程,使用9号信号杀死

 Protocol.hpp:

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <jsoncpp/json/json.h>

namespace ns_protocol
{
#define MYSELF 0

#define SPACE " "
#define SPACE_LEN strlen(SPACE)
#define SEP "\r\n"
#define SEP_LEN strlen(SEP) // 不能是sizeof!

    class Request
    {
    public:
        // 1. 自主实现 "length\r\nx_ op_ y_\r\n"
        // 2. 使用现成的方案
        std::string Serialize()
        {
#ifdef MYSELF
            std::string str;
            str = std::to_string(x_);
            str += SPACE;
            str += op_; // TODO
            str += SPACE;
            str += std::to_string(y_);
            return str;
#else
            Json::Value root;
            root["x"] = x_;
            root["y"] = y_;
            root["op"] = op_;
            Json::FastWriter writer;
            return writer.write(root);
#endif
        }
        // "x_ op_ y_"
        // "1234 + 5678"
        bool Deserialized(const std::string &str)
        {
#ifdef MYSELF
            std::size_t left = str.find(SPACE);
            if (left == std::string::npos)
                return false;
            std::size_t right = str.rfind(SPACE);
            if (right == std::string::npos)
                return false;
            x_ = atoi(str.substr(0, left).c_str());
            y_ = atoi(str.substr(right + SPACE_LEN).c_str());
            if (left + SPACE_LEN > str.size())
                return false;
            else
                op_ = str[left + SPACE_LEN];
            return true;
#else
            Json::Value root;
            Json::Reader reader;
            reader.parse(str, root);
            x_ = root["x"].asInt();
            y_ = root["y"].asInt();
            op_ = root["op"].asInt();
            return true;
#endif
        }

    public:
        Request()
        {
        }
        Request(int x, int y, char op) : x_(x), y_(y), op_(op)
        {
        }
        ~Request() {}

    public:
        // 约定
        // x_ op y_ ? y_ op x_?
        int x_;   // 是什么?
        int y_;   // 是什么?
        char op_; // '+' '-' '*' '/' '%'
    };

    class Response
    {
    public:
        // "code_ result_"
        std::string Serialize()
        {
#ifdef MYSELF
            std::string s;
            s = std::to_string(code_);
            s += SPACE;
            s += std::to_string(result_);

            return s;
#else
            Json::Value root;
            root["code"] = code_;
            root["result"] = result_;
            root["xx"] = x_;
            root["yy"] = y_;
            root["zz"] = op_;
            Json::FastWriter writer;
            return writer.write(root);
#endif
        }
        // "111 100"
        bool Deserialized(const std::string &s)
        {
#ifdef MYSELF
            std::size_t pos = s.find(SPACE);
            if (pos == std::string::npos)
                return false;
            code_ = atoi(s.substr(0, pos).c_str());
            result_ = atoi(s.substr(pos + SPACE_LEN).c_str());
            return true;
#else
            Json::Value root;
            Json::Reader reader;
            reader.parse(s, root);
            code_ = root["code"].asInt();
            result_ = root["result"].asInt();
            x_ =  root["xx"].asInt();
            y_ =  root["yy"].asInt();
            op_ =  root["zz"].asInt();
            return true;
#endif
        }

    public:
        Response()
        {
        }
        Response(int result, int code, int x, int y, char op) 
        : result_(result), code_(code), x_(x), y_(y), op_(op)
        {
        }
        ~Response() {}

    public:
        // 约定!
        // result_? code_? code_ 0? 1?2?3?
        int result_; // 计算结果
        int code_;   // 计算结果的状态码

        int x_;
        int y_;
        char op_;
    };

    // 临时方案
    // 调整方案2: 我们期望,你必须给我返回一个完整的报文
    bool Recv(int sock, std::string *out)
    {
        // UDP是面向数据报:
        // TCP 面向字节流的:
        // recv : 你怎么保证,你读到的inbuffer,是一个完整完善的请求呢?不能保证
        // "1234 + 5678" : 1234 +
        // "1234 + 5678" : 1234 + 5678 123+99
        // "1234 "
        // 必须是:"1234 + 5678"
        // 单纯的recv是无法解决这个问题的,需要对协议进一步定制!
        char buffer[1024];
        ssize_t s = recv(sock, buffer, sizeof(buffer)-1, 0); // 9\r\n123+789\r\n
        if (s > 0)
        {
            buffer[s] = 0;
            *out += buffer;
        }
        else if (s == 0)
        {
            // std::cout << "client quit" << std::endl;
            return false;
        }
        else
        {
            // std::cout << "recv error" << std::endl;
            return false;
        }
        return true;
    }

    void Send(int sock, const std::string str)
    {
        // std::cout << "sent in" << std::endl;
        int n = send(sock, str.c_str(), str.size(), 0);
        if (n < 0)
            std::cout << "send error" << std::endl;
    }
    // "length\r\nx_ op_ y_\r\n..." // 10\r\nabc
    // "x_ op_ y_\r\n length\r\nXXX\r\n"
    std::string Decode(std::string &buffer)
    {
        std::size_t pos = buffer.find(SEP);
        if(pos == std::string::npos) return "";
        int size = atoi(buffer.substr(0, pos).c_str());
        int surplus = buffer.size() - pos - 2*SEP_LEN;
        if(surplus >= size)
        {
            //至少具有一个合法完整的报文, 可以动手提取了
            buffer.erase(0, pos+SEP_LEN);
            std::string s = buffer.substr(0, size);
            buffer.erase(0, size + SEP_LEN);
            return s;
        }
        else
        {
            return "";
        }
    }
    // "XXXXXX"
    // "123\r\nXXXXXX\r\n"
    std::string Encode(std::string &s)
    {
        std::string new_package = std::to_string(s.size());
        new_package += SEP;
        new_package += s;
        new_package += SEP;
        return new_package;
    }

}

protocal.hpp:这个文件里面主要包含了序列化和反序列化以及协议解析和添加报头

首先把内容封装在ns_protocal这个命名空间里面

Requst和Response这两个类分别是存储初始数据和结果,然后在里面各写了一份序列化和反序列化

Recv:就是把读取数据封装了一下

Send:就是把发送数据封装了

Decode:协议解析

Encode:添加报头

【实战指南】RF-DETR多场景部署:从工业质检到自动驾驶的SOTA模型应用 本文深入解析了SOTA目标检测模型RF-DETR在工业质检与自动驾驶等多场景下的实战部署指南。该模型基于Transformer架构,在COCO数据集上实现了实时检测与高精度的突破,并凭借其强大的泛化能力,在RF100-VL等复杂数据集上表现出色。文章提供了从快速Demo、工业缺陷检测微调、车载自适应部署到多硬件平台性能优化的完整解决方案,帮助开发者高效应用这一先进模型。 阅读详情

相关推荐

手把手教你离线部署Jupyter Notebook及高效插件配置

本文详细介绍了如何在离线环境中部署Jupyter Notebook及配置高效插件,包括离线安装步骤、依赖管理、核心扩展安装及常见问题排查。特别针对金融、科研等封闭网络场景,提供完整的whls包和requirements.txt解决方案,帮助开发者和数据分析师突破网络限制,提升工作效率。

weixin_28839549的博客 585

Linux — 网络基础二

应用层 负责应用程序之间的数据沟通 网络通信协议: 网络数据传输中的数据格式规定 自定义协议 序列化: 将数据对象按照持久化存储或者网络数据传输的格式来排布。 反序列化: 对持久化存储或者传输的数据以指定的协议进行解析的过程。 知名协议 HTTP ——超文本传输协议 URL —— 统一资源定位符(网址) URL编码 因为URL中特殊字符都具有特殊含义,因此查询字符串中有特殊字符时,会造成二义性,...

木头的博客 189

当VCSA管理界面打不开时,别慌!手把手教你通过ESXi控制台和SSH救急

本文详细介绍了当VCSA管理界面无法访问时的应急处理方案,包括通过ESXi控制台访问VCSA虚拟机、检查网络配置、启用SSH登录进行深度诊断等步骤。文章还提供了常见问题的解决方法,如清理磁盘空间、检查服务状态等,帮助运维人员快速恢复系统正常运行。

weixin_33704591的博客 319

『 Linux 』网络基础(二)

本质上采用大端字节序作为网络字节序主要是为了标准化,确保在不同系统之间数据能够被正确的解码,若是未指定字节序标准,当大端字节序接受到小端字节序发送的数据时将会解码错误;是面向数据包的协议,将数据划分成一个个独立的数据包,每个数据报在网络上传输时是一个独立的实体且具有边界,通常为单个数据报提供较小的负载;小端字节序中数据的低位字节存储在内存的低地址处,数据的高位字节存储在内存的高地址处,即数据从右往左进行存储;协议规定,多字节数据在传输数据时必须采用大端字节序,这意味着数据的高位字节先传输,低位字节后传输;

小侯宝的博客 1138

SpringBoot 系列教程(二):SpringBoot使用Devtools实现热部署

1.devtools   spring为开发者提供了一个名为spring-boot-devtools的模块来使Spring Boot应用支持热部署,提高开发者的开发效率,无需手动重启Spring Boot应用。 2.项目搭建   本文是采用IDEA搭建的Spring Boot应用,通过spring-boot-devtools配置,可以支持修改java文件会自动重启程序,一些资源无需触发重启,...

Thinkingcao的专栏 1216

YOLO小目标检测优化:9种实用方案,准确率直接提升15%

小目标检测是个系统工程,没有银弹,但有明确的优化路径。优先搞数据。Copy-Paste + 提升分辨率,这俩加起来成本最低、收益最大,能解决80%的小目标问题。别一上来就改模型结构。调参走在改结构前面。锚框聚类、损失加权、增强优化,这些都是零成本的,先做满了再说改模型的事。P2层是大杀器,但不要轻易用。加了P2层,TensorRT部署、后处理、速度都要跟着调,工程化工作量翻倍。数据和训练做到位还不够,再加也不迟。滑动窗口是兜底的。能从训练端解决的问题,就不要拖到推理端。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 196

Linux 网络基础(二)

网络基础再谈协议网络版计算器server.ccclient.ccprotocol.hppHTTP协议URLurlencode和urldecode通过套接字获取一个完整的http请求HTTP协议格式HTTP请求HTTP响应HTTP的方法GETPOSTHTTP状态码3XX重定向HTTP常见Header总结 再谈协议 协议是一种约定 socket api的接口,在读写数据时都是按字符串的方式来发送接受的 (xml/json) 序列化:将数据多变一的过程 反序列化:将数据一变多的过程 为什么需要序列化:方便网络的发

weixin_53946312的博客 1481

【推荐100个unity插件】将UE的资源导出到unity使用—— Exporter for Unreal to/for Unity插件

Unreal to Unity导出器是一款帮助开发者将Unreal Engine项目转换为Unity的工具。文章详细介绍了使用步骤:1)安装虚幻引擎并创建项目;2)在Plugins文件夹中安装导出插件;3)导入UE资产到Content文件夹;4)配置导出参数并完成转换。文末推荐了多个Unity开发专栏,涵盖C#编程、2D/3D开发、特效制作等内容。作者向宇提供了博客地址,欢迎读者交流学习。该工具能有效提升项目迁移效率,适合需要跨引擎开发的用户使用。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 858

linux-网络基础二

应用层 一端发送时构造的数据, 在另一端能够正确的进行解析, 就是ok的. 这种约定, 就是 应用层协议 负责程序之间的数据沟通 自定制协议: 结构化数据的传输 序列化:将数据对象按照指定协议组织成为可持久化存储/数据传输的二进制数据串格式 反序列化:二进制数据串按照指定的协议解析出数据对象 HTTP协议(超文本传输协议) 平时我们俗称的 “网址” 其实就是说的 URL URL:统一资源定位符 u...

PNUHC的博客 505

pymol 动画简单制作,gif、mp4导出

参考: https://www.youtube.com/watch?v=G77K9Lro8js1、直接Movie下Program下,Camera Loop下Nutate下选择,这里选择30degover4 sec;如果要动画过渡自然,可以在这4sec后面再Append 1sec;如果需要两个视角,既可以再把窗口蛋白定位到比如配体,不用管中间过程怎么定位过去配体,再Program下,Camera Loop下Nutate下选择,这里选择30degover4 sec添加;最后如果要整体形成个循环播放,可以在这4s

weixin_42357472的博客 8447

基于CNN-LSTM融合模型的环卫车动态称重算法研究:从频率感知到精准质量估计

摘要: 针对环卫车辆动态称重需求,本研究提出一种基于CNN-LSTM融合网络的频率分析方法。通过在实验室构建振动频率采集系统,获取不同载重下的结构响应数据,经MATLAB进行信号处理和特征提取后,建立频率-质量的非线性映射模型。实验表明,该算法在静态和模拟动态场景下平均绝对误差小于1.5%,显著优于传统方法,为环卫车智能化管理提供了高精度实时称重方案。 关键词: 动态称重;深度学习;频率分析;CNN-LSTM;MATLAB。

AI的内部世界的博客 377

【Linux】网络基础(二)

TCP/UDP 网络通信编程

奔赴在热爱征程上的小小孩~ 1035

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

Linux编程网络基础(二)

本文介绍了网络通信中端口号、套接字和传输层协议的关键概念。端口号作为2字节整数,用于标识主机上的特定进程,与IP地址共同构成套接字(Socket),形成网络通信的基础。端口号分为知名端口(0-1023)和动态分配端口(1024-65535),与进程ID不同,它是网络通信的标准化标识。传输层协议(TCP和UDP)通过系统调用实现网络通信,TCP提供可靠连接,UDP则无连接且不可靠。网络字节序采用大端模式,确保不同主机间的数据兼容性,相关转换函数(如htonl)处理主机与网络字节序的转换。

2302_80061080的博客 753

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

【Linux网络编程】网络基础二

介绍一下Linux网络编程中的网络基础二,包含UDP和TCP

zzg的学习博客 867

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

【Linux网络(二)】网络基础套接字

意思就是TCP协议在发送数据时, 不管一次性发送多少数据, 也不管数据一共要发送几次,它只关心能尽快的将数据从客户端发送到服务器. 所以说TCP在发送数据时, 完整的数据可能是: “abcdefg123456"但是第一次可能发送了"abcdefg1”,第二次再发送"234",再发送"56". 这都是不定的. 而UDP是面向数据报的, 它每次发送数据时, 会将完整的数据全部保存在一个报文中, 然后将这个数据报整体发送过去。1、网络协议中的下三层,主要决定的是,数据安全可靠的送到远端机器。

weixin_74792326的博客 1022

Linux之网络基础(二)

本文摘要(147字): 网络协议封装本质是逐层添加报头,形成"报头+有效载荷"结构。IP协议作为网络层核心,通过IPv4/IPv6地址实现全网寻址,与链路层MAC地址形成互补:IP地址(类似学号)标识通信端点且全程不变,MAC地址(类似驿站)负责相邻节点传输并逐跳改写。路由器基于IP地址进行跨网络路由决策,保持IP包完整仅重封装二层帧头。这种分层设计既解决MAC地址无法路由的问题,又通过IP协议统一不同局域网标准,实现异构网络互联。关键点在于IP地址决定路径选择,MAC地址完成实际数据交

2503_92261635的博客 211

【linux网络(二)】网络基础之套接字编程

本篇文章讲解网络基础之TCP/UDP协议的区别,讲解了网络字节序的相关概念,以及如何转换. 讲解网络套接字编程中常用的API,并且实现了一个简单的TCP服务器和客户端

杭电码农-NEO的博客 2033

Linux【二】- 网络基础【二】IP地址详解

一。IP包头  描述IP地址的位数只有32位。所以我们说在IPV4的数据包中,我们IP地址的数量只有2^32,因为是包头规定的。 二。IP地址 我们把32个二进制位分成四组。表示成十进制最大的是255.255.255.255 三。IP地址分类(按照标准子网掩码分类的) (一)A类IP A类根据第一个数字代表一个网段。例如:1.0.0.0和2.0.0.0不是一...

sunshine77_的博客 210

【ONE·Linux || 网络基础(二)】

主要内容:演示socke套接字编程(TCP模式),介绍序列化和反序列化,并进行演示(json版本达成协议编写、守护进程介绍)。

上士闻道,勤而行之。觉纷扰则静坐,觉懒看书则且看书 ♪(´▽`) 739

Linux——(十一)网络基础(二)

一、应用层1.HTTP协议 2.HTTPS协议 二、传输层 1. UDP协议 2. TCP协议

graceyun的博客 2349

【Linux网络编程二】网络基础2(网络框架)

【Linux网络编程二】网络基础2(网络框架)本篇重点:①跨网络如何通信②网络通信的本质③端口号④TCP/UDP协议⑤通用网络接口⑥网络字节序

Extreme_wei的博客 1135

Linux网络基础二:IP地址规划

一、IPv4网络类型 IPv4定义了5种地址类型,其中3类:A类、B类和C类网络由单播IP地址构成。单播地址可以标识一个单一的主机或接口,该地址能够唯一标识该设备。D类地址用于多播地址,因此大送给D类多播IPv4地址的数据包,实际上会传给多给主机。最后E类是试验性的,仅保留待将来使用。根据地址第一个八位组可以判断出网络类别: 类别 第一个八位组值 用途 A 1-126 单播 B...

linteng1994的博客 444

【Linux---21】网络基础②

TCP/IP四层中重要协议解析+特性原理 应用层: 负责应用程序之间的数据沟通 自定制协议: 网络版计算器:客户端传输两个数字以及运算符到服务端,服务端进行计算将结果返回 结构化数据传输: 序列化:按数据对象按照指定的协议组织成为能够进行持久化存储(磁盘存储)/数据传输的二进制数据串 反序列化:将二进制数据传按照指定的协议解析得到各个数据对象 typedef struct { ...

Austin_Yan的博客 300

【Linux网络】网络基础:传输层TCP协议(二)

在当今这个信息爆炸、网络互联的时代,TCP(Transmission Control Protocol,传输控制协议)作为互联网通信的基石之一,扮演着举足轻重的角色。无论是我们日常浏览网页、观看在线视频,还是企业进行大规模数据传输、云计算服务,TCP协议都默默地在幕后工作,确保数据的可靠、有序和高效传输。

EterNity_TiMe_的计算机学习之路 2137

Linux 网络基础(二) (传输协议层:UDP、TCP)

因为 TCP 是面向字节流的,所以需要应用层来分开这些报文,如果处理的不好就会出现多读了或者少读了影响到了后续报文,这种问题就叫做粘包。首先要明确,粘包问题中的 “包” 是指的应用层的数据包。在 TCP 的协议头中,没有如同 UDP 一样的 “报文长度” 这样的字段,但是有一个序号这样的字段。站在传输层的角度,TCP 是一个个报文过来的,按照序号排好序放在缓冲区中。站在应用层的角度,看到的只是一串连续的字节数据。

puppy_1mo的博客 2333

Linux 网络基础(二)---传输层

传输层端口号端口号划分常见的端口号查看知名端口号netstatpidofUDP协议udp协议端格式udp的特点面向数据报UDP的缓冲区UDP的使用注意事项基于UDP的应用层协议TCP协议TCP协议段格式确认应答(ACK)机制超时重传机制连接管理机制TIME_WAIT解决TIME_WAIT状态引起的bind失败的方法理解CLOSE_WAIT状态滑动窗口流量控制拥塞控制延迟应答捎带应答面向字节流粘包问题tcp异常情况tcp小结基于TCP应用层协议TCP与UDP对比用UDP实现可靠传输TCP相关listen的第二

weixin_53946312的博客 3820
上一篇: Linux网络编程套接字
下一篇: 传输层协议
pythoncjavac++
博客等级 码龄5年 718粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pythoncjavac++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值