Linux-socket套接字

news2024/11/19 9:39:38

前言

        在当今数字化时代，网络通信作为连接世界的桥梁，成为计算机科学领域中至关重要的一部分。理解网络编程是每一位程序员必备的技能之一，而掌握套接字编程则是深入了解网络通信的关键。本博客将深入讨论套接字编程中的基本概念、常见API以及实际应用，通过一步步的学习，帮助读者逐渐掌握网络编程的精髓。

一、预备知识

1.1 IP

IP 是全球网络的基础，使用 IP 地址来标识公网环境下主机的唯一性，我们可以根据 目的IP地址 进行跨路由器的远端通信

仅仅使用 IP 只能定位到目标主机，并且目标主机不是最终目的地，要想定位目的地，需要依靠 端口号

目标主机中存在很多进程，网络通信实际是不同主机中的进程在进行通信，并非主机与主机直接通信

  • IP：源地址 与 目标地址
  • Port：目标地址中的哪个进程

1.2 端口号

        端口号 是一个用于标识网络进程唯一性的标识符，是一个 2 字节的整数，取值范围为 [0, 65535]，可以通过 端口号 定位主机中的目标进程

        抛开网络其他知识，将信息从主机 A 中的进程 A 发送至主机 B 中的 进程 B，这不就是 进程间通信 吗？之前学习的 进程间通信 是通过 匿名管道、命名管道、共享内存 等方式实现，而如今的 进程间通信 则是通过 网络传输 的方式实现

需要进行网络通信的进程有很多，为了方便进行管理，就诞生了 端口号 这个概念，同进程的 PID 一样，端口号 也可以用于标识进程

1.3 端口号与进程PID

端口号 用于标识进程，进程 PID 也是用于标识进程，为什么在网络中，不直接使用进程 PID 呢？

  • 进程 PID 隶属于操作系统中的进程管理，如果在网络中使用 PID，会导致网络标准中被迫中引入进程管理相关概念（进程管理与网络强耦合）
  • 进程管理 属于 OS 内部中的功能，OS 可以有很多标准，但网络标准只能有一套，在网络中直接使用 PID 无法确保网络标准的统一性
  • 并不是所有的进程都需要进行网络通信，如果端口号、PID 都使用同一个解决方案，无疑会影响网络管理的效率

        所以综上所述，网络中的 端口号 需要通过一种全新的方式实现，也就是一个 2 字节的整数 port，进程 A 运行后，可以给它绑定 端口号 N，在进行网络通信时，根据 端口号 N 来确定信息是交给进程 A 的

所以将之前的结论再具体一点：IP + Port 可以标识公网环境下，唯一的网络进程

网络传输中的必备信息组 [目的IP 源 IP || 目的 Port 源 Port]

  • 目的 IP：需要把信息发送到哪一台主机
  • 源 IP：信息从哪台主机中发出
  • 目的 Port：将信息交给哪一个进程
  • 源 Port：信息从哪一个进程中发出

注意： 端口号与进程 PID 并不是同一个概念

进程 PID 就好比你的身份证，端口号 相当于学号，这两个信息都可以标识唯一的你，但对于学校来说，使用学号更方便进行管理

一个进程可以绑定多个 端口号 吗？一个 端口号 可以被多个进程绑定吗？

        端口号 的作用是配合 IP 地址标识网络世界中进程的唯一性，如果一个进程绑定多个 端口号，依然可以保证唯一性（因为无论使用哪个 端口号，信息始终只会交给一个进程）；但如果一个 端口号 被多个进程绑定了，在信息递达时，是无法分辨该信息的最终目的进程的，存在二义性

所以一个进程可以绑定多个端口号，一个 端口号 不允许被多个进程绑定，如果被绑定了，可以通过 端口号 顺藤摸瓜，找到占用该 端口号 的进程

如果某个端口号被使用了，其他进程再继续绑定是会报错的，提示 该端口已被占用

主机（操作系统）是如何根据 端口号 定位具体进程的？

这个实现起来比较简单，创建一张哈希表，维护 <端口号, 进程 PID> 之间的映射关系，当信息通过网络传输到目标主机时，操作系统可以根据其中的 [目的 Port]，直接定位到具体的进程 PID，然后进行通信

1.4 传输层协议

主流的传输层协议有两个：TCP 和 UDP

两个协议各有优缺点，可以采用不同的协议，实现截然不同的网络程序，关于 TCP 和 UDP 的详细信息将会放到后面的博客中详谈，先来看看简单这两种协议的特点

TCP 协议：传输控制协议

  • 传输层协议
  • 有连接
  • 可靠传输
  • 面向字节流

字节流就像水龙头，用户可以根据自己的需求获取水流量

UDP 协议：用户数据协议

  • 传输层协议
  • 无连接
  • 不可靠传输
  • 面向数据报

数据报则是相当于包裹，用户每次获取的都是一个或多个完整的包裹

关于 可靠性
TCP 的可靠传输并不意味着它可以将数据百分百递达，而是说它在数据传输过程中，如果发生了传输失败的情况，它会通过自己独特的机制，重新发送数据，确保对端百分百能收到数据；至于 UDP 就不一样，数据发出后，如果失败了，也不会进行重传，好在 UDP 面向数据报，并且没有很多复杂的机制，所以传输速度很快

总结起来就是：TCP 用于对数据传输要求较高的领域，比如金融交易、网页请求、文件传输等，至于 UDP 可以用于短视频、直播、即时通讯等对传输速度要求较高的领域

如果不知道该使用哪种协议，优先考虑 TCP，如果对传输速度又要求，可以选择 UDP

1.5 网络字节序

在学习网络字节序相关知识前，先回顾一下大小端字节序

  • 数据拥有高权值位和低权值位，比如在 32 位操作系统中，十六进制数 0x11223344，其中的 11 称为 最高权值位，44 称为 最低权值位
  • 内存有高地址和低地址之分

如果将数据的高权值存放在内存的低地址处，低权值存放在高地址处，此时就称为 大端字节序，反之则称为 小端字节序，这两种字节序没有好坏之分，只是系统设计者的使用习惯问题，比如我当前的电脑在存储数据时，采用的就是 小端字节序 方案

通过内存单元可以看到，使用 小端字节序 时数据是倒着放的，大端字节序 就是正着存放了

在网络出现之前，使用大端或小端存储都没有问题，网络出现之后，就需要考虑使用同一种存储方案了，因为网络通信时，两台主机存储方案可能不同，会出现无法解读对方数据的问题

顶层设计者采用了解决方案2，TCP/IP 协议规定：网络中传输的数据，统一采用大端存储方案，也就是网络字节序， 现在大端/小端称为 主机字节序

发送数据时，将 主机字节序 转化为 网络字节序，接收到数据后，再转回 主机字节序 就好了，完美解决不同机器中的大小端差异，可以用下面这批库函数进行转换，在发送/接收时，调用库函数进行转换即可

#include <arpa/inet.h>

// 主机字节序转网络字节序
uint32_t htonl(uint32_t hostlong); // l 表示32位长整数
uint32_t htons(uint32_t hostshort); // s 表示16位短整数

// 网络字节序转主机字节序
uint32_t ntohl(uint32_t netlong); // l 表示32位长整数
uint32_t ntohs(uint32_t netshort); // s 表示16位短整数

二、 socket套接字

2.1 socket 常见API

socket 套接字提供了下面这一批常用接口，用于实现网络通信

#include <sys/types.h>
#include <sys/socket.h>

// 创建socket文件描述符（TCP/UDP	服务器/客户端）
int socket(int domain, int type, int protocol);

// 绑定端口号（TCP/UDP	服务器）
int bind(int socket, const struct sockaddr* address, socklen_t address_len);

// 开始监听socket (TCP	服务器)
int listen(int socket, int backlog);

// 接收连接请求 (TCP	服务器)
int accept(int socket, struct sockaddr* address, socklen_t* address_len);

// 建立连接 (TCP	客户端)
int connect(int sockfd, const struct sockaddr* addr, socklen_t addrlen);

可以看到在这一批 API 中，频繁出现了一个结构体类型 sockaddr，该结构体支持网络通信，也支持本地通信

socket 套接字就是用于描述 sockaddr 结构体的字段，复用了文件描述符的解决方案

2.2 sockaddr 结构体

        socket 这套网络通信标准隶属于 POSIX 通信标准，该标准的设计初衷就是为了实现 可移植性，程序可以直接在使用该标准的不同机器中运行，但有的机器使用的是网络通信，有的则是使用本地通信，socket 套接字为了能同时兼顾这两种通信方式，提供了 sockaddr 结构体

        由 sockaddr 结构体衍生出了两个不同的结构体：sockaddr_in 网络套接字、sockaddr_un 域间套接字，前者用于网络通信，后者用于本地通信

  • 可以根据 16 位地址类型，判断是网络通信，还是本地通信
  • 在进行网络通信时，需要提供 IP 地址、端口号 等网络通信必备项，本地通信只需要提供一个路径名，通过文件读写的方式进行通信（类似于命名管道）

socket 提供的接口参数为 sockaddr*，我们既可以传入 &sockaddr_in 进行网络通信，也可以传入 &sockaddr_un 进行本地通信，传参时将参数进行强制类型转换即可，这是使用 C语言 实现 多态 的典型做法，确保该标准的通用性

三、UDP套接字程序

该图引用于此，套接字运用流程图

3.1 简易本地通讯及bash模拟

分别实现客户端与服务器，客户端向服务器发送消息，服务器收到消息后，回响给客户端，有点类似于 echo 指令

该程序的核心在于 使用 socket 套接字接口，以 UDP 协议的方式实现简单网络通信

程序由 server.hpp、server.cc、client.hpp、client.cc 组成，大体框架如下

server.hpp头文件

server.cc文件

client.hpp头文件

client.cc文件

Makefile文件

四、TCP套接字程序

4.1 多进程版本地通信

#include<iostream>
#include<string>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<signal.h>
using namespace std;
 
void Usage(string proc)
{
    cout << "Usage: " << proc << "port" << endl;
}
void ServiceIO(int new_sock)
{
    // 提供服务
        while(true)
        {
            char buffer[1024];
            memset(buffer, 0, sizeof(buffer));
            ssize_t cnt = read(new_sock, buffer, sizeof(buffer) - 1);
            if(cnt > 0)
            {
                buffer[cnt] = 0;
                cout << "client# " << buffer << endl;
                string echo_string = "server--> ";
                echo_string += buffer;
                write(new_sock, echo_string.c_str(), echo_string.size());
            }
            else if(cnt == 0)
            {
                cout << "client quit..." << endl;
                break;
            }
            else
            {
                cerr << "read error" << endl;
                break;
            }
        }
}
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        return 1;
    }
    // 1.创建监听套接字
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0); // ipv4 , 流式套接
    if(listen_sock < 0)
    {
        cerr << "socket error: " << errno << endl;
        return 2;
    }
    // bind
    // 填充套接字信息
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[1]));
    local.sin_addr.s_addr = INADDR_ANY;
    if(bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cerr << "bind error" << errno << endl;
        return 3;
    }
    // 监听
    const int back_log = 5;
    if (listen(listen_sock, back_log) < 0)
    {
        cerr << "listen error" << errno << endl;
        return 4;
    }
 
    signal(SIGCHLD, SIG_IGN); // 在linux中父进程忽略子进程的SIGCHLD信号，子进程会自动退出释放资源
 
    while(true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int new_sock = accept(listen_sock, (struct sockaddr *)&peer, &len); 
        // 上面创建的监听套接字只起到监听作用
        // accept接口返回的套接字，才能为客户端提供服务
        if(new_sock < 0)
        {
            continue;
        }
        // peer: 输入输出型参数，存放客户端sock
        // 拿到客户端ip地址及端口：
        uint16_t client_port = ntohs(peer.sin_port); // 网络序列转主机序列
        string client_ip = inet_ntoa(peer.sin_addr); // inet_ntoa：将四字节ip转化成点分十进制ip
        cout << "get a new link -> : [" << client_ip << ":" << client_port << "]#" << new_sock << endl;
        pid_t id = fork();
        if(id<0)
        {
            continue;
        }
        else if(id==0) // 子进程会继承父进程的文件描述符, 为防止出现文件描述符泄露，需要关闭不用的文件描述符
        {
            // child
            close(listen_sock);
            ServiceIO(new_sock);
            close(new_sock); // 关闭文件描述符，否则会导致文件描述符泄露
            exit(0);
        }
        else
        {
            // father
            // do nothing
            close(new_sock); // 父进程关闭提供服务的文件描述符，继续接收新链接
        }
        }
    return 0;
}

4.2 多线程版

#include<iostream>
#include<string>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<signal.h>
#include<pthread.h>
using namespace std;
 
void Usage(string proc)
{
    cout << "Usage: " << proc << "port" << endl;
}
void ServiceIO(int new_sock)
{
    // 提供服务
        while(true)
        {
            char buffer[1024];
            memset(buffer, 0, sizeof(buffer));
            ssize_t cnt = read(new_sock, buffer, sizeof(buffer) - 1);
            if(cnt > 0)
            {
                buffer[cnt] = 0;
                cout << "client# " << buffer << endl;
                string echo_string = "server--> ";
                echo_string += buffer;
                write(new_sock, echo_string.c_str(), echo_string.size());
            }
            else if(cnt == 0)
            {
                cout << "client quit..." << endl;
                break;
            }
            else
            {
                cerr << "read error" << endl;
                break;
            }
        }
}
 
void* HandlerRequest(void*args)
{
    pthread_detach(pthread_self()); // 分离新线程
    int sock = *(int *)args;
    delete (args);
    ServiceIO(sock);
    close(sock); 
}
 
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        return 1;
    }
    // 1.创建监听套接字
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0); // ipv4 , 流式套接
    if(listen_sock < 0)
    {
        cerr << "socket error: " << errno << endl;
        return 2;
    }
    // bind
    // 填充套接字信息
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[1]));
    local.sin_addr.s_addr = INADDR_ANY;
    if(bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cerr << "bind error" << errno << endl;
        return 3;
    }
    // 监听
    const int back_log = 5;
    if (listen(listen_sock, back_log) < 0)
    {
        cerr << "listen error" << errno << endl;
        return 4;
    }
 
    signal(SIGCHLD, SIG_IGN); // 在linux中父进程忽略子进程的SIGCHLD信号，子进程会自动退出释放资源
 
    while(true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int new_sock = accept(listen_sock, (struct sockaddr *)&peer, &len); 
        // 上面创建的监听套接字只起到监听作用
        // accept接口返回的套接字，才能为客户端提供服务
        if(new_sock < 0)
        {
            continue;
        }
        // peer: 输入输出型参数，存放客户端sock
        // 拿到客户端ip地址及端口：
        uint16_t client_port = ntohs(peer.sin_port); // 网络序列转主机序列
        string client_ip = inet_ntoa(peer.sin_addr); // inet_ntoa：将四字节ip转化成点分十进制ip
        cout << "get a new link -> : [" << client_ip << ":" << client_port << "]#" << new_sock << endl;
        
        // 创建新线程
        pthread_t tid;
        int *pram = new int(new_sock);
        pthread_create(&tid, nullptr, HandlerRequest, pram);
        // 这里主线程不需要关闭new_sock文件描述符，因为主线程与新线程共享一个文件描述符数组，主线程关闭new_sock会导致新线程也关闭
        }
    return 0;
}

4.3 线程池版

#include<iostream>
#include<string>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<cstring>
#include<unistd.h>
#include<signal.h>
#include<pthread.h>
#include"thread_pool.hpp"
#include"task.hpp"
using namespace std;
 
void Usage(string proc)
{
    cout << "Usage: " << proc << "port" << endl;
}
 
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        return 1;
    }
    // 1.创建监听套接字
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0); // ipv4 , 流式套接
    if(listen_sock < 0)
    {
        cerr << "socket error: " << errno << endl;
        return 2;
    }
    // bind
    // 填充套接字信息
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[1]));
    local.sin_addr.s_addr = INADDR_ANY;
    if(bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cerr << "bind error" << errno << endl;
        return 3;
    }
    // 监听
    const int back_log = 5;
    if (listen(listen_sock, back_log) < 0)
    {
        cerr << "listen error" << errno << endl;
        return 4;
    }
 
    signal(SIGCHLD, SIG_IGN); // 在linux中父进程忽略子进程的SIGCHLD信号，子进程会自动退出释放资源
 
    while(true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int new_sock = accept(listen_sock, (struct sockaddr *)&peer, &len); 
        // 上面创建的监听套接字只起到监听作用
        // accept接口返回的套接字，才能为客户端提供服务
        if(new_sock < 0)
        {
            continue;
        }
        // peer: 输入输出型参数，存放客户端sock
        // 拿到客户端ip地址及端口：
        uint16_t client_port = ntohs(peer.sin_port); // 网络序列转主机序列
        string client_ip = inet_ntoa(peer.sin_addr); // inet_ntoa：将四字节ip转化成点分十进制ip
        cout << "get a new link -> : [" << client_ip << ":" << client_port << "]#" << new_sock << endl;
        // 1.创建任务
        Task t(new_sock);
        // 2.将任务放进线程池
        ThreadPool<Task>::GetInstance()->PushTask(t);
        }
    return 0;
}

五、总结

  • 创建socket的过程(socket())，本质是打开文件。(仅有系统相关的内容)
  • bind()，struct sockaddr_in -> ip，port，本质是ip+port和文件信息进行关联
  • listen()，本质是设置该socket文件的状态，允许别人来连接我
  • accpet()，获取新链接到应用层，是以fd为代表的；所谓的连接，在OS层面，本质其实就是一个描述连接的结构体(文件)
  • read/write，本质就是进行网络通信，对于用户来讲就相当于在进行正常的文件读写
  • close(fd)，关闭文件；系统层面，释放曾经申请的文件资源，连接资源等；网络层面，通知对方，我的连接已经关闭了
  • connect()，本质是发起连接，在系统层面，就是构建一个请求报文发送过去；网络层面，发起tcp连接的三次握手
  • close()，client、server，本质在网络层面就是在进行四次挥手

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++指针（五）完结篇

C++指针（五）完结篇

个人主页&#xff1a;PingdiGuo_guo 收录专栏&#xff1a;C干货专栏 前言 相关文章&#xff1a;C指针&#xff08;一&#xff09;、C指针&#xff08;二&#xff09;、C指针&#xff08;三&#xff09;、C指针&#xff08;四&#xff09;万字图文详解&#xff01; 本篇博客是介…
阅读更多...
Independent Variable Dependent Variable

Independent Variable Dependent Variable

自变量&#xff08;Independent Variable&#xff09; -----------> 因变量&#xff08;Dependent Variable&#xff09; 数据 ----------------------------------------------结果&#xff0c;报告等等
阅读更多...
面试宝典-【redis】

面试宝典-【redis】

目录 1.什么是缓存穿透 ? 怎么解决 ? 2.什么是布隆过滤器 3.什么是缓存击穿 ? 怎么解决 ? 4.什么是缓存雪崩 ? 怎么解决 ? 5.redis做为缓存&#xff0c;mysql数据如何与redis进行同步?(双写) 6.排他锁是如何保证读写、读读互斥的呢&#xff1f; 7.你听说过延…
阅读更多...
3月10日

3月10日

微机原理 1M1000k 1000/5200 200 NMI INTR 主 从 从 8-288 ZF0 100H MOVBX,[DI] 0AA55 基址 寄存器 ENDS SP 指示型和指令行的区别 指令型的语句是可执行的最终产生机器码会上机运行需要CPU去运行 指示型语句是指示如何汇编 数据定义 DB DW 符号定义 EQU 取值 TYPE OF…
阅读更多...
Vite：下一代前端开发与构建工具

Vite：下一代前端开发与构建工具

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
基于鹦鹉优化算法（Parrot optimizer，PO）的无人机三维路径规划（提供MATLAB代码）

基于鹦鹉优化算法（Parrot optimizer，PO）的无人机三维路径规划（提供MATLAB代码）

一、无人机路径规划模型介绍 无人机三维路径规划是指在三维空间中为无人机规划一条合理的飞行路径&#xff0c;使其能够安全、高效地完成任务。路径规划是无人机自主飞行的关键技术之一&#xff0c;它可以通过算法和模型来确定无人机的航迹&#xff0c;以避开障碍物、优化飞行…
阅读更多...
鲜为人知的闰年判定大坑

鲜为人知的闰年判定大坑

【题目描述】 输入年份&#xff0c;判断是否为闰年。如果是&#xff0c;则输出yes&#xff0c;否则输出no。 提示&#xff1a;简单地判断除以4的余数是不够的。 【题目来源】 刘汝佳《算法竞赛入门经典 第2版》习题1-7　年份&#xff08;year&#xff09; 【解析】 一、闰…
阅读更多...
多线程多进程处理服务器并发（多进程处理如何解决僵死进程）

多线程多进程处理服务器并发（多进程处理如何解决僵死进程）

目录 1.可循环发送数据的代码 2.改成循环之后每次发现只能处理一个客户端 3.服务器端处理并发问题 3.1 思路 3.2 利用多线程实现并发 ​编辑 3.3 利用多进程实现并发 3.3.1 多进程并发产生的僵死进程问题 ​3.3.2 解决僵死进程问题 1.可循环发送数据的代码 服务器代…
阅读更多...
vue 在什么情况下在数据发生改变的时候不会触发视图更新

vue 在什么情况下在数据发生改变的时候不会触发视图更新

在 Vue 中&#xff0c;通常数据发生变化时&#xff0c;视图会自动更新。但是&#xff0c;有几种情况可能导致数据变化不会触发视图更新&#xff1a; 1.对象属性的添加或删除&#xff1a; Vue 无法检测到对象属性的添加或删除。因为 Vue 在初始化实例时对属性执行了 getter/se…
阅读更多...
【教学类-34-09】20240310华文彩云学号拼图（3*3格子浅灰底图 深灰拼图块）（AI对话大师）

【教学类-34-09】20240310华文彩云学号拼图（3*3格子浅灰底图 深灰拼图块）（AI对话大师）

作品展示 背景需求&#xff1a; 制作了两位数的学号3*3格子&#xff0c; 【教学类-34-05】20230523拼图&#xff08;数字学号0X-长方块拼图-双色深灰浅灰&#xff09;3*3格子&#xff08;中班主题《个别化拼图》偏艺术-美术&#xff09;_灰底白色方块数字怎么制作-CSDN博客文…
阅读更多...
PhantomCrawler：一款功能强大的多代理IP网站请求生成工具

PhantomCrawler：一款功能强大的多代理IP网站请求生成工具

关于PhantomCrawler PhantomCrawler是一款功能强大的多代理IP网站请求生成工具&#xff0c;该工具允许广大研究人员通过不同的代理IP地址来模拟与目标Web站点的交互行为。 PhantomCrawler基于Python、requests和BeautifulSoup实现其功能&#xff0c;并提供了一种简单且高效的方…
阅读更多...
【Linux】gcc与make、makefile

【Linux】gcc与make、makefile

文章目录 1 gcc/g1.1 预处理1.2 编译1.3 汇编1.4 链接1.4.1 静态链接1.4.2 动态链接 2 make和makefile2.1 依赖关系2.2 依赖方法2.3 伪目标 3 总结 1 gcc/g 当我们创建一个文件&#xff0c;并向里面写入代码&#xff0c;此时&#xff0c;我们该如何使我们的代码能够运行起来呢&…
阅读更多...
Delphi 的Read 与Readln 的区别

Delphi 的Read 与Readln 的区别

结合运行窗口&#xff0c;你输入1 2 3 4 这是一行ReadLn在读入时把这四个数当成一行&#xff0c;read(a,b)只读入了前两个数&#xff1a;1 2&#xff0c;就准备读下一行了&#xff0c;下一行输入3&#xff0c;再下一行输入2&#xff0c;所以输出1232&#xff1b; Read是逐个读…
阅读更多...
【MySQL 系列】MySQL 语句篇_DQL 语句

【MySQL 系列】MySQL 语句篇_DQL 语句

DQL&#xff08;Data Query Language&#xff09;&#xff0c;即数据查询语言&#xff0c;用来查询数据记录。DQL 基本结构由 SELECT FROM、WHERE、JOIN 等子句构成。 DQL 语句并不会改变数据库&#xff0c;而是让数据库将查询结果发送结果集给客户端&#xff0c;返回的结果是一…
阅读更多...
IDEA打开项目文件目录不见了

IDEA打开项目文件目录不见了

偶尔发生新拉下来的代码&#xff0c;或者旧代码修改了包名&#xff0c;项目名称等&#xff0c;idea左侧project一栏不显示代码的文件目录。例如下面此时不要慌张&#xff0c;不用删除项目重新拉取&#xff0c;通过以下方式解决&#xff1a; 本人尝试能够解决&#xff0c;如果无…
阅读更多...
Learn OpenGL 05 变换

Learn OpenGL 05 变换

万向节死锁 万向节死锁&#xff08;Gimbal Lock&#xff09;是用欧拉角定义旋转时&#xff0c;产生的在某一情况下旋转轴重合导致的系统丢失自由度的情况&#xff0c;一种最简单的解决方式是调整三维软件中的旋转轴顺序来避免该情况发生。 也就是说当中间轴旋转至90的时候就会…
阅读更多...
Vue+ElementUI启动vue卡死的问题

Vue+ElementUI启动vue卡死的问题

0 引言 今天&#xff0c;博主在学习vueelementui的时候遇到一个问题&#xff0c;卡了博主很久。 1 问题复现 在vue页面的<template>标签中写入两个<div>标签&#xff0c; <template><div><h1>第一个div标签</h1><el-table></…
阅读更多...
vue学习笔记21-组件传递数据_Props

vue学习笔记21-组件传递数据_Props

组件与组件之间不是完全独立的&#xff0c;而是有交集的&#xff0c;那就是组件与组件之间是可以传递数据的 传递数据的解决方案就是props 父级&#xff1a; 在父级中引入子集 <template><h3>Parent</h3><Child/> </template><script> i…
阅读更多...
适配器模式已经在SpringMVC中的源码实现

适配器模式已经在SpringMVC中的源码实现

介绍&#xff1a; 1、适配器模式将某个类的接口转换成客户端期望的另一种接口表示 2、目的&#xff1a;兼容性&#xff0c;让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为&#xff1a;包装器。 3、属于&#xff1a;结构型模式 4、分3类&#xff1a;1&#xff0…
阅读更多...
方程式工具包远程溢出漏洞图形界面版V0.3（内置永恒之蓝、永恒冠军、永恒浪漫等）

方程式工具包远程溢出漏洞图形界面版V0.3（内置永恒之蓝、永恒冠军、永恒浪漫等）

Part1 前言 大家好&#xff0c;我是ABC_123。我从年前到现在&#xff0c;一直在整理曾经写过的红队工具&#xff0c;逐步把自己认为比较好用的原创工具发出来给大家用一用&#xff0c;方便大家在日常的攻防比赛、红队评估项目中解放双手&#xff0c;节省时间精力和体力。本期给…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023