网络——套接字编程TCP

news2024/9/22 13:43:43

目录

服务端

创建套接字（socket）

服务端绑定（bind）

服务端监听（listen）

服务器接收（accept）

服务端处理（read & write）

客户端

创建套接字（socket）

客户端连接（connect）

客户端处理（send & recv）​​​​​​​

多进程代码测试

捕获忽略SIGCHLD信号

子进程创建子进程

多线程代码测试    

线程池代码测试

服务端

创建套接字（socket）

        我们继续将TCP服务器封装成一个类，TCP创建套接字只有第二个参数不同，所需要的服务类型是SOCK_STREAM，这就是一个可靠的、需要链接的、全双工的、面向字节流的协议。

class TcpServer
{
public:
    TcpServer(uint16_t port, std::string ip = "")
        :_port(port)
        ,_ip(ip)
        ,_sock(-1)
    {}

    void initServer()
    {
        // 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "sock: %d", _sock);
    }

    ~TcpServer()
    {
        if (_sock > 0)
            close(_sock);
    }
private:
    uint16_t _port;
    std::string _ip;
    int _sock;
};

服务端绑定（bind）

        绑定的操作和UDP是差不多的，想要详细了解可以翻看上一篇。

    // 创建套接字
    // ...    

    // bind
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
        exit(3);
    }

服务端监听（listen）

        至此，创建套接字和绑定与UDP没有太大的差别，而TCP是面向连接的，客户端发送数据要先与TCP建立连接，然后才能通信。

        所以TCP要注意，随时都有可能从客户端发来连接请求，此时就需要将TCP服务器创建的套接字设置为监听状态，用到的函数就是listen。

参数：

  • sockfd：需要设置为监听状态的套接字文件描述符
  • backlog：全连接队列的最大长度，具体是什么后面再说，一般设置为5、10或20就可以

返回值：监听成功返回0，失败返回-1，错误码被设置。

        至此，我的服务器初始化任务已经完成了。

const static int g_backlog = 20;

void initServer()
{
    // 创建socket
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if (_sock < 0)
    {
        logMessage(FATAL, "%d:%s", errno, strerror(errno));
        exit(2);
    }
    logMessage(NORMAL, "sock: %d", _sock);

    // bind
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
        exit(3);
    }
    logMessage(NORMAL, "bind success ...");

    // tcp面向连接的，通信前要先建立连接，设置为监听状态，listen
    if (listen(_sock, g_backlog) < 0)
    {
        logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
        exit(4);
    }
    logMessage(NORMAL, "listen success ...");

    logMessage(NORMAL, "init server success");
}

服务器接收（accept）

        TCP服务器在与客户端进行通信之前，服务器需要先获取到客户端的连接请求，获取的函数就是accept。

参数：

  • sockfd：从该套接字中获取连接
  • addr：输出型参数，获取对端的网络属性信息
  • addrlen：输入输出型参数，返回实际读到的addr结构体的长度、

返回值：获取连接成功的对端套接字的文件描述符，失败返回-1，错误吗被设置。

accept返回值 vs sockfd：

  • sockfd是我们绑定的监听套接字，它只负责帮我们把获取的连接拿过来。
  • 而真正执行IO的就是accept返回的对端的套接字。

所以我们上述的_sock也叫做监听套接字listensock（_sock->listensock）。

void start()
{
    while (true)
    {
        // 获取连接accept
        struct sockaddr_in src; // 客户端addr
        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));
            // 接收失败也不影响，继续接收
            continue;
        }

        // 获取连接成功
        uint16_t client_port = ntohs(src.sin_port);
        std::string client_ip = inet_ntoa(src.sin_addr);
        logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n",
                    servicesock, client_ip.c_str(), client_port);

        // 处理任务

        close(servicesock);
    }
}

服务端处理（read & write）

static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{
    // echo
    char buffer[1024];
    while (true)
    {
        // read和write可以直接使用
        // 读取数据
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的消息当做字符串
            std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 代表对端关闭连接
            logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
            break; // 跳出循环结束通信
        }
        else
        {
            logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
            break;
        }

        // 写回数据
        write(sock, buffer, sizeof(buffer));
    }
}

// 获取连接成功
// ...

service(servicesock, client_ip, client_port);

close(servicesock);

        直接使用read和write就可以进行IO了，但是就有一个问题，当一个连接被接收到了，这个函数就是一个死循环，对端不退出会一直执行，那么如果此时再来一个连接那就会被阻塞。

        那我们就可以使用多进程，子进程负责处理接收的文件描述符，父进程负责接收描述符。

void start()
{
    signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态
    while (true)
    {
        // 获取连接accept
        // ...

        // 获取连接成功
        // ...

        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            // 子进程
            // 子进程也会继承父进程的文件与文件fd
            // 子进程提供服务，他不用管监听的事，所以要关闭
            close(listensock);
            service(servicesock, client_ip, client_port);
            exit(0);
        }
        // 父进程
        // 父进程只需要接收sock，所以要关闭服务sock
        close(servicesock);
    }
}

客户端

创建套接字（socket）

        初始化客户端，而客户端唯一要做的就是创建套接字，它不需要bind，也不需要listen，因为没有人会去连接客户端，那就更不需要accept接收了，它只需要知道服务端的IP和PORT就可以了。

// 1.创建套接字
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
    std::cerr << "socket error" << std::endl;
    exit(2);
}

客户端连接（connect）

        向服务端发起连接请求，使用的函数就是connect。

参数：

  • sockfd：通过该套接字发起连接请求
  • addr：服务端网络属性信息
  • addrlen：传入的addr结构体的长度

返回值：连接成功返回0，失败返回-1，错误码被设置。

        客户端不需要bind，当客户端向服务端发起连接请求，操作系统会自动给客户端分配端口号。

// 不需要显示绑定bind，OS自动选择port
// 2.向服务端发起建立连接的请求connect
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());

if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
{
    std::cerr << "connect error" << std::endl;
    exit(3);
}

客户端处理（send & recv）

        send和recv是TCP用来通信的接口，但是read和write也可以使用。

作用：发送数据到对端

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

参数：

  • sockfd：向创建的套接字写入
  • buf：要把哪个缓冲区中的数据写入
  • len：缓冲区的长度
  • flags：一般默认为0

返回值：成功返回发送的数据个数，失败返回-1，错误码被设置。

 

作用：接收对端的数据

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

参数：

  • sockfd：从哪个套接字中接收数据
  • buf：将接收的数据放到的缓冲区
  • len：缓冲区的长度
  • flags：一般设置为0

返回值：成功返回接收的个数，失败返回-1，错误码被设置。

while (true)
{
    std::string line;
    std::cout << "请输入: ";
    std::getline(std::cin, line);

    send(sock, line.c_str(), line.size(), 0);

    char buffer[1024];
    ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
    if (s > 0)
    {
        buffer[s] = 0;
        std::cout << "server echo: " << buffer << std::endl;
    }
    else if (s == 0)
    {
        // 对端关闭
        break;
    }
    else
    {
        break;
    }
}

多进程代码测试

捕获忽略SIGCHLD信号

// tcp_server.hpp

#pragma once
#include <iostream>
#include <string>

#include <cerrno>
#include <cstdio>
#include <cstring>
#include <cassert>

#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "log.hpp"

static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{
    // echo
    char buffer[1024];
    while (true)
    {
        // read和write可以直接使用
        // 读取数据
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的消息当做字符串
            std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 代表对端关闭连接
            logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
            break; // 跳出循环结束通信
        }
        else
        {
            logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
            break;
        }

        // 写回数据
        write(sock, buffer, strlen(buffer));
    }
}


class TcpServer
{
    const static int g_backlog = 20;

public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port), _ip(ip), listensock(-1)
    {}

    void initServer()
    {
        // 创建socket
        listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "sock: %d", listensock);

        // bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }
        logMessage(NORMAL, "bind success ...");

        // tcp面向连接的，通信前要先建立连接，设置为监听状态，listen
        if (listen(listensock, g_backlog) < 0)
        {
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }
        logMessage(NORMAL, "listen success ...");

        logMessage(NORMAL, "init server success");
    }

    void start()
    {
        signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态
        while (true)
        {
            // 获取连接accept
            struct sockaddr_in src; // 客户端addr
            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));
                // 接收失败也不影响，继续接收
                continue;
            }

            // 获取连接成功
            uint16_t client_port = ntohs(src.sin_port);
            std::string client_ip = inet_ntoa(src.sin_addr);
            logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n", servicesock, client_ip.c_str(), client_port);

            // v1 -- 单进程循环版
            // service(servicesock, client_ip, client_port);

            // v2 -- 多进程版
            pid_t id = fork();
            assert(id != -1);
            if (id == 0)
            {
                // 子进程
                // 子进程也会继承父进程的文件与文件fd
                // 子进程提供服务，他不用管监听的事，所以要关闭
                // 这是不是很像匿名管道呢
                close(listensock);
                service(servicesock, client_ip, client_port);
                exit(0);
            }
            // 父进程
            // 父进程只需要接收sock，所以要关闭服务sock
            close(servicesock);
        }
    }

    ~TcpServer()
    {
        if (listensock > 0)
            close(listensock);
    }

private:
    uint16_t _port;
    std::string _ip;
    int listensock;
};
// tcp_server.cc

#include "tcp_server.hpp"
#include <memory>

void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}

// ./tcp_server port
int main(int argc, char* argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    std::unique_ptr<TcpServer> svr(new TcpServer(port));

    svr->initServer();

    svr->start();

    return 0;
}
// tcp_client.cc

#include <iostream>
#include <unistd.h>
#include <string>

#include <cstring>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ip port\n" << std::endl;
}


int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }  

    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    // 1.创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }

    // 不需要显示绑定bind，OS自动选择port
    // 2.向服务端发起建立连接的请求connect
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
    {
        std::cerr << "connect error" << std::endl;
        exit(3);
    }

    // 连接成功
    std::cout << "connect success" << std::endl;
    while (true)
    {
        std::string line;
        std::cout << "请输入: ";
        std::getline(std::cin, line);

        send(sock, line.c_str(), line.size(), 0);
        char buffer[1024];
        ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "server echo: " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 对端关闭
            break;
        }
        else
        {
            break;
        }
    }
    close(sock);
    return 0;
}

子进程创建子进程

        其实多进程还有一种写法，我们再来看看这种写法是怎么实现的，这种写法没有用子进程退出向父进程发送SIGCHLD信号的特性。

void start()
{
    while (true)
    {
        // 获取连接accept
        // ...

        // 获取连接成功
        // ...

        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            // 子进程
            close(listensock);
            if (fork() > 0) exit(0); // 子进程fork创建孙子进程，子进程exit退出了
            // 孙子进程就变成了孤儿进程，孤儿进程会被系统领养，执行完后由操作系统释放
            service(servicesock, client_ip, client_port);
            exit(0);
        }
        // 父进程
        close(servicesock);
        waitpid(id, nullptr, 0); //阻塞式等待子进程退出
    }
}

多线程代码测试    

        创建进程的成本是很高的，创建进程时需要创建该进程对应task_struct、进程地址空间（mm_struct）等数据结构。而创建线程的成本就会会小得多，线程本质是在进程地址空间内运行，创建出来的线程会共享该进程的大部分资源，因此在实现多执行流的服务器时最好采用多线程进行实现。

class ThreadData
{
public:
    int sock;
    uint16_t port;
    std::string ip;
};

class TcpServer
{
    static void *threadRoutine(void *args)
    {
        pthread_detach(pthread_self()); // 线程分离，就不用join了
        ThreadData *td = (ThreadData *)args;
        service(td->sock, td->ip, td->port);

        delete td;

        return nullptr;
    }

private:
    void start()
    {
        while (true)
        {
            // 获取连接accept
            // ...

            // 获取连接成功
            // ...

            ThreadData *td = new ThreadData();
            td->sock = servicesock;
            td->ip = client_ip;
            td->port = client_port;
            pthread_t tid;
            // 多线程就不用关闭listensock文件描述符了，线程共享这些文件描述符
            pthread_create(&tid, nullptr, threadRoutine, (void *)td);
            close(servicesock);
        }
    }
};

再查看一下线程信息。

线程池代码测试

        当有新连接到来时，服务端的主线程都会重新为该客户端创建新线程，当服务结束后，将该线程销毁，在短时间内创建与销毁线程，这样做不仅麻烦，而且效率低，创建线程和销毁线程也是有成本的。
        所以为了解决这样的问题我们就可以引入线程池，客户端有发来任务，线程就为他服务，服务完后可以让线程休眠，再有任务来时再将线程唤醒。

        创建的线程也不能太多，要不然CPU的压力也会过大。如果这一批线程都在服务客户，再来一个客户端的连接就不能创建线程，应该让这个新来的连接请求在连接队列中排队，有空闲线程后再获取请求的连接为它提供服务。

        当有新的任务到来的时候，就Push到线程池中的任务队列中，多线程就不断检测任务队列中是否有任务，通过封装的任务类，调用仿函数执行相应的操作。

        这次我们想要实现一个网络词典的功能。

class TcpServer
{
public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port)
        , _ip(ip)
        , listensock(-1)
        , _threadpool_ptr(ThreadPool<Task>::getThreadPool()) // 获取线程池
    {}

    void start()
    {
        _threadpool_ptr->run();

        while (true)
        {
            // 获取连接accept
            // ...

            // 获取连接成功
            // ...

            Task t(servicesock, client_ip, client_port, dictOnline);
            _threadpool_ptr->pushTask(t);
        }
    }
private:
    // ...
    std::unique_ptr<ThreadPool<Task>> _threadpool_ptr; // 线程池指针
};

        添加成员变量_threadpool_ptr，用智能指针维护，在构造函数的初始化列表中调用getThreadPool获取线程池，因为线程池用了单例模式。当TCP服务端初始化完成后，调用start函数，首先就要启动线程池，当accept接受到对端的sock文件描述符后就可以制作任务，并push到任务队列中。

// Task.hpp

typedef std::function<void (int, const std::string&, const uint16_t&, const std::string&)> func_t;

class Task
{
public:
    Task(){}
    Task(int sock, const std::string& ip, const uint16_t port, func_t func)
        :_sock(sock)
        ,_ip(ip)
        ,_port(port)
        ,_func(func)
    {}
    void operator()(const std::string& name)
    {
        _func(_sock, _ip, _port, name);
    }    
public:
    int _sock;
    std::string _ip;
    uint16_t _port;
    func_t _func;
};

         我们想要实现一个从客户端接收一个英文单词，在单词的map中找，找到了就返回，没有找到就告知客户端词库中没有这个单词。

        这次我们采用短连接的方式，这个dictOnline函数就是修改了service函数，service函数使用的是死循环，一个线程对应一个客户端，如果这个客户端已经连接上了，它一直死循环不退出地做某件事，那么服务器接收的连接数就被限制了，所以来一个连接就服务一个，服务完之后，双方都断开连接。

static void dictOnline(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{
    // 网络词典
    static unordered_map<std::string, std::string> dict = {
        {"apple", "苹果"},
        {"banana", "香蕉"},
        {"process", "进程"},
        {"thread", "线程"}}; // 简易字典
    char buffer[1024];
    // read和write可以直接使用
    // 读取数据
    ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    if (s > 0)
    {
        buffer[s] = 0; // 将发过来的消息当做字符串
        std::cout << thread_name << " | " << clientip << " : " << clientport << "# " << buffer << std::endl;
        std::string message;
        auto iter = dict.find(buffer);
        if (iter == dict.end())
            message = "词库中无此单词";
        else
            message = iter->second;
        // 写回数据
        write(sock, message.c_str(), message.size());
    }
    else if (s == 0)
    {
        // 代表对端关闭连接
        logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
    }
    else
    {
        logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
    }
    close(sock);
}

        所以采用短连接，客户端可以死循环，每次执行完后就要关闭套接字，再一次连接的时候就要创建套接字。

void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ip port\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }

    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    int sock = 0;
    std::string line;

    while (true)
    {
        // 1.创建套接字
        sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0)
        {
            std::cerr << "socket error" << std::endl;
            exit(2);
        }

        // 不需要显示绑定bind，OS自动选择port
        // 2.向服务端发起建立连接的请求connect
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(serverport);
        server.sin_addr.s_addr = inet_addr(serverip.c_str());
        if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
        {
            std::cerr << "connect error" << std::endl;
            exit(3);
        }
        // 连接成功
        std::cout << "connect success" << std::endl;

        std::cout << "请输入英文: ";
        std::getline(std::cin, line);
        if (line == "quit")
            break;

        ssize_t s = send(sock, line.c_str(), line.size(), 0);
        if (s > 0)
        {
            char buffer[1024];
            s = recv(sock, buffer, sizeof(buffer) - 1, 0);
            if (s > 0)
            {
                buffer[s] = 0;
                std::cout << "中文: " << buffer << std::endl;
            }
        }
        close(sock);
    }
    return 0;
}

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

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

相关文章

安捷伦Agilent 34401A数字万用表

安捷伦Agilent 34401A数字万用表

181/2461/8938产品概述&#xff1a; Agilent34401A 万用表将准确性、速度、测量简便性和多功能性结合到坚固的 6 1/2 位数字万用表中&#xff0c;无论在工作台上还是在系统中都同样适用。您可以以 5 1/2 位数的价格获得 6 1/2 位数的性能。除了直流和交流电压、直流和交流电流…
阅读更多...
瑞吉外卖实战学习--登录过滤器和判断是否登录过

瑞吉外卖实战学习--登录过滤器和判断是否登录过

完善登录功能 1、创建自定义过滤器LoginCheckFiler1.1通过WebFilter创建过滤器1.2 验证是否可以拦截请求1.3 代码 2、在启动类加入注解ServletComponentScan 用来扫描过滤器触发所有的过滤器ServletComponentScan 3、完善过滤器的处理逻辑3.1判断是否需要是要放行的请求3.2判断…
阅读更多...
PTA引水入城

PTA引水入城

在一个遥远的国度&#xff0c;一侧是风景秀美的湖泊&#xff0c;另一侧则是漫无边际的沙漠。该国的行政区划十分特殊&#xff0c;刚好构成一个 N 行 M 列的矩形&#xff0c;如上图所示&#xff0c;其中每个格子都代表一座城市&#xff0c;每座城市都有一个海拔高度。 为了使居民…
阅读更多...
【Java - 框架 - Lombok】(2) SpringBoot整合Lombok完成日志的创建使用 - 快速上手；

【Java - 框架 - Lombok】(2) SpringBoot整合Lombok完成日志的创建使用 - 快速上手；

"SpringBoot"整合"Lombok"完成日志的创建使用 - 快速上手&#xff1b; 环境 “Java"版本"1.8.0_202”&#xff1b;“Lombok"版本"1.18.20”&#xff1b;“Spring Boot"版本"2.5.9”&#xff1b;“Windows 11 专业版_22621…
阅读更多...
安科瑞智慧安全用电综合解决方案

安科瑞智慧安全用电综合解决方案

概述 智慧用电管理云平台是智慧城市建设的延伸成果&#xff0c;将电力物联网技术与云平台的大数据分析功能相结合&#xff0c;实现用电信息的可视化管理&#xff0c;可帮助用户实现安全用电&#xff0c;节约用电&#xff0c;可靠用电。平台支持web&#xff0c;app&#xff0c;微…
阅读更多...
113 链接集11--ctrl+左键单击多选

113 链接集11--ctrl+左键单击多选

1.ctrl左键单击多选&#xff0c;单击单选 精简代码 <div class"model-list"><divmousedown.prevent"handleClick(item, $event)"class"model-list-item"v-for"item in modelList":key"item.id":class"{ model…
阅读更多...
【超全详解一文搞懂】Scala基础

【超全详解一文搞懂】Scala基础

目录 Scala 01 —— Scala基础一、搭建Scala开发环境安装Scala编译器在IDEA中进行scala编码 二、Scala简介与概述Scala简介Scala概述Scala代码规范 三、理解Scala变量与数据类型Scala的变量与常量Scala和Java变量的区别 Scala的数据类型 四、Scala的程序逻辑1.表达式2.运算符3.…
阅读更多...
SqlServer期末复习（数据库原理及应用）持续更新中

SqlServer期末复习（数据库原理及应用）持续更新中

一、SQL语句 1.1 SQL语句知识引入 1.DDL语言(数据定义语言&#xff09;主要是进行定义/改变表的结构、数据类型、表之间的链接等操作&#xff0c;关键字CREATE、DROP、ALTER CREATE TABLE 表面( 列名1 数据类型&#xff0c; 列名2 数据类型&#xff0c; ) ALTER TABLE 表名&a…
阅读更多...
GPU从虚拟化迈向池化：趋动OrionX产品的创新之路

GPU从虚拟化迈向池化：趋动OrionX产品的创新之路

/ 引言 / 随着人工智能&#xff08;AI&#xff09;和机器学习&#xff08;ML&#xff09;技术的飞速发展&#xff0c;图形处理单元&#xff08;GPU&#xff09;已成为数据中心和云计算环境中的关键资源。GPU的并行处理能力使其成为执行复杂计算任务的理想选择。 然而&#xff…
阅读更多...
数据在内存的存储（2）【浮点数在内存的存储】

数据在内存的存储（2）【浮点数在内存的存储】

一.浮点数以什么形式存储在内存中 根据根据国际标准IEEE&#xff08;电气和电子工程协会&#xff09;754&#xff0c;任意一个二进制浮点数V都可以存储为这样的形式&#xff1a; V&#xff08;-1&#xff09;^S*M*2^E。 &#xff08;1&#xff09;&#xff08;-1&#xff09;^…
阅读更多...
PEReDi 完全隐私的央行数字货币方案

PEReDi 完全隐私的央行数字货币方案

第一个对完全隐私保护建模的方案&#xff0c;基于账户模型&#xff0c;要求交易双方都在线。 角色分类 中央银行 B B B&#xff1a;负责发行数字货币和货币政策&#xff0c;但不控制用户账户的状态&#xff0c;没有能力对交易的发送者或接收者进行去匿名化或披露与特定交易相…
阅读更多...
【C++航海王：追寻罗杰的编程之路】queue

【C++航海王：追寻罗杰的编程之路】queue

目录 1 -> queue的介绍和使用 1.1 -> queue的介绍 1.2 -> queue的使用 1.3 -> queue的模拟实现 1 -> queue的介绍和使用 1.1 -> queue的介绍 queue的文档介绍 1. 队列是一种容器适配器&#xff0c;专门用于在FIFO(先进先出)上下文中操作&#xff0c;其…
阅读更多...
【C++】隐藏的this指针

【C++】隐藏的this指针

文章目录 1.this指针的引出2.this指针的特性 1.this指针的引出 我们通过日期类来学习this指针&#xff0c;首先我们先定义一个日期类。 class Date { public:void Display(){cout << _year << "-" << _month << "-" << _d…
阅读更多...
关于《海岛奇兵》中n点能量可造成最大伤害的计算

关于《海岛奇兵》中n点能量可造成最大伤害的计算

最近在玩海岛奇兵, 里面有 武器A, 第n次使用消耗(10 6 * (n - 1))点能量并造成18315伤害; 武器B, 第n次使用消耗 (3 2 * (n - 1))点能量并造成8124伤害, 就想着能不能写一个程序计算一下, 当有x点能量时, 可造成的最大伤害是多少? 分别使用AB武器各多少次? 讨论: https://…
阅读更多...
一文读懂！进销存系统如何及时分析产品采购价格？库存检验？以及财务对账？

一文读懂！进销存系统如何及时分析产品采购价格？库存检验？以及财务对账？

进销存管理系统如何及时分析产品采购价格&#xff1f;库存检验如何在进销存管理系统中进行&#xff1f;财务对账在进销存管理系统中如何实现&#xff1f;本文将为你一一解答&#xff0c;深入了解进销存管理系统的场景功能。 立即收藏&#xff0c;获取更多实用干货&#xff01;…
阅读更多...
【好书推荐3】Python网络爬虫入门到实战

【好书推荐3】Python网络爬虫入门到实战

【好书推荐3】Python网络爬虫入门到实战 写在最前面内容简介作者简介目录前言/序言 &#x1f308;你好呀&#xff01;我是 是Yu欸 &#x1f30c; 2024每日百字篆刻时光&#xff0c;感谢你的陪伴与支持 ~ &#x1f680; 欢迎一起踏上探险之旅&#xff0c;挖掘无限可能&#xff…
阅读更多...
中御海参已确定参加2024第七届燕窝天然滋补品博览会

中御海参已确定参加2024第七届燕窝天然滋补品博览会

参展企业介绍 烟台中御海参有限公司成立于2018年09月19日&#xff0c;公司坐落在山东省&#xff0c;详细地址为&#xff1a;山东省烟台市蓬莱区大辛店镇三甲村36号;经国家企业信用信息公示系统查询得知&#xff0c;烟台中御海参有限公司企业的经营范围为&#xff1a;食品生产&a…
阅读更多...
抖音小店赚钱吗？入驻抖店需要多少钱？一篇告诉你值不值得去做！

抖音小店赚钱吗？入驻抖店需要多少钱？一篇告诉你值不值得去做！

哈喽~我是电商月月 抖音是现在流量最大的软件&#xff0c;抖音赚钱的方式有很多&#xff0c;和直播&#xff0c;拍视频等形式来比&#xff0c;抖音小店绝对是最值得被新手小白关注的项目&#xff01; 商家和达人博主是互利共赢的关系 商家想靠达人卖货拿利润&#xff0c;主播…
阅读更多...
3.Python数据分析—数据分析入门知识图谱索引(知识体系中篇)

3.Python数据分析—数据分析入门知识图谱索引(知识体系中篇)

3.Python数据分析—数据分析入门知识图谱&索引-知识体系中篇 一个人简介二数据获取和处理2.1 数据来源&#xff1a;2.2 数据清洗&#xff1a;2.2.1 缺失值处理&#xff1a;2.2.2 异常值处理&#xff1a; 2.3 数据转换&#xff1a;2.3.1 数据类型转换&#xff1a;2.3.2 数据…
阅读更多...
解决“ModuleNotFoundError: No module named ‘transformers’”错误的全面指南

解决“ModuleNotFoundError: No module named ‘transformers’”错误的全面指南

一、问题背景与原因 在Python编程中&#xff0c;ModuleNotFoundError是一个常见的错误&#xff0c;表明解释器无法在指定的路径或Python环境中找到所需的模块。特别是当我们尝试导入像transformers这样的第三方库时&#xff0c;如果库没有被正确安装&#xff0c;就会遇到这样的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023