18.windows使用select突破64個socket

原創 邶風 2021-02-01 13:51

windows默認FD_SETSIZE大小爲64，Linux的select默認只支持1024個句柄

在引入#include <WinSock2.h>之前，定義：

#define FD_SETSIZE      1024

就能實現突破64個socket，使用1024是爲了要實現代碼可以跨平臺。

客戶端---------------：100個tcp的client去連接服務端

DataHeader.hpp

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_


enum CMD
{
    CMD_LOGIN,
    CMD_LOGIN_RET,
    CMD_LOGOUT,
    CMD_LOGOUT_RET,
    CMD_NEW_USER_JOIN,
    CMD_ERROR
};

struct DataHeader
{
    DataHeader()
    {
        dataLength = sizeof(DataHeader);
        cmd = CMD_ERROR;
    }
    short dataLength;
    short cmd;
};

struct Login :public DataHeader
{
    Login()
    {
        dataLength = sizeof(Login);
        cmd = CMD_LOGIN;
    }
    char userName[32];
    char passWord[32];
    char data[932];
};

struct LoginResult :public DataHeader
{
    LoginResult()
    {
        dataLength = sizeof(LoginResult);
        cmd = CMD_LOGIN_RET;
        ret = 1;
    }
    int ret;
    char data[992];
};

struct LogOut :public DataHeader
{
    LogOut()
    {
        dataLength = sizeof(LogOut);
        cmd = CMD_LOGOUT;
    }
    char userName[32];
};

struct LogOutResult :public DataHeader
{
    LogOutResult()
    {
        dataLength = sizeof(LogOutResult);
        cmd = CMD_LOGOUT_RET;
        ret = 1;
    }
    int ret;

};

struct NewUserJoin :public DataHeader
{
    NewUserJoin()
    {
        dataLength = sizeof(NewUserJoin);
        cmd = CMD_NEW_USER_JOIN;
        sock = -1;
    }
    int sock;
};

#endif

 

 

EasyTcpClient.hpp

#ifndef _EasyTcpClient_hpp_
#define _EasyTcpClient_hpp_

#ifdef _WIN32
    #include <windows.h>
    #include <WinSock2.h>
#else
    #include<unistd.h>
    #include<arpa/inet.h>
    #include<string.h>
    #define SOCKET int
    #define INVALID_SOCKET (SOCKET)(~0)
    #define SOCKET_ERROR (-1)
#endif

#include <stdio.h>
#include "DataHeader.hpp"

#define RECV_BUFF_SIZE 10240

class  EasyTcpClient
{
public:
    EasyTcpClient()
    {
        _sock = INVALID_SOCKET;
    }
    //虛析構函數
    virtual ~EasyTcpClient()
    {
        Close();
    }

    //初始化socket
    void InitSocket()
    {
#ifdef _WIN32
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
#endif // _WIN32

        if (_sock != INVALID_SOCKET)
        {
            Close();
        }

        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (INVALID_SOCKET == _sock)
        {
            printf("錯誤，建立Socket失敗...\n");
        }
        else
        {
            printf("建立Socket成功...\n");
        }

    }

    int Connect(const char* ip, unsigned short port)
    {
        if (INVALID_SOCKET == _sock)
        {
            InitSocket();
        }

        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(port);
#ifdef _WIN32
        _sin.sin_addr.S_un.S_addr = inet_addr(ip);
#else
        _sin.sin_addr.s_addr = inet_addr(ip);
#endif

        int ret = connect(_sock, (const sockaddr*)&_sin, sizeof(sockaddr_in));
        if (SOCKET_ERROR == ret)
        {
            printf("錯誤，連接服務端失敗...\n");
        }
        else
        {
            printf("連接服務端成功...\n");
        }

        return ret;
    }

    bool isRun()
    {
        return (_sock != INVALID_SOCKET);
    }

    bool onRun()
    {
        if (isRun())
        {
            fd_set fdRead;
            FD_ZERO(&fdRead);
            FD_SET(_sock, &fdRead);

            timeval t = { 1, 0 };
            int ret = select(_sock + 1, &fdRead, 0, 0, &t);
            if (ret < 0)
            {
                Close();
                printf("select任務結束1。\n");
                return false;
            }

            if (FD_ISSET(_sock, &fdRead))
            {
                if (-1 == RecvData())
                {
                    Close();
                    printf("select任務結束2。\n");
                    return false;
                }
            }

        }
        return false;
    }

    //接收數據 處理粘包 拆分包
    int RecvData()
    {
        int nLen = recv(_sock, _szRecv, RECV_BUFF_SIZE, 0);
        //printf("nLen=%d\n", nLen);
        if (nLen <= 0)
        {
            printf("服務端%d已退出。\n", _sock);
            return -1;
        }

        //將收到的數據拷貝到消息緩衝區
        memcpy(_szMsgBuf + _lastPos, _szRecv, nLen);
        //消息緩衝區的數據尾部位置後移
        _lastPos += nLen;

        //判斷消息緩衝區的數據長度大於消息頭DataHeader長度
        while (_lastPos >= sizeof(DataHeader))
        {
            //這時就可以知道當前消息的長度
            DataHeader* header = (DataHeader*)_szMsgBuf;
            //判斷是否可以獲取一個完整消息
            if (_lastPos >= header->dataLength)
            {
                //剩餘的未處理消息緩衝區數據的長度
                int nSize = _lastPos - header->dataLength;
                //處理網絡消息
                onNetMsg(header);
                //將消息緩衝區剩餘未處理數據前移
                memcpy(_szMsgBuf, _szMsgBuf + header->dataLength, nSize);
                //將消息緩衝區的數據尾部位置前移
                _lastPos = nSize;
            }
            else
            {
                //消息緩衝區剩餘數據不夠一條完整消息
                break;
            }
        }

        return 0;
    }

    void onNetMsg(DataHeader* pData)
    {
        switch (pData->cmd)
        {
        case CMD_LOGIN_RET:
        {
            LoginResult *pLogin = (LoginResult*)pData;
            //printf("login result:%d\n", pLogin->ret);
        }
        break;
        case CMD_LOGOUT_RET:
        {
            LogOutResult *pLogOut = (LogOutResult*)pData;
            printf("log out result:%d\n", pLogOut->ret);
        }
        break;
        case CMD_NEW_USER_JOIN:
        {
            NewUserJoin *pMsg = (NewUserJoin*)pData;
            printf("new user:%d join.\n", pMsg->sock);
        }
        break;
        case CMD_ERROR:
        {
            printf("收到服務端消息:CMD_ERROR，數據長度:%d\n", pData->dataLength);
        }
        break;
        default:
        {
            printf("收到未定義消息，數據長度:%d\n", pData->dataLength);
        }
        }
    }

    //發送數據
    int SendData(DataHeader* pHeader)
    {
        if (isRun() && pHeader)
        {
            return send(_sock, (const char*)pHeader, pHeader->dataLength, 0);
        }
        return SOCKET_ERROR;
    }

    void Close()
    {
        if (_sock != INVALID_SOCKET)
        {
#ifdef _WIN32
            closesocket(_sock);
            //清除Windows socket環境
            WSACleanup();
#else
            close(_sock);
#endif
            _sock = INVALID_SOCKET;
        }
    }

private:
    SOCKET _sock;

    //接收緩衝區
    char _szRecv[RECV_BUFF_SIZE] = {};

    //第二緩衝區 消息緩衝區
    char _szMsgBuf[RECV_BUFF_SIZE * 10] = {};

    //消息緩衝區的數據尾部位置
    int _lastPos = 0;

};


#endif

 

 

main.cpp

#ifdef  _WIN32
    #define WIN32_LEAN_AND_MEAN
    #define _WINSOCK_DEPRECATED_NO_WARNINGS //也可以放到工程屬性，預處理中
    #define _CRT_SECURE_NO_WARNINGS
    #pragma comment(lib, "ws2_32.lib")
#endif 

#include <stdio.h>
#include <thread>
#include "EasyTcpClient.hpp"

bool g_bRun = true;
void cmdThread()
{
    while (true)
    {
        //3輸入請求命令
        char cmdBuf[128] = {};
        scanf("%s", cmdBuf);
        getchar();
        //4處理請求
        if (0 == strcmp(cmdBuf, "exit"))
        {
            printf("退出cmdThread線程\n");
            return;
        }
        else
        {
            printf("wrong cmd, please input cmd again.\n");
        }
    }
}

int main()
{
    const int count = 100;
    EasyTcpClient* client[count];
    for (int n=0;n<count;n++)
    {
        client[n] = new EasyTcpClient();
        client[n]->Connect("192.168.10.157", 4567);
    }

    std::thread t(cmdThread);
    t.detach();

    Login login = {};
    strcpy(login.userName, "jj");
    strcpy(login.passWord, "ww");

    while (g_bRun)
    {
        for (int n = 0; n < count; n++)
        {
            client[n]->SendData(&login);
            client[n]->onRun();
        }

    }

    for (int n = 0; n < count; n++)
    {
        client[n]->Close();
    }

    for (int n = 0; n < count; n++)
    {
        delete client[n];
        client[n] = nullptr;
    }

    printf("已退出");
    getchar();
    return 0;
}

 

 

服務端-----------：

DataHeader.hpp

同客戶端

 

EasyTcpServer.hpp

#ifndef _EasyTcpServer_hpp_
#define _EasyTcpServer_hpp_

#ifdef _WIN32
    #define FD_SETSIZE      1024
    #define WIN32_LEAN_AND_MEAN
    #define _WINSOCK_DEPRECATED_NO_WARNINGS //也可以放到工程屬性，預處理中
    #define _CRT_SECURE_NO_WARNINGS
    #include <windows.h>
    #include <WinSock2.h>
    #pragma comment(lib, "ws2_32.lib")
#else
    #include<unistd.h>
    #include<arpa/inet.h>
    #include<string.h>
    #define SOCKET int
    #define INVALID_SOCKET (SOCKET)(~0)
    #define SOCKET_ERROR (-1)
#endif

#include <stdio.h>
#include <vector>
#include "DataHeader.hpp"

#define RECV_BUFF_SIZE 1024

class ClientSocket
{
public:
    ClientSocket(SOCKET sockfd = INVALID_SOCKET)
    {
        _sockfd = sockfd;
        //memset(_szMsgBuf, 0, sizeof(_szMsgBuf));
    }

    SOCKET sockfd()
    {
        return _sockfd;
    }

    char* msgBuf()
    {
        return _szMsgBuf;
    }

    int getlastPos()
    {
        return _lastPos;
    }

    void setlastPos(int pos)
    {
        _lastPos = pos;
    }

private:
    SOCKET _sockfd = INVALID_SOCKET;
    char _szMsgBuf[RECV_BUFF_SIZE * 10] = {};
    int _lastPos = 0;
};

class EasyTcpServer
{
public:
    EasyTcpServer()
    {
        _sock = INVALID_SOCKET;
    }

    virtual ~EasyTcpServer()
    {
        Close();
    }

    //初始化socket
    SOCKET InitSocket()
    {
#ifdef _WIN32
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
#endif // _WIN32

        if (_sock != INVALID_SOCKET)
        {
            Close();
        }

        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (INVALID_SOCKET == _sock)
        {
            printf("錯誤，建立Socket失敗...\n");
        }
        else
        {
            printf("建立Socket成功...\n");
        }

        return _sock;
    }

    //綁定端口號
    int Bind(const char* ip, unsigned short port)
    {
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(4567);//host to net unsigned short

                                    //使用127.0.0.1可以防止外網訪問
                                    //啓用本機全部的ip地址可以使用，INADDR_ANY

#ifdef _WIN32
        if (ip)
        {
            _sin.sin_addr.S_un.S_addr = inet_addr(ip);
        }
        else
        {
            _sin.sin_addr.S_un.S_addr = INADDR_ANY;
        }

#else
        if (ip)
        {
            _sin.sin_addr.s_addr = inet_addr(ip);
        }
        else
        {
            _sin.sin_addr.s_addr = INADDR_ANY;
        }

#endif

        int ret = bind(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
        if (SOCKET_ERROR == ret)
        {
            printf("錯誤，綁定網絡端口失敗...\n");
        }
        else
        {
            printf("綁定網絡端口成功...\n");
        }

        return ret;
    }

    //監聽端口號
    int Listen(int cnt)
    {
        int ret = listen(_sock, cnt);
        if (SOCKET_ERROR == ret)
        {
            printf("錯誤，監聽網絡端口失敗...\n");
        }
        else
        {
            printf("監聽網絡端口成功...\n");
        }

        return ret;
    }

    //接收客戶端連接
    int Accept()
    {
        sockaddr_in clientAddr = {};
        int nAddrLen = sizeof(clientAddr);
        SOCKET _cSock = INVALID_SOCKET;
#ifdef _WIN32
        _cSock = accept(_sock, (sockaddr*)&clientAddr, &nAddrLen);
#else
        _cSock = accept(_sock, (sockaddr*)&clientAddr, (socklen_t*)&nAddrLen);
#endif
        if (INVALID_SOCKET == _cSock)
        {
            printf("錯誤，接受到無效客戶端socket...\n");
        }
        else
        {

            //NewUserJoin msg;
            //msg.sock = _cSock;
            //Send2All(&msg);

            _clients.push_back(new ClientSocket(_cSock));
            printf("新客戶端加入:socket=%d,IP=%s,count=%d\n", _cSock, inet_ntoa(clientAddr.sin_addr), _clients.size());
        }

        return _cSock;
    }

    //關閉socket
    void Close()
    {
        if (_sock != INVALID_SOCKET)
        {
#ifdef _WIN32
            // 關閉套接字
            for (size_t n = 0; n<_clients.size(); n++)
            {
                closesocket(_clients[n]->sockfd());
                delete _clients[n];
            }
            closesocket(_sock);
            //清除Windows socket環境
            WSACleanup();
#else
            for (size_t n = 0; n<_clients.size(); n++)
            {
                close(_clients[n]->sockfd());
                delete _clients[n];
            }
            close(_sock);
#endif

            _clients.clear();

        }

    }

    //處理網絡消息
    bool OnRun()
    {
        if (!isRun())
        {
            return false;
        }

        fd_set fdRead;
        fd_set fdWrite;
        fd_set fdExp;

        FD_ZERO(&fdRead);
        FD_ZERO(&fdWrite);
        FD_ZERO(&fdExp);

        FD_SET(_sock, &fdRead);
        FD_SET(_sock, &fdWrite);
        FD_SET(_sock, &fdExp);

        SOCKET maxSock = _sock;
        for (size_t n = 0; n<_clients.size(); n++)
        {
            FD_SET(_clients[n]->sockfd(), &fdRead);
            if (maxSock < _clients[n]->sockfd())
            {
                maxSock = _clients[n]->sockfd();
            }
        }

        timeval t = { 1,0 };
        int ret = select(maxSock + 1, &fdRead, &fdWrite, &fdExp, &t);
        if (ret < 0)
        {
            printf("select任務結束。\n");
            Close();
            return false;
        }


        if (FD_ISSET(_sock, &fdRead))
        {
            FD_CLR(_sock, &fdRead);//從集合移除了_sock

            Accept();
        }


        for (int n = (int)_clients.size() - 1; n >= 0; n--)
        {
            if (FD_ISSET(_clients[n]->sockfd(), &fdRead))
            {
                if (-1 == RecvData(_clients[n]))
                {
                    auto iter = _clients.begin() + n;
                    if (iter != _clients.end())
                    {
                        delete _clients[n];
                        _clients.erase(iter);
                    }
                }
            }
        }

        return true;
    }

    //是否工作中
    bool isRun()
    {
        return _sock != INVALID_SOCKET;
    }


    //接收數據 處理粘包 拆分包
    int RecvData(ClientSocket* pClient)
    {

        // 接收客戶端數據
        int nLen = (int)recv(pClient->sockfd(), _szRecv, RECV_BUFF_SIZE, 0);
        //printf("nLen=%d\n", nLen);
        if (nLen <= 0)
        {
            printf("客戶端%d已退出。\n", pClient->sockfd());
            return -1;
        }

        memcpy(pClient->msgBuf() + pClient->getlastPos(), _szRecv, nLen);
        //消息緩衝區的數據尾部位置後移
        pClient->setlastPos(pClient->getlastPos() + nLen);


        //判斷消息緩衝區的數據長度大於消息頭DataHeader長度
        while (pClient->getlastPos() >= sizeof(DataHeader))
        {
            //這時就可以知道當前消息的長度
            DataHeader* header = (DataHeader*)pClient->msgBuf();
            //判斷是否可以獲取一個完整消息
            if (pClient->getlastPos() >= header->dataLength)
            {
                //剩餘的未處理消息緩衝區數據的長度
                int nSize = pClient->getlastPos() - header->dataLength;
                //處理網絡消息
                onNetMsg(pClient->sockfd(), header);
                //將消息緩衝區剩餘未處理數據前移
                memcpy(pClient->msgBuf(), pClient->msgBuf() + header->dataLength, nSize);
                //將消息緩衝區的數據尾部位置前移
                pClient->setlastPos(nSize);
            }
            else
            {
                //消息緩衝區剩餘數據不夠一條完整消息
                break;
            }
        }

        return 0;
    }

    //響應網絡消息
    virtual void onNetMsg(SOCKET _cSock, DataHeader* header)
    {
        switch (header->cmd)
        {
        case CMD_LOGIN:
        {
            Login *pLogin = (Login*)header;
            //printf("客戶端%d,cmd logint,user:%s,password:%s\n", _cSock, pLogin->userName, pLogin->passWord);
            //----------------------------
            //----------------------------
            LoginResult longinRet = {};
            Send(_cSock, &longinRet);
        }
        break;
        case CMD_LOGOUT:
        {

            LogOut *pLogOut = (LogOut*)header;
            printf("客戶端%d,cmd logout,user:%s\n", _cSock, pLogOut->userName);
            //----------------------------
            LogOutResult logOutRet = {};
            Send(_cSock, &logOutRet);
        }
        break;
        default:
        {
            DataHeader header = {};
            header.cmd = CMD_ERROR;
            Send(_cSock, &header);
        }
        break;
        }
    }

    //指定socket發送數據
    int Send(SOCKET _cSock, DataHeader* header)
    {
        if (isRun() && header)
        {
            return send(_cSock, (const char*)header, header->dataLength, 0);
        }
        return SOCKET_ERROR;
    }

    void Send2All(DataHeader* header)
    {
        if (isRun() && header)
        {
            for (int n = (int)_clients.size() - 1; n >= 0; n--)
            {
                Send(_clients[n]->sockfd(), header);
            }
        }

    }


private:
    SOCKET _sock;
    std::vector<ClientSocket*> _clients;
    char _szRecv[RECV_BUFF_SIZE] = {};

};

#endif

 

 

main.cpp

#ifdef  _WIN32
    #define WIN32_LEAN_AND_MEAN
    #define _WINSOCK_DEPRECATED_NO_WARNINGS //也可以放到工程屬性，預處理中
    #define _CRT_SECURE_NO_WARNINGS
    #pragma comment(lib, "ws2_32.lib")
#endif 

#include <stdio.h>
#include <thread>
#include "EasyTcpClient.hpp"

bool g_bRun = true;
void cmdThread()
{
    while (true)
    {
        //3輸入請求命令
        char cmdBuf[128] = {};
        scanf("%s", cmdBuf);
        getchar();
        //4處理請求
        if (0 == strcmp(cmdBuf, "exit"))
        {
            printf("退出cmdThread線程\n");
            return;
        }
        else
        {
            printf("wrong cmd, please input cmd again.\n");
        }
    }
}

int main()
{
    const int count = 100;
    EasyTcpClient* client[count];
    for (int n=0;n<count;n++)
    {
        client[n] = new EasyTcpClient();
        client[n]->Connect("192.168.10.157", 4567);
    }

    std::thread t(cmdThread);
    t.detach();

    Login login = {};
    strcpy(login.userName, "jj");
    strcpy(login.passWord, "ww");

    while (g_bRun)
    {
        for (int n = 0; n < count; n++)
        {
            client[n]->SendData(&login);
            client[n]->onRun();
        }

    }

    for (int n = 0; n < count; n++)
    {
        client[n]->Close();
    }

    for (int n = 0; n < count; n++)
    {
        delete client[n];
        client[n] = nullptr;
    }

    printf("已退出");
    getchar();
    return 0;
}

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

C#開源的兩款功能強大的錄屏神器

ScreenToGif ScreenToGif是一款由C#語言開發且開源的操作簡單、免費的屏幕錄製和GIF動畫製作神器。它可以幫助用戶捕捉計算機屏幕上的實時動畫，並將其保存爲高質量的 GIF 圖像格式。該工具不僅適用於技術支持、軟件演示和教

追逐時光 2024-05-03 14:28:27

前端 Vue yarn.lock文件：詳解和使用指南

yarn.lock文件：詳解和使用指南 https://www.python100.com/html/38KF796X6BHM.html 一、什麼是yarn.lock文件 yarn.lock文件是一個產生於Yarn 0.22及以後版

emanlee 2024-05-03 14:15:26

前端 Vue webpack配置之 webpack.config.js 文件配置

  Webpack 在執行的時候，除了在命令行傳入參數，還可以通過指定的配置文件來執行。默認情況下，會搜索當前目錄的 webpack.config.js 文件，這個文件是一個 node.js 模塊，返回一個 json 格式的配置信息對象，或

emanlee 2024-05-03 14:15:26

Vue package-lock.json的作用

package-lock.json的作用   "node_modules/@aashutoshrathi/word-wrap": { "version": "1.2.6", "resolved": "h

emanlee 2024-05-03 14:15:26

前端 Vue-cli中 vue.config.js 的配置詳解

Vue-cli 3 / Vue-cli 4   目錄結構 ├── README.md # 說明 |-- dist # 打包後文件夾 ├── babel.config.js

emanlee 2024-05-03 14:15:26

druid數據源 xml配置

https://blog.csdn.net/h273979586/article/details/87932220 pom依賴 <dependency> <groupId>com.alibaba</groupId>

tono 2024-05-03 14:14:55

Windows中Redis怎麼設置密碼

Windows中Redis怎麼設置密碼

久曲健 2024-05-03 14:11:15

JDK8和JDK17共存以及切換的方法

1、先安裝"jdk-8u381-windows-x64.exe"，再安裝"jdk-17_windows-x64_bin.exe" 2、"系統屬性"-"高級"-"環境變量"-"系統變量"-"Path"-"編輯"，刪除以下2條 C:\Progr

久曲健 2024-05-03 14:11:15

centos7修改redis密碼

檢查Redis配置文件 首先，我們需要確保Redis的配置文件中包含了設置密碼的選項。打開Redis的配置文件/etc/redis.conf，查找以下行並確保取消註釋（去掉行首的#）： requirepass your_password 啓

久曲健 2024-05-03 14:11:15

基於SSM的在線外賣訂餐系統畢業設計論文【範文】

摘要 隨着互聯網技術的迅猛發展和人們生活節奏的加快，在線外賣訂餐系統因其便捷性和高效率而受到廣泛歡迎。本文圍繞《基於SSM框架的在線外賣訂餐系統》這一課題展開研究，旨在設計並實現一個功能全面、操作簡便且安全可靠的在線外賣訂餐平臺。 首先，文

Lucky帥小武 2024-05-03 14:08:24

基於CodeMirror開發在線編輯器時遇到的問題及解決方案

需求：實現json在線編輯並支持校驗，基於此使用了 CodeMirror在線編輯，jsonlint校驗輸入數據 // package.json: "dependencies": { "codemirror": "^5.53.2"

致愛麗絲 2024-05-03 14:04:44

《軟件性能測試、分析與調優實踐之路》(第2版) PPT課件流出

掃描圖書前言中的如下圖所示的二維碼，即可進入到下載頁面。  如下圖所示即爲課件的下載頁面，免費提供下載      

張永清 2024-05-03 14:01:24

2024年感想

　　看了一眼之前到博客，最近的一次博客還在一年之前，時間如白駒過隙，飛快流逝。這兩年生活和工作都經歷裏很多，想想是應該在這裏好好梳理總結下。我總是感慨，自己從二十六七歲到現在三十多的年紀，好像經歷別人的半輩子，感悟衆多。 　　我以前是個朋友

兜兜有糖的博客 2024-05-03 13:57:53

AWS S3 Lambda Python腳本函數實現圖片自動轉換爲webp並上傳至s3

Amazon S3 自動轉換圖片格式  Amazon S3 存儲桶 新增文件自動觸發 AWS Lambda。Lambda 取 S3 文件做轉換並存回去 S3 同一個目錄下，並增加相應的後綴名。 並且支持通過API Gateway的方式觸發對

翎野 2024-05-03 13:51:42

Eclipse Memory Analyzer (MAT)的安裝後提示JDK版本不對要升級到jdk_17

背景 在啓動MAT分析內存時報錯：Version1.8.0 of the jvm is not suitable for this product，Version17 or greater isrequired。 問題原因很明顯，我電腦的J

翎野 2024-05-03 13:51:42