常見HTTP狀態碼與常見編程語言應用

原創 PetterLiu 2023-12-25 13:26

常見HTTP狀態碼與常見編程語言應用

      我之前問過一些初中級工程師，他們並不是每一個人都清楚。但確實很重要。您應該知道的 HTTP 狀態代碼 HTTP 的響應代碼分爲五類：

以下是一些常見的HTTP狀態碼及其含義：

  1. 1xx（信息性狀態碼）：這些狀態碼錶示請求已被接收，繼續處理。

    • 100 Continue：服務器已經收到了請求的首部，並且客戶端應該繼續發送請求的其餘部分。
    • 101 Switching Protocols：服務器已經理解了客戶端的請求，並將通過Upgrade消息頭通知客戶端採用不同的協議。

  2. 2xx（成功狀態碼）：這些狀態碼錶示請求被成功接收、理解、接受或處理。

    • 200 OK：請求成功。常用於GET、POST等請求。
    • 201 Created：請求已經被實現，而且有一個新的資源已經依據請求的需要而建立。
    • 204 No Content：服務器成功處理了請求，但不需要返回任何實體內容。

  3. 3xx（重定向狀態碼）：客戶端需要進行附加操作以完成請求。

    • 301 Moved Permanently：永久重定向，請求的資源已被分配了新的URI。
    • 302 Found：臨時重定向，請求的資源現在臨時從不同的URI響應請求。
    • 304 Not Modified：客戶端已經執行了條件GET請求，資源未被修改。

  4. 4xx（客戶端錯誤狀態碼）：客戶端似乎有錯誤，請求包含諸如語法錯誤或無效請求之類的錯誤。

    • 400 Bad Request：請求無效，服務器不理解請求的語法。
    • 401 Unauthorized：請求要求身份驗證。要求用戶進行身份驗證。
    • 403 Forbidden：服務器理解請求，但是拒絕執行請求。

  5. 5xx（服務器錯誤狀態碼）：服務器在處理請求的過程中發生錯誤。

    • 500 Internal Server Error：服務器內部錯誤，無法完成請求。
    • 502 Bad Gateway：服務器作爲網關或代理，從上游服務器收到無效響應。
    • 503 Service Unavailable：服務器暫時不可用，通常是由於維護或過載。

這些代碼在 RFC 9110 中定義。爲了避免您閱讀整個文檔（大約 200 頁），以下是最常見的摘要。

image


在Spring Boot中

你可以通過`ResponseEntity`類來設置HTTP狀態碼並返回響應實體。這樣的方式允許你更靈活地處理HTTP狀態碼，並將其與前端應用實現基於語意的邏輯。以下是一些示例：

1. **成功響應**：

   ```java
    @GetMapping("/success")
    public ResponseEntity<String> success() {
        return ResponseEntity.ok("Operation successful");
    }
    ```

   這將返回狀態碼200 OK，並且響應體包含"Operation successful"。

2. **客戶端錯誤**：

   ```java
    @GetMapping("/client-error")
    public ResponseEntity<String> clientError() {
        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body("Client error: Bad request");
    }
    ```

   這將返回狀態碼400 Bad Request，並且響應體包含"Client error: Bad request"。

3. **服務器錯誤**：

   ```java
    @GetMapping("/server-error")
    public ResponseEntity<String> serverError() {
        return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("Server error: Internal server error");
    }
    ```

   這將返回狀態碼500 Internal Server Error，並且響應體包含"Server error: Internal server error"。

4. **重定向**：

   ```java
    @GetMapping("/redirect")
    public ResponseEntity<Void> redirect() {
        HttpHeaders headers = new HttpHeaders();
        headers.setLocation(URI.create("https://www.example.com"));
        return new ResponseEntity<>(headers, HttpStatus.FOUND);
    }
    ```

   這將返回狀態碼302 Found，並重定向到https://www.example.com。

   在前端應用中，你可以利用這些狀態碼來實現基於語意的邏輯。比如，如果收到200 OK，可以表示操作成功，然後在前端做出相應的界面更新；如果收到400 Bad Request，可以提示用戶輸入的數據有誤等。對於異步請求，前端還可以根據狀態碼執行相應的回調函數。Spring Boot的`ResponseEntity`提供了很多方法來設置不同的狀態碼，你可以根據需要選擇合適的方法來構建響應。

Resteasy

     Resteasy是一個用於構建RESTful Web服務的JAX-RS實現框架，它是基於Java的。在Resteasy框架中，你可以通過使用JAX-RS的`Response`類來處理HTTP狀態碼，並根據業務需求進行適當的處理。以下是一些示例代碼，演示瞭如何在Resteasy中處理HTTP 400和500異常狀態：

1. **成功響應**：

   ```java
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.core.Response;

   @Path("/data")
    public class MyResource {

       @GET
        public Response getData() {
            // 處理成功響應
            return Response.ok("Operation successful").build();
        }
    }
    ```

   在這個例子中，`Response.ok()`方法表示返回一個HTTP 200 OK的響應。

2. **客戶端錯誤**：

   ```java
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.core.Response;

   @Path("/data")
    public class MyResource {

       @GET
        public Response getData() {
            // 處理客戶端錯誤
            return Response.status(Response.Status.BAD_REQUEST)
                    .entity("Client error: Bad request")
                    .build();
        }
    }
    ```

   在這個例子中，`Response.status(Response.Status.BAD_REQUEST)`表示返回一個HTTP 400 Bad Request的響應。

3. **服務器錯誤**：

   ```java
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.core.Response;

   @Path("/data")
    public class MyResource {

       @GET
        public Response getData() {
            // 處理服務器錯誤
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity("Server error: Internal server error")
                    .build();
        }
    }
    ```

   在這個例子中，`Response.status(Response.Status.INTERNAL_SERVER_ERROR)`表示返回一個HTTP 500 Internal Server Error的響應。

4. **自定義異常處理**：

   ```java
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.core.Response;

   @Path("/data")
    public class MyResource {

       @GET
        public Response getData() {
            // 模擬業務邏輯錯誤
            boolean businessLogicFailed = true;

           if (businessLogicFailed) {
                // 處理自定義異常
                return Response.status(Response.Status.UNPROCESSABLE_ENTITY)
                        .entity("Custom error: Business logic failed")
                        .build();
            }

           // 處理成功響應
            return Response.ok("Operation successful").build();
        }
    }
    ```

   在這個例子中，如果業務邏輯失敗，將返回一個HTTP 422 Unprocessable Entity的響應。在的實際項目中，你可以根據業務邏輯、錯誤類型和HTTP狀態碼來選擇適當的`Response`方法。記住在構建`Response`實例時，可以設置狀態碼、實體內容、頭部信息等來滿足你的需求。


Go語言（Golang）中


     你可以使用`net/http`包來處理HTTP請求和響應。以下是一些在Golang中運用HTTP狀態碼與前端應用實現基於語意的邏輯的示例：

1. **成功響應**：

   ```go
    package main

   import (
        "net/http"
        "fmt"
    )

   func successHandler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Operation successful")
    }

   func main() {
        http.HandleFunc("/success", successHandler)
        http.ListenAndServe(":8080", nil)
    }
    ```

   這將在`/success`路徑上返回狀態碼200 OK和"Operation successful"的響應。

2. **客戶端錯誤**：

   ```go
    package main

   import (
        "net/http"
        "fmt"
    )

   func clientErrorHandler(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusBadRequest)
        fmt.Fprint(w, "Client error: Bad request")
    }

   func main() {
        http.HandleFunc("/client-error", clientErrorHandler)
        http.ListenAndServe(":8080", nil)
    }
    ```

   這將在`/client-error`路徑上返回狀態碼400 Bad Request和"Client error: Bad request"的響應。

3. **服務器錯誤**：

   ```go
    package main

   import (
        "net/http"
        "fmt"
    )

   func serverErrorHandler(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusInternalServerError)
        fmt.Fprint(w, "Server error: Internal server error")
    }

   func main() {
        http.HandleFunc("/server-error", serverErrorHandler)
        http.ListenAndServe(":8080", nil)
    }
    ```

   這將在`/server-error`路徑上返回狀態碼500 Internal Server Error和"Server error: Internal server error"的響應。

4. **重定向**：

   ```go
    package main

   import (
        "net/http"
        "net/url"
        "fmt"
    )

   func redirectHandler(w http.ResponseWriter, r *http.Request) {
        targetURL := "/redirect-target?param=value"
        http.Redirect(w, r, targetURL, http.StatusFound)
    }

   func main() {
        http.HandleFunc("/redirect", redirectHandler)
        http.ListenAndServe(":8080", nil)
    }
    ```

   這將在`/redirect`路徑上執行302 Found重定向到`/redirect-target?param=value`。

在前端應用中，你可以利用這些狀態碼來實現基於語意的邏輯。例如，使用XMLHttpRequest、Fetch API或Axios等工具發起HTTP請求，然後根據返回的狀態碼執行相應的操作。下面是一個使用Fetch API的簡單示例：

```javascript
fetch('http://localhost:8080/server-error')
     .then(response => {
         if (!response.ok) {
             throw new Error(`HTTP error! Status: ${response.status}`);
         }
         return response.text();
     })
     .then(data => {
         // 處理成功響應
         console.log(data);
     })
     .catch(error => {
         // 處理錯誤響應
         console.error(error.message);
     });
```

在前端代碼中，你可以根據HTTP狀態碼進行不同的處理，例如顯示錯誤消息、更新頁面內容等。這樣，前端和後端之間就能夠實現基於語意的邏輯交互。


在Gin框架中

你可以使用`gin.Context`對象來處理HTTP請求和響應。以下是一些在Gin框架中運用HTTP狀態碼與前端應用實現基於語意的邏輯的示例：

1. **成功響應**：

   ```go
    package main

   import (
        "github.com/gin-gonic/gin"
        "net/http"
    )

   func successHandler(c *gin.Context) {
        c.String(http.StatusOK, "Operation successful")
    }

   func main() {
        router := gin.Default()
        router.GET("/success", successHandler)
        router.Run(":8080")
    }
    ```

   這將在`/success`路徑上返回狀態碼200 OK和"Operation successful"的響應。

2. **客戶端錯誤**：

   ```go
    package main

   import (
        "github.com/gin-gonic/gin"
        "net/http"
    )

   func clientErrorHandler(c *gin.Context) {
        c.String(http.StatusBadRequest, "Client error: Bad request")
    }

   func main() {
        router := gin.Default()
        router.GET("/client-error", clientErrorHandler)
        router.Run(":8080")
    }
    ```

   這將在`/client-error`路徑上返回狀態碼400 Bad Request和"Client error: Bad request"的響應。

3. **服務器錯誤**：

   ```go
    package main

   import (
        "github.com/gin-gonic/gin"
        "net/http"
    )

   func serverErrorHandler(c *gin.Context) {
        c.String(http.StatusInternalServerError, "Server error: Internal server error")
    }

   func main() {
        router := gin.Default()
        router.GET("/server-error", serverErrorHandler)
        router.Run(":8080")
    }
    ```

   這將在`/server-error`路徑上返回狀態碼500 Internal Server Error和"Server error: Internal server error"的響應。

4. **重定向**：

   ```go
    package main

   import (
        "github.com/gin-gonic/gin"
        "net/http"
    )

   func redirectHandler(c *gin.Context) {
        targetURL := "/redirect-target?param=value"
        c.Redirect(http.StatusFound, targetURL)
    }

   func main() {
        router := gin.Default()
        router.GET("/redirect", redirectHandler)
        router.Run(":8080")
    }
    ```

   這將在`/redirect`路徑上執行302 Found重定向到`/redirect-target?param=value`。

在前端應用中，你可以使用類似前面提到的方法來處理HTTP請求，並根據狀態碼執行相應的操作。在Gin框架中，你還可以通過`c.JSON()`方法返回JSON格式的響應，或使用`c.HTML()`方法返回HTML頁面，以滿足不同前端應用的需求。請注意，在實際應用中，你可能還需要處理路由、中間件、參數解析等其他方面的邏輯，具體根據你的應用場景來調整和擴展這些示例。

在Rust中

你可以使用標準庫中的 `hyper`、`actix-web` 或其他 Web 框架來處理 HTTP 請求和響應。以下是一個使用 `actix-web` 框架的簡單示例，演示如何處理服務端返回的 HTTP 400 和 500 異常狀態：

首先，確保在 `Cargo.toml` 文件中添加 `actix-web` 依賴：

```toml
[dependencies]
actix-web = "4"
```

然後，創建一個簡單的 `main.rs` 文件：

```rust
use actix_web::{web, App, HttpResponse, HttpServer};

async fn success_handler() -> HttpResponse {
     HttpResponse::Ok().body("Operation successful")
}

async fn client_error_handler() -> HttpResponse {
     HttpResponse::BadRequest().body("Client error: Bad request")
}

async fn server_error_handler() -> HttpResponse {
     HttpResponse::InternalServerError().body("Server error: Internal server error")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
     HttpServer::new(|| {
         App::new()
             .route("/success", web::get().to(success_handler))
             .route("/client-error", web::get().to(client_error_handler))
             .route("/server-error", web::get().to(server_error_handler))
     })
     .bind("127.0.0.1:8080")?
     .run()
     .await
}
```

在這個例子中：

- `/success` 路徑處理成功的請求，返回狀態碼 200 OK。
- `/client-error` 路徑處理客戶端錯誤的請求，返回狀態碼 400 Bad Request。
- `/server-error` 路徑處理服務器錯誤的請求，返回狀態碼 500 Internal Server Error。

你可以根據需要在這些處理函數中加入業務邏輯和錯誤處理。

然後，運行你的 Rust 應用：

```bash
cargo run
```

應用將在 `127.0.0.1:8080` 地址上運行。你可以使用 curl、Postman 或瀏覽器訪問這些路徑來測試不同的 HTTP 狀態碼的處理。


Vue.js

在Vue.js中處理服務端返回的HTTP 400和500異常狀態通常涉及到異步請求和Promise處理。你可以使用Vue.js中的Axios庫或Vue Resource等HTTP庫來發送異步請求。以下是使用Axios庫的示例：

1. **安裝 Axios**：

   首先，確保你的項目中已經安裝了Axios。如果沒有安裝，可以使用以下命令安裝：

   ```bash
    npm install axios
    ```

2. **在Vue組件中發送請求**：

   在Vue組件中，你可以使用Axios發送HTTP請求。例如，發送GET請求：

   ```javascript
    // 引入Axios
    import axios from 'axios';

   export default {
        methods: {
            fetchData() {
                axios.get('/api/data')
                    .then(response => {
                        // 處理成功響應
                        console.log(response.data);
                    })
                    .catch(error => {
                        // 處理異常狀態
                        if (error.response) {
                            // 請求已發出，但服務器返回狀態碼不在2xx範圍內
                            console.error('HTTP Error', error.response.status);

                           // 處理HTTP 400錯誤
                            if (error.response.status === 400) {
                                console.error('Bad Request');
                                // 執行相關操作，比如提示用戶輸入有誤
                            }

                           // 處理HTTP 500錯誤
                            if (error.response.status === 500) {
                                console.error('Internal Server Error');
                                // 執行相關操作，比如提示用戶服務器出現問題
                            }
                        } else {
                            // 請求未發出，網絡出現問題等
                            console.error('Network Error', error.message);
                        }
                    });
            }
        }
    };
    ```

   在這個例子中，`axios.get()`方法發送GET請求，並使用`.then()`和`.catch()`處理成功和失敗的回調。在失敗的回調中，我們檢查`error.response`對象，以獲取服務器返回的響應信息和狀態碼。

3. **在模板中使用方法**：

   在模板中使用剛剛定義的方法：

   ```html
    <template>
        <div>
            <button @click="fetchData">Fetch Data</button>
        </div>
    </template>
    ```

通過這種方式，你可以在Vue.js中根據服務端返回的HTTP狀態碼，實現不同的前端邏輯。這包括對HTTP 400和500等異常狀態的處理。當然，具體的處理方式可以根據你的項目需求進行調整。


在React.js中

你可以使用`fetch` API或第三方庫（如axios、fetch-mock、superagent等）來發送HTTP請求，並根據服務端返回的狀態碼進行處理。以下是使用`fetch` API的示例：

1. **使用 `fetch` API 發送請求**：

   ```javascript
    // 在組件中導入 React 和 useEffect
    import React, { useEffect } from 'react';

   const MyComponent = () => {
      useEffect(() => {
        fetchData();
      }, []);

     const fetchData = async () => {
        try {
          const response = await fetch('/api/data');
          if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
          }

         const data = await response.json();
          console.log(data);
        } catch (error) {
          // 處理異常狀態
          if (error instanceof Error) {
            console.error('Network Error', error.message);
          } else {
            console.error('Unexpected Error', error);
          }
        }
      };

     return <div>My Component</div>;
    };

   export default MyComponent;
    ```

2. **處理異常狀態**：

   在`fetch`的`catch`塊中，我們可以根據響應狀態碼執行不同的邏輯。例如：

   ```javascript
    const fetchData = async () => {
      try {
        const response = await fetch('/api/data');
        if (!response.ok) {
          // 請求已發出，但服務器返回狀態碼不在2xx範圍內
          console.error('HTTP Error', response.status);

         // 處理HTTP 400錯誤
          if (response.status === 400) {
            console.error('Bad Request');
            // 執行相關操作，比如提示用戶輸入有誤
          }

         // 處理HTTP 500錯誤
          if (response.status === 500) {
            console.error('Internal Server Error');
            // 執行相關操作，比如提示用戶服務器出現問題
          }

         throw new Error(`HTTP error! Status: ${response.status}`);
        }

       const data = await response.json();
        console.log(data);
      } catch (error) {
        // 處理異常狀態
        if (error instanceof Error) {
          console.error('Network Error', error.message);
        } else {
          console.error('Unexpected Error', error);
        }
      }
    };
    ```

     在上述示例中，我們通過`response.ok`檢查HTTP狀態碼是否在2xx範圍內，如果不在範圍內，則拋出一個包含狀態碼的錯誤。然後，可以在`catch`塊中根據錯誤的類型進行不同的處理，以滿足特定的業務需求。

請注意，`fetch` API默認只在網絡錯誤時纔會reject Promise。如果HTTP請求成功但返回的狀態碼錶示錯誤，`fetch`並不會reject。因此，我們需要手動檢查`response.ok`並在需要時拋出錯誤。


今天先到這兒，希望對雲原生，技術領導力， 企業管理，系統架構設計與評估，團隊管理, 項目管理, 產品管管，團隊建設 有參考作用 , 您可能感興趣的文章:
領導人怎樣帶領好團隊
構建創業公司突擊小團隊
國際化環境下系統架構演化
微服務架構設計
視頻直播平臺的系統架構演化
微服務與Docker介紹
Docker與CI持續集成/CD
互聯網電商購物車架構演變案例
互聯網業務場景下消息隊列架構
互聯網高效研發團隊管理演進之一
消息系統架構設計演進
互聯網電商搜索架構演化之一
企業信息化與軟件工程的迷思
企業項目化管理介紹
軟件項目成功之要素
人際溝通風格介紹一
精益IT組織與分享式領導
學習型組織與企業
企業創新文化與等級觀念
組織目標與個人目標
初創公司人才招聘與管理
人才公司環境與企業文化
企業文化、團隊文化與知識共享
高效能的團隊建設
項目管理溝通計劃
構建高效的研發與自動化運維
某大型電商雲平臺實踐
互聯網數據庫架構設計思路
IT基礎架構規劃方案一(網絡系統規劃)
餐飲行業解決方案之客戶分析流程
餐飲行業解決方案之採購戰略制定與實施流程
餐飲行業解決方案之業務設計流程
供應鏈需求調研CheckList
企業應用之性能實時度量系統演變

如有想了解更多軟件設計與架構, 系統IT,企業信息化, 團隊管理 資訊，請關注我的微信訂閱號：

MegadotnetMicroMsg_thumb1_thumb1_thu[2]

作者：Petter Liu
出處：http://www.cnblogs.com/wintersun/
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。 該文章也同時發佈在我的獨立博客中-Petter Liu Blog。

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

在Avalonia中，如何移除高度的值，使其爲NaN

 MainBody.Height = double.NaN;//移除該屬性值 這樣就能自適應高度了

揚中源 2024-04-30 14:27:14

nginx反向代理與證書設置

server { listen 443 ssl; server_name your.domain.com; ssl_certificate /path/to/certificate.crt; ssl_ce

hiningrise 2024-04-30 14:25:14

免費證書certbot-aliyun

FROM certbot/certbot RUN pip install certbot-dns-aliyun docker build -t certbot-aliyun . # Aliyun DNS credentials

hiningrise 2024-04-30 14:25:14

通過Http鏈接地址爬取有贊微信商城商品信息及下載至EXCEL

一、環境 開發環境： Microsoft Visual Studio Professional 2022 (2) (64 位) - Current版本 17.7.7 .net core 6.0 AngleSharp 1.1.2 AngleS

冰臨神下 2024-04-30 14:22:03

多人同時導出 Excel 幹崩服務器！新來的阿里大佬給出的解決方案太優雅了！

來源：juejin.cn/post/7259249904777838629 前言 業務訴求：考慮到數據庫數據日漸增多，導出會有全量數據的導出，多人同時導出可以會對服務性能造成影響，導出涉及到mysql查詢的io操作，還涉及文件輸入、輸出流的

Java技術棧 2024-04-30 14:21:33

golang將uint32與byte[]互轉

package main import ( "encoding/binary" "fmt" ) func main() { // 一個長度爲4的byte切片，表示一個負數 bytes := []byte{0xFF, 0xFF,

藍天上的雲℡ 2024-04-30 14:21:33

Linux內核源碼-存儲驅動之 QSPI Flash

傳輸方式 DIO/QIO/DOUT/QPI QPI模式(Quad Peripheral Interface)，所有階段都通過4線傳輸。與之相對的是SPI。 SPI模式： 純種SPI(MISO/MOSI兩個數據線) DOUT 全稱 Dua

藍天上的雲℡ 2024-04-30 14:21:33

一個園上面點3個點, 成鈍角三角形概率多大?

答案1/4 要有數學上的順序的概念.

張博的博客 2024-04-30 14:20:03

python找不到自己的寫的庫包或者文件

import sys sys.path.append('../..') sys.path.append('.') sys.path.append('./') 把這些路徑都加入sys.path就找到了.

張博的博客 2024-04-30 14:20:02

符文Runes協議技術詳解

最近符文Runes協議是比特幣生態最火的項目，於是我利用晚上的時間，把Runes協議使用Go語言實現了一遍，項目地址：https://github.com/bxelab/runestone，另外也基於這個Runestone庫編寫對應的一個命

深藍 2024-04-30 14:18:02

《最新出爐》系列入門篇-Python+Playwright自動化測試-41-錄製視頻

1.簡介 上一篇講解和分享了錄製自動生成腳本，索性連帶錄製視頻也一股腦的在這裏就講解和分享了。今天我們將學習如何使用Playwright和Python來錄製瀏覽器操作的視頻，以便在需要時進行回放和分析。 2.錄製視頻語法 錄製視頻介紹官方A

北京-宏哥 2024-04-30 14:14:41

MFC文本設置字體發虛的問題

MFC 文本設置字體發虛的問題 最近在做一項目中，發現默認的字體比較正常，字體如下： 字體比較清晰，在代碼加入如下設置字體項後，反而顯示發虛，模糊 CFont * m_font= new CFont; m_font->CreatePoin

孤獨的貓 2024-04-30 14:13:31

算法~利用zset實現滑動窗口限流

滑動窗口限流 滑動窗口限流是一種常用的限流算法，通過維護一個固定大小的窗口，在單位時間內允許通過的請求次數不超過設定的閾值。具體來說，滑動窗口限流算法通常包括以下幾個步驟： 初始化：設置窗口大小、請求次數閾值和時間間隔。 維護窗口：將請求

張佔嶺 2024-04-30 14:12:40

springboot~AutoConfigureAfter如何控制Bean的注入順序

這個文章主要介紹一下@AutoConfigureAfter在spring框架中的作用，在使用過程中，很多開發人員在使用它的時候都出現了問題，問題比較多的就是它們的註冊順序總不是我們預期的，下面介紹一下正常的使用方法。 @AutoConfi

張佔嶺 2024-04-30 14:12:40

java~graalVM虛擬機

GraalVM GraalVM 是一種高性能、通用的虛擬機，由 Oracle 公司開發。它支持多種編程語言（如 Java、JavaScript、Python 等），並提供了即時編譯器、AOT 編譯器等功能。GraalVM 的主要特點包括：

張佔嶺 2024-04-30 14:12:40