常见HTTP状态码与常见编程语言应用

常见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 页），以下是最常见的摘要。

在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中处理服务端返回的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`并在需要时抛出错误。

如有想了解更多软件设计与架构, 系统IT,企业信息化, 团队管理 资讯，请关注我的微信订阅号：

作者：Petter Liu
出处：http://www.cnblogs.com/wintersun/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 该文章也同时发布在我的独立博客中-Petter Liu Blog。

本栏目推荐文章
• 【C语言】
• 【C语言】形参和实参的一些注意点
• Go 语言为什么不支持并发读写 map？
• 【C语言】函数的递归调用
• 字节微服务HTTP框架Hertz使用与源码分析｜拥抱开
• Maven常见问题与原理技巧
• Scala编程语言day1
• NUS CS1101S：SICP JavaScript 描述：四、元语言抽象
• NUS CS1101S：SICP JavaScript 描述：三、模块化、对象和状态
• 学了这么多编程语言，你学会了几种“Hello world”呢？

常见 编程语言 状态 语言 HTTP常见 编程语言 状态 语言 状态 常见 错误http 进程 状态 语言 报文http状态 常见 状态 常见http 接口 常见 错误 语言 自动机 题解 状态 语言 语言 服务器http gzip 模型 常见 语言 方法 序列 编程语言 片段 常见