【网络】协议的定制与Json序列化和反序列化

文章目录

  • 应用层
  • 初识TCP协议通讯流程
  • 定制协议
    • 再谈协议
    • 网络版本计算器
      • Protocal.hpp
      • CalServer
      • CalClient
  • Json的安装

应用层

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

初识TCP协议通讯流程

  • 建立链接和断开链接

基于TCP协议,我们需要知道写代码时对应的接口大概在TCP通讯的过程中属于什么样的时间点角色,在TCP协议时详谈。三次握手,四次挥手

listen状态:准备好了,可以进行链接,accept:获取链接,不是创造链接,链接已经在底层创建好了,在应用层调用accept把链接拿上来

connect:1.发起链接请求2.绑定套接字;建立链接,在底层向服务端建立链接请求,在TCP中,采用链接的方案是三次握手的方案,connect会发起三次握手,发起链接请求和真正的建立链接是两码事,建立链接由双方OS自动完成的,为什么自动完成?网络分层中,下三层是OS内部的,用户感知不到。通过客户端调用connect让OS来帮我们把三次握手的工作做完。

而accept是获取链接,链接是已经建立好了的,所以accept并不参与三次握手的任何细节,accept一定是在获取链接前别人把链接做完,既链接建立完。三次握手是OS自己完成的,connect只是发起,accept只是收尾。即使上层不调用accept,三次握手也是能够建立好的。

TCP保证可靠性不是write和read有关系的,由双方OS完成的,后面详谈。

建立链接后面就要断开链接,所以UDP由于不需要建立链接,自然不需要谈论断开链接

而四次挥手的工作都是由双方的OS完成,而我们决定什么时候分手一旦调用系统调用close,用户层就不用管了。

  • 理解链接

谈男女朋友时,都会表达自己的爱意,一定有一方主动发起链接,无论如何表达,双方看对眼的概率是极低的。而主动发起链接,是怎么发起的呢?首先,男方先表白,然后女方在做表态,什么时候在一起?男方回答就现在。这就是双方三次握手成功。(虽然现实生活中被拒绝是常态)

建立链接究竟在干什么:记下一些东西

  • 什么是建立链接

所谓的建立链接,三次握手根本就是手段,不是目的,为了达到让双方都能记住这一套,一个服务端链接客户端,很多客户端来链接了,意味着很多的客户端来了,OS应该区分清楚,需要把链接管理起来,先描述在组织,需要创建对应的链接数据结构,把所有的链接描述起来,在对其进行管理。所谓的链接就是OS内部创建的链接结构体,包含了在建立链接时对应的属性信息。当有新的链接进来时,每到来一个链接,服务端会构建一个链接对象 ,将所有的链接对象在内部中用特定的数据结构管理起来。这就是链接的建模过程。维护链接是需要成本的。占用内存资源,要用对象进行管理。

断开链接需要四次挥手,断开链接的最终目的毫无疑问就是把建立好的链接信息释放。四次挥手理解:

男女朋友处的非常好,走到了婚姻的殿堂,但是被现实打败了,过不下去啦。然后一方提出离婚,但是你自己说了不算,另一方说好啊,过了一会,对象又说离就离,那我也要离,那么你一看,我也OK。所以断开链接是双方的事情,必须得征求双方的意见。双方在协商,TCP要保证可靠性,你说的话要保证你也听到了,我也知道了,反之也一样。这就是传说中的四次挥手

TCP与UDP对比

可靠传输VS不可靠传输

有连接VS无连接

字节流VS数据报

定制协议

应用层协议的定制

再谈协议

协议是一种约定,socket api的接口,在读写数据时,都是按照字符串的方式来接收的,如果要传输一些”结构化的数据“怎么办呢?

结构化的数据:群里说话的时候除了消息本身,还有头像,昵称时间等等信息 。但是不是一个一个独立的个体,你需要做的把这些消息形成一个报文——打包成一个字符串。

由多变一这个过程就是序列化。经过网络传输后,收到的是一个报文,收到一个报文要的是什么?把一个字符串变成多个字符串,这个过程是反序列化

业务数据发送到网络的时候,先序列化发送,收到的是序列字节流,要先进行反序列化, 然后才能使用

业务协议就是结构体,这样说还是不够的,所以我们要手写一个协议。

应用场景:形成字符串对方收到,收到之后上层来不及接收,对方又发一个,有可能一次全读的,上层如何保证收到的是一个报文?

tcp这里怎么保证收到一个完整的报文

理解业务协议,理解序列化和反序列化。

网络版本计算器

例如, 我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加减乘除数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端

TCP是面向字节流的,所以明确报文和报文的边界:

image-20230521235914835

TCP是全双工的,如果接收方来不及读,那接收缓冲区就会存在很多数据,读的时候怎么怎么保证读到一个完整的报文:

1.定长2.特殊符号3.自描述方式

序列化、反序列化与定制协议是两码事,是不同阶段的事情,定制协议:报头+有效载荷

Protocal.hpp

自定义协议:

#define SEP " "
#define SEP_LEN strlen(SEP)
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP)

请求和响应:Request,Response

Request:x,y,op(“x op y”)x和y是数据,op是操作符,比如1+2

Response:设置了退出码exitcode和结果result()

对请求和响应添加报头,这里设置的报头是长度,enLength(即添加大小,转化成字符串),也就是封装了enLength函数:

//"x op y"->"content_len"\r\n"x op y"\r\n
//"exitcode result"->"cotent_len"\r\n"exitcode result"\r\n
const std::string enLength(const std::string &text)
{
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;
    return send_string;
}

对请求和响应提取报文,只要报文,不要报头,也就是封装了deLength函数:

//"cotent_len"\r\n"exitcode result"\r\n
bool deLength(const std::string &package, std::string *text)
{
    auto pos = package.find(LINE_SEP);
    if (pos == std::string::npos)
        return false;
    std::string text_len_string = package.substr(0, pos);
    int text_len = std::stoi(text_len_string);
    *text = package.substr(pos + LINE_SEP_LEN, text_len);
    return true;
}

对请求和响应进行序列化和反序列化:对于序列化和反序列化我们可以用Json来进行实现

序列化过程:结构化数据->“x op y”

反序列化过程:“x op y”->结构化数据

Protocal.hpp还提供了recvPackage函数

#define SEP " "
#define SEP_LEN strlen(SEP)
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP)
enum
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};

//"x op y" --->"content_len"\r\n"x op y"\r\n,添加报头
std::string enLength(const std::string &text)
{
    std::string send_string = std::to_string(text.size());
    send_string += LINE_SEP;
    send_string += text;
    send_string += LINE_SEP;
    return send_string;
}

//"content_len"\r\n"exitcode result"\r\n
// 去掉报头,得到"exitcode result"
bool deLength(const std::string &package, std::string *text)
{
    auto pos = package.find(LINE_SEP);
    if (pos == std::string::npos)
        return false;
    std::string text_len_string = package.substr(0, pos); // content_len:如“14”
    int text_len = std::stoi(text_len_string);
    *text = package.substr(pos + LINE_SEP_LEN, text_len);
    return true;
}

class Request
{
public:
    Request() : x(0), y(0), op(0)
    {
    }

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

    // 序列化:
    // 结构化-> "x op y"
    bool serialize(std::string *out)
    {
#ifdef MYSELF
        *out = "";
        std::string x_string = std::to_string(x);
        std::string y_string = std::to_string(y);

        *out = x_string;
        *out += SEP;
        *out += op;
        *out += SEP;
        *out += y_string;
#else
        Json::Value root;
        root["first"] = x;
        root["second"] = y;
        root["oper"] = op;

    Json::FastWriter writer;
    *out = writer.write(root);
#endif
        return true;
    }

    // 反序列化化:
    //"x op y"->结构化
    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        auto left = in.find(SEP);
        auto right = in.rfind(SEP);
        if (left == std::string::npos || right == std::string::npos)
            return false;
        if (left == right)
            return false;
        if (right - (left + SEP_LEN) != 1)
            return false;
        std::string x_string = in.substr(0, left);
        std::string y_string = in.substr(right + SEP_LEN);

        if (x_string.empty())
            return false;
        if (y_string.empty())
            return false;
        x = std::stoi(x_string);
        y = std::stoi(y_string);
        op = in[left + SEP_LEN];
#else
        Json::Value root;
        Json::Reader reader;
        reader.parse(in, root);

        x = root["first"].asInt();
        y = root["second"].asInt();
        op = root["oper"].asInt();
#endif
        return true;
    }

public:
    int x;
    int y;
    char op;
};

class Response
{
public:
    Response() : exitcode(0), result(0)
    {
    }

    Response(int exitcode_, int result_) : exitcode(exitcode_), result(result_)
    {
    }

    bool serialize(std::string *out)
    {
#ifdef MYSELF
        *out = "";
        std::string ec_string = std::to_string(exitcode);
        std::string res_string = std::to_string(result);

        *out = ec_string;
        *out += SEP;
        *out += res_string;
#else
        Json::Value root;
        root["exitcode"] = exitcode;
        root["result"] = result;

        Json::FastWriter writer;
        *out = writer.write(root);
#endif
        return true;
    }

    bool deserialize(const std::string &in)
    {
#ifdef MYSELF
        auto mid = in.find(SEP);
        if (mid == std::string::npos)
            return false;
        std::string ec_string = in.substr(0, mid);
        std::string res_string = in.substr(mid + SEP_LEN);

        if (ec_string.empty() || res_string.empty())
            return false;
        exitcode = std::stoi(ec_string);
        result = std::stoi(res_string);
#else
        Json::Value root;
        Json::Reader reader;
        reader.parse(in, root);

        exitcode = root["exitcode"].asInt();
        result = root["result"].asInt();
#endif
        return true;
    }

public:
    int exitcode;
    int result;
};

// 读取报文,保证读取的是一个完整的报文 ,inbuffer由外部传入
// "content_len"\r\n"x op y"\r\n"content_len"\r\n"x op y"\r\n"content_len"\r\n"x op
bool recvPackage(int sock, std::string &inbuffer, std::string *text)
{
    char buffer[1024];
    while(true)
    {
        ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if(n>0)
        {
            buffer[n] = 0;
            inbuffer+=buffer;
            
            auto pos = inbuffer.find(LINE_SEP);
            if(pos == std::string::npos) continue;
            std::string text_len_string = inbuffer.substr(0,pos);
            int text_len  =std::stoi(text_len_string);
            int total_len = text_len_string.size()+2*LINE_SEP_LEN+text_len;

            std::cout<<"处理前#inbuffer:\n"<<inbuffer<<std::endl;
            if(inbuffer.size()< total_len)
            {
                std::cout<<"你输入的消息,没有遵守所定制的协议,正在等待后续的内容,continue"<<std::endl;
                continue;
            }

            //至少是一个完整的报文
            *text = inbuffer.substr(0,total_len);
            inbuffer.erase(0,total_len);

            std::cout<<"处理后#inbuffer:\n"<<inbuffer<<std::endl;
            break;
        }
        else
            return false;
    }
    return true;
}

对于recvPackage函数我们要保证读到的至少是一个完整的报文

CalServer

服务端代码

//CalServer.hpp
namespace server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5;
    typedef std::function<bool(const Request &req, Response &resp)> func_t;


    void handlerEntery(int sock,func_t func)
    {
        std::string inbuffer;
        while(true)
        {
            //1.读取:"content_len"\r\n"x op y"\r\n
            //保证读到的消息是一个完整的请求
            std::string req_text,req_str;
            if(!recvPackage(sock,inbuffer,&req_text)) return;
            std::cout<<"带报头的请求:\n"<<req_text<<std::endl;
            //去掉报头
            if(!deLength(req_text,&req_str)) return;
            std::cout<<"去掉报头的正文:\n"<<req_str<<std::endl;

            //2.对请求Request,反序列化
            //2.1得到一个结构化的请求对象
            Request req;
            if(!req.deserialize(req_str)) return;

            //3.计算机处理————业务逻辑
            Response resp;
            func(req,resp);

            //4.对响应Response,进行序列化
            //4.1得到一个"字符串"
            std::string resp_str;
            resp.serialize(&resp_str);

            std::cout<<"计算完成,序列化响应:"<<resp_str<<std::endl;

            //5.发送响应
            std::string send_string = enLength(resp_str);
            std::cout<<"构建完成完整的响应\n"<<send_string<<std::endl;
            send(sock,send_string.c_str(),send_string.size(),0);


        }
    }
    class CalServer
    {
    public:
        CalServer(const uint16_t&port = gport):_listensock(-1),_port(port)
        {}

        void initServer()
        {
            _listensock = socket(AF_INET,SOCK_STREAM,0);
            if(_listensock<0)
            {
                logMessage(FATAL,"create socket error");
                exit(SOCKET_ERR);
            }

            logMessage(NORMAL,"create socket success:%d",_listensock);

            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);
            local.sin_addr.s_addr = INADDR_ANY;
            if(bind(_listensock,(struct sockaddr*)&local,sizeof(local))<0)
            {
                logMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL,"bind socket success");

            if(listen(_listensock,gbacklog)<0)
            {
                logMessage(FATAL,"listen socker error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL,"listen socket success");
        }

        void start(func_t func)
        {
            for(;;)
            {
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int sock = accept(_listensock,(struct sockaddr*)&peer,&len);
                if(sock<0)
                {
                    logMessage(ERROR,"accept error,next");
                    continue;
                }
                logMessage(NORMAL,"accept a new link success,get new sock:%d",sock);

                pid_t id = fork();
                if(id == 0)
                {
                    close(_listensock);
                    handlerEntery(sock,func);
                    close(sock);
                    exit(0);
                }
                close(sock);

                pid_t ret = waitpid(id,nullptr,0);
                if(ret>0)
                {
                    logMessage(NORMAL,"wait child success");

                }
            }
        }
         ~CalServer() {}
    public:
        int _listensock;
        uint16_t _port;
    };
}

//CalServer.cc
#include "calServer.hpp"
#include <memory>
using namespace server;
using namespace std;
static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}

// req是处理好的完整的请求对象
// resp:根据req进行业务处理,填充resp,不需要管理任何IO,序列化和反序列化
bool cal(const Request &req, Response &resp)
{
    // req已经有结构化的数据
    resp.exitcode = OK;
    resp.result = 0;
    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(req.y==0) resp.exitcode = DIV_ZERO;
        else resp.result = req.x/req.y;
    }
    break;
    case '%':
    {
        if(req.y == 0)
            resp.exitcode = MOD_ZERO;
        else resp.result = req.x%req.y;
    }
    break;
    default:
        resp.exitcode = OP_ERROR;
        break;
    }
    return true;
}

// tcp服务器,启动上和udp server一模一样
// ./tcpserver local_port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }

    uint16_t port = atoi(argv[1]);
    unique_ptr<CalServer> tsvr(new CalServer(port));
    tsvr->initServer();
    tsvr->start(cal);
    return 0;
}

CalClient

ParseLine:解析,构建一个请求:“1+1”

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "Protocol.hpp"
#define NUM 1024

class CalClient
{
public:
    CalClient(const std::string &serverip, const uint16_t &serverport)
        : _sock(-1), _serverip(serverip), _serverport(serverport)
    {
    }
    void initClient()
    {
        // 1. 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            std::cerr << "socket create error" << std::endl;
            exit(2);
        }
    }
    void start()
    {
        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 << "socket connect error" << std::endl;
        }
        else
        {
            std::string line;
            std::string inbuffer;
            while (true)
            {
                std::cout << "mycal>>> ";
                std::getline(std::cin, line);  // 1+1
                Request req = ParseLine(line); // "1+1"
                std::string content;
                req.serialize(&content);
                std::string send_string = enLength(content);
                send(_sock, send_string.c_str(), send_string.size(), 0); // bug?? 不管

                std::string package, text;
                //  "content_len"\r\n"exitcode result"\r\n
                if (!recvPackage(_sock, inbuffer, &package))
                    continue;
                if (!deLength(package, &text))
                    continue;
                // "exitcode result"
                Response resp;
                resp.deserialize(text);
                std::cout << "exitCode: " << resp.exitcode << std::endl;
                std::cout << "result: " << resp.result << std::endl;
            }
        }
    }
    Request ParseLine(const std::string &line)
    {
        // 建议版本的状态机!
        //"1+1" "123*456" "12/0"
        int status = 0; // 0:操作符之前,1:碰到了操作符 2:操作符之后
        int i = 0;
        int cnt = line.size();
        std::string left, right;
        char op;
        while (i < cnt)
        {
            switch (status)
            {
            case 0:
            {
                if(!isdigit(line[i]))
                {
                    op = line[i];
                    status = 1;
                }
                else left.push_back(line[i++]);
            }
            break;
            case 1:
                i++;
                status = 2;
                break;
            case 2:
                right.push_back(line[i++]);
                break;
            }
        }
        std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
        return Request(std::stoi(left), std::stoi(right), op);
    }
    ~CalClient()
    {
        if (_sock >= 0)
            close(_sock);
    }

private:
    int _sock;
    std::string _serverip;
    uint16_t _serverport;
};

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

using namespace std;
static void Usage(string proc)
{
    cout<<"\nUasge:\n\t"<<proc<<" serverip serverport\n\n";
}
int main(int argc,char*argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    unique_ptr<CalClient> tcli(new CalClient(serverip,serverport));
    tcli->initClient();
    tcli->start();
    return 0;
}

Json的安装

sudo yum install -y jsoncpp-devel

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

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

相关文章

nginx相关

1、nginx无默认配置文件 参考文章&#xff1a;nginx配置失败&#xff0c;卸载后重装无 nginx.conf文件_haojuntu的博客-CSDN博客 2、nginx更改服务器的端口号 参考文章&#xff1a;https://www.cnblogs.com/chaosfe/p/16123585.html#:~:text%E6%88%91%E4%BB%AC%E6%9F%A5%E7%…

Java----使用eureka进行注册连接(微服务简单实现)

当采用微服务架构时&#xff0c;各个业务流程被逐一分解&#xff0c;虽说是分解&#xff0c;但还是要进行连接的&#xff0c;最简单的就是使用http请求&#xff0c;将他们联系起来&#xff0c;通过给容器注入restTemplate&#xff0c;然后使用内置的方法进行请求&#xff0c;但…

Java虚拟机(JVM)介绍

JVM是什么 JVM是Java Virtual Machine的缩写。它是一种基于计算设备的规范&#xff0c;是一台虚拟机&#xff0c;即虚构的计算机。 JVM屏蔽了具体操作系统平台的信息&#xff08;显然&#xff0c;就像是我们在电脑上开了个虚拟机一样&#xff09;&#xff0c;当然&#xff0c;J…

支付宝接入

支付宝接入 python-alipay-sdk pycryptodome一、电脑网站支付 1.1 获取支付宝密钥 沙箱网址 1.APPID 2.应用私钥 3.支付宝公钥1.2 存放密钥 在与 settings.py 的同级目录下创建 pem 文件夹pem 文件夹下创建 app_private_key.pem 和 alipay_public_key.pem app_private_key…

pdf文档加水印怎么弄?用这款软件很方便

在工作中&#xff0c;我们经常需要将PDF文件发送给他人&#xff0c;但无法保证文件内容不被窃取&#xff0c;因此需要添加水印来保证文件的安全性。如果你不知道如何给PDF文件添加水印&#xff0c;以下两款软件可以帮助你轻松实现&#xff0c;一起来看看吧&#xff01; 方法一&…

爬虫之Scrapy

一 介绍 Scrapy一个开源和协作的框架&#xff0c;其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的&#xff0c;使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。但目前Scrapy的用途十分广泛&#xff0c;可用于如数据挖掘、监测和自动化测试等领域&#x…

Python实现Excel文件拷贝图片到另一个的Excel文件(保持原有图片比例)

Python实现Excel文件拷贝图片到另一个的Excel文件&#xff08;保持原有图片比例&#xff09; 1、前言1.1 成功拷贝但是比例错误1.2 直接报错 2、解决办法3、号外 1、前言 今天朋友给我一个需求&#xff0c;需要把xlsx文件中的图片拷贝到另一个xlsx中&#xff0c;但是试过网上比…

[Lesson 01] TiDB数据库架构概述

目录 一 章节目标 二 TiDB 体系结构 1 TiDB Server 2.1 TiKV 2.2 TiFlash 3 PD 参考 一 章节目标 理解TiDB数据库整体架构了解TiDB Server TiKV tiFlash 和 PD的主要功能 二 TiDB 体系结构 了解这些体系结构是如何实现TiDB的核心功能的 1 TiDB Server TiDB Serve…

若依官方前端手册 小笔记

提供确认窗体信息 this.$modal.confirm(确认信息).then(function() {... }).then(() > {... }).catch(() > {}); 提供遮罩层信息 // 打开遮罩层 this.$modal.loading("正在导出数据&#xff0c;请稍后...");// 关闭遮罩层 this.$modal.closeLoading(); 验证…

pythonocc进阶学习:faces的inner wire与outer wire

总目录 >> PythonOCC入门进阶到实战(目前已更新入门篇、基础篇和进阶篇) 我们在这篇文章中绘制了带有holes的面&#xff0c; 本篇是在读取到外部文件如brep&#xff0c;igs&#xff0c;stp后获取面的性质&#xff0c;寻找面中的wires的正向与逆向 只显示外wire from O…

【LeetCode热题100】打卡第37天:岛屿数量反转链表

文章目录 【LeetCode热题100】打卡第37天&#xff1a;岛屿数量&反转链表⛅前言 岛屿数量&#x1f512;题目&#x1f511;题解 反转链表&#x1f512;题目&#x1f511;题解 【LeetCode热题100】打卡第37天&#xff1a;岛屿数量&反转链表 ⛅前言 大家好&#xff0c;我是…

【Spring core学习二】创建Spring 项目 Spring的存

目录 &#x1f31f;一、创建最原始的Spring-core项目。 &#x1f31f;二、怎么往Spring中存取对象&#xff1f; &#x1f337;1、在Spring中存对象 &#x1f337;2、通过getBean获取对象的三种方式 &#x1f337;3、通过factory方式获取对象 &#x1f31f;三、对存对象的…

用github的copilot;tmux中进去了> 怎么退出

1、首先要学籍认证 &#xff08;前提&#xff1a;(241条消息) Copilot使用的关卡——GitHub教育认证方法和注意事项_github教师认证_石去皿的博客-CSDN博客&#xff09; 网址&#xff1a;Are you a student? - GitHub Education (241条消息) GitHub学生认证&#xff0c;可…

微信小程序开发学习之页面导航(声明式导航和编程式导航)

微信小程序之页面导航&#xff08;声明式导航和编程式导航&#xff09; 1.0 页面导航1.1. 声明式导航1.1.1. 导航到tabBar页面1.1.2. 导航到非tabBar页面1.1.3. 后退导航 1.2. 编程式导航1.2.1. 导航到tabBar页面1.2.2. 导航到非tabBar页面1.2.3. 后退导航 1.3. 导航传参1.3.1.…

开发工具篇第25讲:阿里云MFA绑定Chrome浏览器Authenticator插件

开发工具篇第25讲&#xff1a;阿里云MFA绑定Chrome浏览器Authenticator插件 本文是开发工具篇第25讲&#xff0c;登录阿里云旗下产品时&#xff0c;需要使用mfa登录&#xff0c;每次如果要用手机看mfa码很麻烦&#xff0c; Chrome浏览器提供了一个快捷的登录方法&#xff0c;可…

Mac上提取应用APP的LOGO

1、找到想提取LOGO的应用&#xff0c;右键「显示包内容」 2、 双击【Contents】文件夹&#xff0c;再双击【Resources】文件夹 3、双击图标打开&#xff0c;选择最清晰的一帧&#xff0c;右键【导出为】 4、选择保存位置&#xff0c;格式注意选择常见格式&#xff0c;如png

通过git管理远程gitee仓库(push、pull)

通过git管理远程gitee仓库&#xff08;push、pull&#xff09; Git:是一种分布式版本控制系统&#xff0c;用于跟踪和管理软件开发项目的源代码和文件。它可以记录文件的修改历史&#xff0c;允许多人协同工作&#xff0c;并提供了撤销更改、分支管理、合并代码等功能。 Git最初…

一、对象的概念(2)

本章概要 复用继承 “是一个”与“像是一个”的关系 多态 复用 一个类经创建和测试后&#xff0c;理应是可复用的。然而很多时候&#xff0c;由于程序员没有足够的编程经验和远见&#xff0c;我们的代码复用性并不强。 代码和设计方案的复用性是面向对象程序设计的优点之一…

Spring Boot 中的 @Query 注解是什么,原理,如何使用

Spring Boot 中的 Query 注解是什么&#xff0c;原理&#xff0c;如何使用 在 Spring Boot 中&#xff0c;Query 注解是一个非常常用的注解&#xff0c;用于定义自定义查询语句。本文将介绍 Query 注解的作用、原理和使用方法。 1. Query 注解的作用 在 Spring Boot 中&#…

Linux——进程信号的发送

目录 一.信号发送的概念 首先来讲几个发送术语&#xff1a; 它有三种情况&#xff1a; 注意&#xff1a; 二.信号在内核中的表示示意图 三.信号捕捉 所以总结一下&#xff1a; 此时&#xff0c;会出现这样一个疑问&#xff1a;操作系统是如何得知现在被执行的进程是用户态…