协议的定制之序列化与反序列化 | 守护进程

目录

一、再谈协议

二、序列化与反序列化

三、网络计算器的简单实现

四、网络计算器完整代码

五、代码改进

六、守护进程

七、Json序列化与反序列化

八、netstat

一、再谈协议

是对数据格式和计算机之间交换数据时必须遵守的规则的正式描述。简单的说了，网络中的计算机要能够互相顺利的通信，就必须讲同样的语言，语言就相当于协议。

为了使数据在网络上能够从源主机到达目的主机，网络通信的参与方必须遵循相同的规则，我们将这套规则称为协议。只有使用相同的协议，主机间才能进行通信。 

二、序列化与反序列化

今天，我们作为客户端，想要让服务端帮助我们进行计算，然后将结果返回给我们，这就是一个网络计算器了。如果我们要计算两数相加，比如 a+b，那么现在问题来了，我们应该如何将a，+，b这三个数据传输给服务器呢？是一个一个传呢，还是整体传输呢？

如果客户端将这些结构化的数据单独一个个的发送到网络当中，那么服务端从网络当中获取这些数据时也只能一个个获取，此时服务端还需要考虑，哪个是左操作数，哪个是操作符，哪个是右操作数。所以这样不合适。

对于一起发送。a，+，b三个数据组成一组结构化的数据，我们首先想到使用一个结构体将三个数据打包，一起发送给服务器，而我们所用的各种通信函数只允许我们传输字符串，所以我们必须要将结构化的数据先转化成字符串，然后才能发送给服务器。而服务器接收到字符串后，则必须将字符串进行解析，转成结构化的数据，进行计算，然后将结果转成字符串发回客户端。这个过程就叫做“序列化”和“反序列化”。

~ 序列化：就是将对象的状态信息转换为可以存储或传输的形式（字节序列）的过程。

~ 反序列化：就是把字节序列恢复为对象的过程。

具体怎么实现，我们通过编写网络计算器来进行讲解。

三、网络计算器的简单实现

对于网络计算器的客户端，我们使用一个结构体去存储左右操作数和操作符，这个结构体我们称为请求（Request），在向服务端发送请求的时候，我们需要转成字符串才能发送，于是我们需要有序列化的函数，当然，收到结果后，我们也需要反序列化函数，将字符串结果转成结构化结果。

对于服务端，我们使用一个结构体去存储计算结果和标识计算结果的正确性，因为客户端可能会发过来除0或者模0的请求。在收到客户端的请求后，我们需要反序列化函数将结果转成结构化数据，方便计算，发回结果的时候，需要序列化函数将结果转成字符串才能发送。

四、网络计算器完整代码

Sock.hpp

我们对网络套接字进行一个封装。

#pragma once
#include <iostream>
#include <string>
#include <cstdbool>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class Sock
{
public:
    const static int gmv = 20;
    Sock()
    {
    }

    int Socket()
    {
        // 1.创建套接字
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(1);
        }
        std::cout << "创建套接字成功！" << std::endl;
        return sock;
    }

    void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
    {
        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &src_server.sin_addr);
        socklen_t len = sizeof(src_server);
        if (bind(sock, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(2);
        }
        std::cout << "绑定成功！" << std::endl;
    }

    void Listen(int sock)
    {
        // 3.开始监听,等待连接
        if (listen(sock, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(3);
        }

        std::cout << "服务器监听成功！" << std::endl;
    }

    int Accept(int sock, std::string *ip, uint16_t *port)
    {
        // 4.获取链接
        struct sockaddr_in client_sock;
        socklen_t len = sizeof(client_sock);
        int serversock = accept(sock, (struct sockaddr *)&client_sock, &len);
        if (serversock < 0)
        {
            std::cout << "获取链接失败！" << std::endl;
            return -1;
        }
        if (port)
            *port = ntohs(client_sock.sin_port);
        if (ip)
            *ip = inet_ntoa(client_sock.sin_addr);
        return serversock;
    }

    bool Connect(int sock, const std::string &ip, const uint16_t &port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof server);
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(ip.c_str());
        server.sin_port = htons(port);
        if (connect(sock, (struct sockaddr *)&server, sizeof(server)) == 0)
            return true;
        else
            return false;
    }

    ~Sock()
    {
    }
};

TcpServer.hpp： 

#pragma once
#include "Sock.hpp"
#include <functional>
#include <pthread.h>

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
{
private:
    static void *threadRoutine(void *arg)
    {
        pthread_detach(pthread_self());
        threaddata *td = (threaddata *)arg;
        td->server_->excute(td->sock_);
        close(td->sock_);
        delete td;
    }

public:
    TcpServer(const uint16_t &port, const std::string &ip = "0.0.0.0")
    {
        listensock_ = sock_.Socket();
        sock_.Bind(listensock_, port, ip);
        sock_.Listen(listensock_);
    }

    void BindServer(func_t func)
    {
        func_ = func;
    }

    void excute(int sock)
    {
        func_(sock);
    }

    void Start()
    {
        for (;;)
        {
            std::string clientip;
            uint16_t clientport;
            int sock = sock_.Accept(listensock_, &clientip, &clientport);
            if (sock == -1)
                continue;

            threaddata *td = new threaddata(sock, this);
            pthread_t tid;
            pthread_create(&tid, nullptr, threadRoutine, td);
        }
    }

    ~TcpServer()
    {
        if (listensock_ >= 0)
            close(listensock_);
    }

private:
    int listensock_;
    Sock sock_;
    func_t func_;
};

Protocol.hpp：协议定制

我们规定序列化的结果是"x_ op_ y_”，即：左操作数，空格，操作符，空格，左操作数。

#pragma once
#include <iostream>
#include <string>
#include <cstdbool>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstdlib>
#include <cstring>

#define SPACE " "
#define SPACELEN strlen(SPACE)

std::string Recv(int sock)
{
    char buffer[1024];
    ssize_t s = recv(sock, buffer, sizeof buffer, 0);
    if (s == 0)
        std::cout << "客户端退出！" << std::endl;
    else if (s > 0)
        return buffer;
    else
        std::cerr << "客户端退出！" << std::endl;

    return "";
}

void Send(int sock, const std::string &str)
{
    ssize_t s = send(sock, str.c_str(), str.size(), 0);
}

class Request
{
public:
    std::string Serialize()
    {
        std::string requeststr = std::to_string(x_);
        requeststr += SPACE;
        requeststr += op_;
        requeststr += SPACE;
        requeststr += std::to_string(y_);
        return requeststr;
    }

    // x_ op_ y_
    bool Deserialization(const std::string &str)
    {
        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 + SPACELEN).c_str());
        op_ = str[left + SPACELEN];
        return true;
    }

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

public:
    int x_;
    int y_;
    char op_;
};

class Response
{
public:
    // code_ result_
    std::string Serialize()
    {
        std::string str = std::to_string(code_);
        str += SPACE;
        str += std::to_string(result_);
        return str;
    }

    bool Deserialization(std::string &str)
    {
        std::size_t pos = str.find(SPACE);
        if (pos == std::string::npos)
            return false;
        code_ = atoi(str.substr(0, pos).c_str());
        result_ = atoi(str.substr(pos + SPACELEN).c_str());
        return true;
    }

public:
    Response(const int &result = 0, const int &code = 0) : result_(result), code_(code) {}
    ~Response() {}

public:
    int result_;
    int code_;
};

CalServer.cc：

#include "tcpserver.hpp"
#include "Protocol.hpp"
#include <signal.h>
#include <memory>

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

Response CalculatorHelper(const Request &req)
{
    Response res(0, 0);
    switch (req.op_)
    {
    case '+':
        res.result_ = req.x_ + req.y_;
        break;
    case '-':
        res.result_ = req.x_ - req.y_;
        break;
    case '*':
        res.result_ = req.x_ * req.y_;
        break;
    case '/':
        if (0 == req.y_)
            res.code_ = 1;
        else
            res.result_ = req.x_ / req.y_;
        break;
    case '%':
        if (0 == req.y_)
            res.code_ = 2;
        else
            res.result_ = req.x_ % req.y_;
        break;
    default:
        res.code_ = 3;
        break;
    }
    return res;
}

void Calculator(int sock)
{
    while (true)
    {
        std::string buffer = Recv(sock);
        if (!buffer.empty())
        {
            Request req;
            req.Deserialization(buffer);
            Response res = CalculatorHelper(req);
            std::string sendstr = res.Serialize();
            Send(sock, sendstr);
        }
        else break;
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    signal(SIGPIPE, SIG_IGN);
    uint16_t server_port = atoi(argv[1]);
    std::unique_ptr<TcpServer> sev(new TcpServer(server_port));
    sev->BindServer(Calculator);
    sev->Start();

    return 0;
}

CalClient.cc：

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstdlib>
#include <unistd.h>
#include "Sock.hpp"
#include "Protocol.hpp"

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

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);
    Sock sock;
    int sockfd = sock.Socket();
    if (!sock.Connect(sockfd, ip, port))
    {
        std::cout << "连接出错！" << std::endl;
        exit(2);
    }
    std::cout << "连接成功！" << std::endl;

    while (true)
    {
        Request req;
        std::cout << "请输入x # ";
        std::cin >> req.x_;
        std::cout << "请输入y # ";
        std::cin >> req.y_;
        std::cout << "请输入op # ";
        std::cin >> req.op_;

        std::string sendstr = req.Serialize();
        Send(sockfd, sendstr);

        std::string recstr = Recv(sockfd);
        Response res;
        res.Deserialization(recstr);
        std::cout << "code_: " << res.code_ << std::endl;
        std::cout << "result_: " << res.result_ << std::endl;
    }

    return 0;
}

运行结果：

五、代码改进

其实，上面我们 Protocol.hpp 中的代码是有问题的？为什么呢？

我们早就说过，TCP是面向字节流的，所以在从网络中读取的时候，并不能保证发送和读取到的是一个完整的 x_ op_ y_ 结构，可能只发送或者读取了 x_ op_，也可能是 x_ op_ y_  x_ op_ y_  x_ op_ y_。所以客户端和服务器不能准确区分，因此我们需要对发送和读取进行控制，使得每次发送和读取到的都是一个完整的报文。

我们所使用的TCP协议是传输层协议。在TCP层，拥有两个缓冲区：发送缓冲区和接收缓冲区。我们调用的所有发送函数，并不是直接把数据发送到网络中，而是将数据由应用层拷贝到TCP的发送缓冲区中，由TCP协议决定如何发送这些数据和每次发送多少数据。接收函数也不是直接从网络中获取数据，而是从发送缓冲区拷贝数据到应用层。至于数据如何到TCP的接收缓冲区，也是完全由TCP协议决定。

因此，发送函数和接收函数本质上是拷贝函数。

因此我们可以将序列化的数据定成这种结构  length\r\nx_ op_ y_\r\n（或者 length\r\ncode_ result_\r\n） ，我们通过length来标定正文长度，使用\r\n来分隔length和正文。

知道length，就可以知道怎样读取多长的数据了，这样就可以读取到完整的报文。而发送的时候任然是面向字节流式的发送，不过我们需要添加 length 和特殊符号 \r\n，再发送。

在Protocol.hpp：协议定制里面，我们还需要修改下面的代码：Encode：将序列化的字符串转成  length\r\nx_ op_ y_\r\n。Decode：将 length\r\nx_ op_ y_\r\n 转成 x_ op_ y_（即拿到正文）。

#pragma once
#include <iostream>
#include <string>
#include <cstdbool>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstdlib>
#include <cstring>

#define SPACE " "
#define SPACELEN strlen(SPACE)
#define SEP "\r\n"
#define SEPLEN strlen(SEP)

bool Recv(int sock, std::string *out)
{
    char buffer[1024];
    ssize_t s = recv(sock, buffer, sizeof buffer - 1, 0);
    if (s == 0)
    {
        std::cout << "客户端退出！" << std::endl;
        return false;
    }
    else if (s > 0)
    {
        buffer[s] = 0;
        *out += buffer;
    }
    else
    {
        std::cerr << "客户端退出！" << std::endl;
        return false;
    }

    return true;
}

void Send(int sock, const std::string &str)
{
    ssize_t s = send(sock, str.c_str(), str.size(), 0);
}

// len\r\nx op y\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 mainsize = buffer.size() - pos - 2 * SEPLEN; // 正文长度
    if (mainsize >= size)
    {
        buffer.erase(0, pos + SEPLEN);
        std::string result = buffer.substr(0, size);
        buffer.erase(0, size + SEPLEN);
        return result;
    }
    else
        return "";
}

std::string Encode(std::string &s)
{
    std::string ret = std::to_string(s.size());
    ret += SEP;
    ret += s;
    ret += SEP;
    return ret;
}

class Request
{
public:
    std::string Serialize()
    {
        std::string requeststr = std::to_string(x_);
        requeststr += SPACE;
        requeststr += op_;
        requeststr += SPACE;
        requeststr += std::to_string(y_);
        return requeststr;
    }

    // x_ op_ y_
    bool Deserialization(const std::string &str)
    {
        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 + SPACELEN).c_str());
        op_ = str[left + SPACELEN];
        return true;
    }

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

public:
    int x_;
    int y_;
    char op_;
};

class Response
{
public:
    // code_ result_
    std::string Serialize()
    {
        std::string str = std::to_string(code_);
        str += SPACE;
        str += std::to_string(result_);
        return str;
    }

    bool Deserialization(std::string &str)
    {
        std::size_t pos = str.find(SPACE);
        if (pos == std::string::npos)
            return false;
        code_ = atoi(str.substr(0, pos).c_str());
        result_ = atoi(str.substr(pos + SPACELEN).c_str());
        return true;
    }

public:
    Response(const int &result = 0, const int &code = 0) : result_(result), code_(code) {}
    ~Response() {}

public:
    int result_;
    int code_;
};

CalServer.cc：

#include "tcpserver.hpp"
#include "Protocol.hpp"
#include <signal.h>
#include <memory>

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

Response CalculatorHelper(const Request &req)
{
    Response res(0, 0);
    switch (req.op_)
    {
    case '+':
        res.result_ = req.x_ + req.y_;
        break;
    case '-':
        res.result_ = req.x_ - req.y_;
        break;
    case '*':
        res.result_ = req.x_ * req.y_;
        break;
    case '/':
        if (0 == req.y_)
            res.code_ = 1;
        else
            res.result_ = req.x_ / req.y_;
        break;
    case '%':
        if (0 == req.y_)
            res.code_ = 2;
        else
            res.result_ = req.x_ % req.y_;
        break;
    default:
        res.code_ = 3;
        break;
    }
    return res;
}

void Calculator(int sock)
{
    std::string str;
    while (true)
    {
        bool rest = Recv(sock, &str);
        if (!rest)
            break;
        std::string package = Decode(str);
        if (!package.empty())
        {
            Request req;
            req.Deserialization(package);
            Response res = CalculatorHelper(req);
            std::string sendstr = res.Serialize();
            sendstr = Encode(sendstr);
            Send(sock, sendstr);
        }
        else
            continue;
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    signal(SIGPIPE, SIG_IGN);
    uint16_t server_port = atoi(argv[1]);
    std::unique_ptr<TcpServer> sev(new TcpServer(server_port));
    sev->BindServer(Calculator);
    sev->Start();

    return 0;
}

 CalClient.cc：

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstdlib>
#include <unistd.h>
#include "Sock.hpp"
#include "Protocol.hpp"

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

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);
    Sock sock;
    int sockfd = sock.Socket();
    if (!sock.Connect(sockfd, ip, port))
    {
        std::cout << "连接出错！" << std::endl;
        exit(2);
    }
    std::cout << "连接成功！" << std::endl;

    bool quit = false;
    std::string buffer;

    while (!quit)
    {
        Request req;
        std::cout << "请输入x # ";
        std::cin >> req.x_;
        std::cout << "请输入y # ";
        std::cin >> req.y_;
        std::cout << "请输入op # ";
        std::cin >> req.op_;

        std::string sendstr = req.Serialize();
        sendstr = Encode(sendstr);
        Send(sockfd, sendstr);

        while (true)
        {
            bool ret = Recv(sockfd, &buffer);
            if (!ret)
            {
                quit = true;
                break;
            }
            std::string recstr = Decode(buffer);
            if (recstr.empty())
                continue;
            Response res;
            res.Deserialization(recstr);
            std::cout << "code_: " << res.code_ << std::endl;
            std::cout << "result_: " << res.result_ << std::endl;
            break;
        }
    }
    close(sockfd);

    return 0;
}

六、守护进程

后台进程：就是在后台运行，不占用用户终端的进程。

前台进程：前台进程是与用户直接交互的进程（和终端关联的进程）。可以直接获取键盘的输入。

如下：我们的bash就是一个最常见的前台进程，我们输入各种指令，他就能返回相应的结果。

而我们上面所写的服务器进程在启动后，也是在前台运行的，也是一个前台进程。如下：

从上图我们也看到：服务器进程在启动后，如果我们再输入各种指令的话，将不会有任何结果。因为xshell登录后，只允许有一个前台进程和多个后台进程。 

再如下：我们使用管道创建多个进程，

除了PID，PPID之外，PGID我们称为组ID，SID我们称为会话ID。

这三个被同时创建的进程组成了一个进程组，他们的PGID都是23440，也是第一个进程的PID。所以一个进程组的PGID是第一个进程的PID。

我们在登陆了xshell后，xshell会给用户提供一种会话机制，在会话中，包含了给用户提供服务的bash进程，终端，以及用户自己在该会话中启动的进程。当xshell退出登录，会话也会退出。

如下图：

而现在，我希望会话退出后，服务器进程任然也可以运行。那么我们就需要让服务器进程自成一个会话。这样服务器进程就成为了一个守护进程。守护进程也是一种后台进程。

我们使用 setsid()函数，就可以让某个进程变成自成会话。注：setsid要成功被调用，必须保证当前进程不是进程组的组长。

所以，我们自己写一个方法来让服务器进程变成一个守护进程。

一般步骤：

1、忽略信号：SIGPIPE，SIGCHLD

2、不要让自己是进程组的组长，fork()

3、调用setsid(）函数

4、因为守护进程不能向显示器打印消息，所以我们需要将标准输出、标准错误和标准输入进行重定向。这里我们需要使用Linux中的一个文件：/dev/null。其特点就是，任何向其中写入的内容都会被其丢弃。因为文件中没有内容，所以读取时什么也读取不到。

daemon.hpp：

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

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

    // 2.不要让自己成为组长
    if (fork() > 0)
        exit(0);

    // 3.调用setsid()
    setsid();

    int devnull = open("/dev/null", O_RDONLY | O_WRONLY);
    if (devnull > 0)
    {
        dup2(0, devnull);
        dup2(1, devnull);
        dup2(2, devnull);
        close(devnull);
    }
}

然后，我们只需要在服务器运行前调用这个函数即可。当然，服务器代码中任何向显示器打印的函数都不应该调用了。

CalServer.cc的main函数：

通过查询，发现 MyServer的父进程PPID为1，也就是操作系统。所以说，守护进程也是一种孤儿进程。 

七、Json序列化与反序列化

对于序列化和反序列化，上面我们自己的方案其实也很多问题，所以我们除了可以自定义方案以外，还可以使用别人的已经实现好了的方案。比如我们接下来讲到的：json。

使用前，我们需要安装json库： sudo yum install jsoncpp-devel

Protocol.hpp：

#include <jsoncpp/json/json.h>

class Request
{
public:
    std::string Serialize()
    {
        Json::Value root;
        root["x"] = x_;
        root["y"] = y_;
        root["op"] = op_;
        Json::FastWriter writer;
        return writer.write(root);
    }

    // x_ op_ y_
    bool Deserialization(const std::string &str)
    {
        Json::Value root;
        Json::Reader reader;
        reader.parse(str, root);
        x_ = root["x"].asInt();
        y_ = root["y"].asInt();
        op_ = root["op"].asInt();
        return true;
    }

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

public:
    int x_;
    int y_;
    char op_;
};

class Response
{
public:
    // code_ result_
    std::string Serialize()
    {
        Json::Value root;
        root["code"] = code_;
        root["result"] = result_;
        Json::FastWriter writer;
        return writer.write(root);
    }

    bool Deserialization(std::string &str)
    {
        Json::Value root;
        Json::Reader reader;
        reader.parse(str, root);
        code_ = root["code"].asInt();
        result_ = root["result"].asInt();
        return true;
    }

public:
    Response(const int &result = 0, const int &code = 0) : result_(result), code_(code) {}
    ~Response() {}

public:
    int result_;
    int code_;
};

八、netstat

netstat：我们可以通过netstat命令来查看当前网络的状态，这里我们可以选择携带nlup选项。

netstat常用选项：

-n：直接使用IP地址，而不通过域名服务器。
-l：显示监控中的服务器的Socket。
-t：显示TCP传输协议的连线状况。
-u：显示UDP传输协议的连线状况。
-p：显示正在使用Socket的程序识别码和程序名称。

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

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

相关文章

java多线程-练习

java多线程-练习

需求 代码 使用Callable 方便返回执行的结果&#xff1a;每个线程的发送礼物的数量礼物清单&#xff1a;共享资源&#xff0c;方便上锁礼物数量&#xff1a;线程变量&#xff0c;每个线程发送礼物的数量 public class SendGiftThread implements Callable<Integer> {// 共…
阅读更多...
通过命令行构建Django应用程序

通过命令行构建Django应用程序

假设读者安装好Django开发环境后&#xff08;这个环境搭建很容易&#xff0c;大家可以参看随意一个网文&#xff09;&#xff0c;就可以通过命令行构建Django应用程序了。通过命令行构建Django应用程序的关键&#xff0c;是使用一个Django框架自带的管理工具——django-admin.p…
阅读更多...
springboot3 集成knife4j

springboot3 集成knife4j

knife4j介绍 Knife4j是一个集Swagger2 和 OpenAPI3为一体的增强解决方案。 springdoc地址&#xff1a;OpenAPI 3 Library for spring-boot Knife4j官网地址&#xff1a;Knife4j 集Swagger2及OpenAPI3为一体的增强解决方案. | Knife4j 环境介绍 java&#xff1a;17 Spring…
阅读更多...
你们项目日志是如何处理的？？？

你们项目日志是如何处理的？？？

ELK日志采集系统 1.什么是ELK ELK 是一套流行的数据搜索、分析和可视化解决方案&#xff0c;由三个开源项目组成&#xff0c;每个项目的首字母合起来形成了“ELK”这一术语&#xff1a; Elasticsearch (ES): Elasticsearch 是一个基于 Apache Lucene 构建的分布式、实时搜索与…
阅读更多...
项目开发流程

项目开发流程

项目开发流程 &#x1f469;‍&#x1f9b3;项目立项 估计项目的花费&#xff0c;确定大致的所需开发人员数&#xff0c;确定项目是否可行&#xff1b; &#x1f469;‍&#x1f9b0;需求分析 整体过程&#xff1a; 项目背景和目标&#xff0c;即项目的目的是什么 用户需求&…
阅读更多...
动态Web项目讲解+Demo

动态Web项目讲解+Demo

web流程演示 请求路径 请求路径明确要请求的是哪个servlet 请求方式 servlet含有两种请求方式&#xff1a;doGet和doPost doGet&doPost 返回数据就是httpResponse&#xff0c;返回给success 参数 包含在request当中 成功 上述流程任何一步都没出问题&#xff0c;就会…
阅读更多...
设计模式之创建型模式---工厂模式

设计模式之创建型模式---工厂模式

文章目录 工厂模式概述简单工厂简单工厂的代码实现简单工厂的使用简单工厂应用场景 工厂方法工厂方法模式的代码实现工厂方法的使用工厂方法应用场景 抽象工厂抽象工厂模式代码实现抽象工厂的使用方法抽象工厂模式的应用场景 总结 工厂模式概述 工厂模式从名字就能看出&#x…
阅读更多...
在【laravel框架】学习中遇到的常见的问题以及解决方法

在【laravel框架】学习中遇到的常见的问题以及解决方法

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;开发者-曼亿点 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 曼亿点 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a…
阅读更多...
.net core webapi 高颜值的接口管理系统界面取代swagger，更好调试和查看

.net core webapi 高颜值的接口管理系统界面取代swagger，更好调试和查看

.net core webapi 高颜值的接口管理系统界面取代swagger&#xff0c;更好调试和查看 安装 dotnet add package IGeekFan.AspNetCore.Knife4jUI --version 0.0.16配置文档&#xff1a; 配置起始页 builder.Services.AddSwaggerGen(c > {// 配置 Swagger 文档相关信息c.Swa…
阅读更多...
开源项目实现简单实用的股票回测

开源项目实现简单实用的股票回测

1 引言 之前&#xff0c;尝试做股票工具一直想做的大而全&#xff0c;试图抓取长期的各个维度数据&#xff0c;然后统计或者训练模型。想把每个细节做到完美&#xff0c;结果却陷入了细节之中&#xff0c;最后烂尾了。 最近&#xff0c;听到大家分享了一些关于深度学习、时序…
阅读更多...
【面试题】MySQL 事务的四大特性说一下？

【面试题】MySQL 事务的四大特性说一下？

事务是一个或多个 SQL 语句组成的一个执行单元&#xff0c;这些 SQL 语句要么全部执行成功&#xff0c;要么全部不执行&#xff0c;不会出现部分执行的情况。事务是数据库管理系统执行过程中的一个逻辑单位&#xff0c;由一个有限的数据库操作序列构成。 事务的主要作用是保证数…
阅读更多...
Core dump(核心转储)

Core dump(核心转储)

文章目录 core dump core dump 进程退出时有三种情况正常退出&#xff0c;退出结果不对&#xff0c;异常退出 低7位表示收到信号退出&#xff0c;次低八位代表进程正常退出它的退出码&#xff01;在第八位有一个core dump标志位&#xff0c;这个标志位表示进程收到信号做的动…
阅读更多...
Leetcode 28. 找出字符串中第一个匹配项的下标

Leetcode 28. 找出字符串中第一个匹配项的下标

心路历程&#xff1a; 两个字符串匹配的问题基本都可以用动态规划解决&#xff0c;递推关系就是依次匹配下去 注意的点&#xff1a; 1、注意边界条件是匹配串needle到头&#xff0c;但是haystack不一定需要到头 2、这道题按照从i开始的字符串而不是从i结束的进行DP建模 解法…
阅读更多...
vue---计算属性

vue---计算属性

姓名案例 1.使用插值语法实现 <!DOCTYPE html> <html><head><meta charset"UTF-8" /><title>姓名案例_插值语法实现</title><!-- 引入Vue --><script type"text/javascript" src"../js/vue.js"&g…
阅读更多...
被这批B端界面的颜值给征服了，匍匐拜倒。。

被这批B端界面的颜值给征服了，匍匐拜倒。。

高颜值的 B 端界面对于企业来说具有非常重要的作用&#xff0c;可以帮助企业提升品牌形象、吸引客户、增加用户留存、提升竞争力、提高交易转化率&#xff0c;以及优化用户体验&#xff0c;从而为企业带来更多的商业机会和利益。本期分享一批&#xff0c;都是颜值杠杠的。
阅读更多...
制造业信息安全实践——企业信息安全运营规划

制造业信息安全实践——企业信息安全运营规划

前言 制造业作为一个庞大的传统产业&#xff0c;涵盖了汽车、船舶、飞机、家电、新能源等众多领域。当前&#xff0c;无论是国内还是国外的制造业都面临着一个共同的挑战&#xff1a;在计算机和信息时代的背景下&#xff0c;如何跟上IT技术的发展步伐&#xff1f;如何让传统产…
阅读更多...
网络协议安全：OSI七层模型分层及作用，数据封装与解封过程，数据传输过程。

网络协议安全：OSI七层模型分层及作用，数据封装与解封过程，数据传输过程。

「作者简介」&#xff1a;2022年北京冬奥会中国代表队&#xff0c;CSDN Top100&#xff0c;学习更多干货&#xff0c;请关注专栏《网络安全自学教程》 这一章节我们需要知道OSI分哪七层&#xff0c;每层的作用&#xff0c;知道数据在七层模型中是怎样传输的&#xff0c;封包和解…
阅读更多...
【离婚不再难】告别痛苦，用一纸起诉状重新启航

【离婚不再难】告别痛苦，用一纸起诉状重新启航

【离婚不再难】告别痛苦&#xff0c;用一纸起诉状重新启航 在这个瞬息万变的时代&#xff0c;婚姻关系的走向已不再是人们心中永恒的定局。当缘尽人散&#xff0c;面对离婚的纷扰&#xff0c;你是否感到迷茫与无助&#xff1f;别担心&#xff0c;李秘书讲写作公众号在这里&…
阅读更多...
C++11——线程库的理解与使用

C++11——线程库的理解与使用

目录 前言 一、线程库的构造 1.默认构造 2.带参构造 3.拷贝构造与赋值拷贝&#xff08;不支持&#xff09; 4.移动构造 二、线程调用lambda函数 三、线程安全与锁 1.lambda中的线程与锁 2.函数指针中的线程与锁 3.trylock() 4.recursive_mutex 5.lock_gurad守卫锁…
阅读更多...
​「Python大数据」VOC数据清洗

​「Python大数据」VOC数据清洗

前言 本文主要介绍通过python实现数据清洗、脚本开发、办公自动化。读取voc数据，存储新清洗后的voc数据数据。 一、业务逻辑 读取voc数据采集的数据批处理，使用jieba进行分词，去除停用词，清洗后的评论存储到新的列中保存清洗后的数据到新的Excel文件中二、具体产出 三、执…
阅读更多...
最新文章

Copyright @ 2022~2023