golang 封装 http请求

随着互联网的发展，HTTP请求已经成为了后端开发的标配，也是前端发起网络请求的方式。在Golang中，标准库内置了net/http包，提供了一个完整的HTTP客户端和服务端。不过，封装一个HTTP请求库能够让我们在开发过程中更加高效、方便地发起HTTP请求。在这篇文章中，我们将讨论如何封装一个Golang的HTTP请求库。

一、需求分析

在封装一个HTTP请求库之前，我们需要明确一些需求和功能，以便于更好地设计和开发我们的库。在这里，我们认为一个完整的HTTP请求库需要具备以下几个功能：

1. 支持GET、POST、PUT、DELETE等HTTP方法。
2. 支持设置请求头、请求体以及请求参数。
3. 支持设置超时时间和重试次数。
4. 支持返回值的格式化成不同的数据类型。

基于以上需求和功能，我们可以开始设计和开发我们的HTTP请求库。

二、设计与实现

2.1 设计要点

在设计我们的HTTP请求库时，我们需要考虑一些关键点，以便于实现一个高可用、可扩展和易于使用的请求库。具体来说，我们应该考虑以下几个方面：

1. 网络问题。

在发起HTTP请求时，我们要考虑到网络问题，例如连接超时、请求超时等等。因此，在我们的HTTP请求库中需要支持设置连接超时时间和请求超时时间。

2. 异常处理。

当我们发起HTTP请求时，可能会出现各种不可预测的异常，例如网络异常、返回值异常等等。为了使我们的HTTP请求库更加健壮，需要针对这些异常进行处理，例如根据http状态码、异常信息等来进行相应的处理。

3. RESTful API支持。

在RESTful API中，常常需要提交JSON数据或表单数据等等。因此，在我们的HTTP请求库中，需要支持这些数据的提交和解析。

4. 对返回值的处理。

在发起HTTP请求后，我们需要对返回值进行处理。通常，不同的API接口返回值的格式可能会有所不同，因此，我们需要支持根据API接口的返回值格式进行相应的处理。

2.2 实现流程

基于以上的设计要点，在我们开始实现HTTP请求库时，我们可以按照以下步骤进行：

1. 定义HTTP请求的结构体。

在封装一个HTTP请求库时，我们需要将HTTP请求的信息进行封装。具体来说，我们可以定义一个HTTP请求的结构体，以便于存储和传递HTTP请求所需的信息。下面是一个HTTP请求的结构体的示例：

type Request struct {
    URL        string
    Method     string
    Headers    map[string]string
    Body       []byte
    Params     map[string]string
    Timeout    int
    RetryTimes int
}

2. 发起HTTP请求。

在我们定义好HTTP请求结构体后，我们可以通过Golang的标准库来发送HTTP请求。

例如，我们可以使用http.NewRequest()方法来创建一个HTTP请求：

req, err := http.NewRequest(req.Method, req.URL, bytes.NewBuffer(req.Body))
if err != nil {
    return nil, err
}

使用http.Transport中的DialContext()方法来设置连接超时和请求超时:

client := &http.Client{
        Transport: &http.Transport{
            DialContext: (&net.Dialer{
                Timeout:   time.Duration(req.Timeout) * time.Second,
                KeepAlive: time.Duration(req.Timeout) * time.Second,
            }).DialContext,
            MaxIdleConns:        100,              // http.ConnectionPool数量
            IdleConnTimeout:     90 * time.Second, // http.ConnectionPool中连接的空闲超时时间
            TLSHandshakeTimeout: 10 * time.Second,
            ExpectContinueTimeout: 1 * time.Second,
        }
    }

接着，我们可以使用Do()方法发起HTTP请求，并获取返回值：

resp, err := client.Do(req)
if err != nil {
    return nil, err
}

在成功发起HTTP请求后，我们需要释放资源，避免恶意请求导致的内存泄漏：

defer resp.Body.Close()

3. 异常处理。

在发起HTTP请求时，可能会出现各种不可预测的异常，例如网络异常、返回值异常等等。因此，在我们的HTTP请求库中需要针对这些异常进行处理。

例如，我们可以根据HTTP的status code 和 response body 来检查HTTP请求的异常。如果发生了异常，我们可以根据异常的类型返回相应的错误信息，以便于在开发过程中及时发现并进行处理。

4. RESTful API支持。

在调用RESTful API时，我们需要支持不同的提交格式，例如JSON数据或表单数据等等。为了使我们的HTTP请求库更加通用，可以添加一个ContentType属性字段来支持不同的提交格式。同时，在提交JSON数据时，我们也需要将数据编码为JSON格式。

5. 对返回值的处理。

在调用接口后，我们需要对返回值进行处理。通常，不同的API接口返回值的格式可能会有所不同，因此，我们需要在上层应用中根据API接口的返回值格式进行相应的处理。例如，可以根据返回值的格式设置反序列化的方式。

2.3 代码实现

基于以上的设计要点，在我们开始实现HTTP请求库时，可以参考以下的代码实现：

package httpreq

import (
    "bytes"
    "encoding/json"
    "io/ioutil"
    "net"
    "net/http"
    "time"
)

type Request struct {
    URL        string
    Method     string
    Headers    map[string]string
    Body       []byte
    Params     map[string]string
    Timeout    int
    RetryTimes int
    ContentType string
}

type Response struct {
    StatusCode int
    Body       []byte
}

func Do(req Request) (*Response, error) {
    if req.Method == "" {
        req.Method = http.MethodGet
    }

    // 处理请求参数
    if req.Params != nil {
        req.URL = AddQueryParams(req.URL, req.Params)
    }

    // 创建一个请求
    httpRequest, err := http.NewRequest(req.Method, req.URL, bytes.NewBuffer(req.Body))
    if err != nil {
        return nil, err
    }

    // 处理请求头
    if req.Headers != nil {
        for k, v := range req.Headers {
            httpRequest.Header.Set(k, v)
        }
    }

    // 设置ContentType
    if req.ContentType != "" {
        httpRequest.Header.Set("Content-Type", req.ContentType)
    }

    // 设置请求超时
    httpClient := &http.Client{
        Transport: &http.Transport{
            DialContext: (&net.Dialer{
                Timeout:   time.Duration(req.Timeout) * time.Second,
                KeepAlive: time.Duration(req.Timeout) * time.Second,
            }).DialContext,
            MaxIdleConns:        100,              // http.ConnectionPool数量
            IdleConnTimeout:     90 * time.Second, // http.ConnectionPool中连接的空闲超时时间
            TLSHandshakeTimeout: 10 * time.Second,
            ExpectContinueTimeout: 1 * time.Second,
        },
    }

    // 发起请求
    resp, err := httpClient.Do(httpRequest)
    if err != nil {
        return nil, err
    }

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    // 处理异常
    if resp.StatusCode >= 400 {
        return nil, NewError(resp.StatusCode, body)
    }

    return &Response{StatusCode: resp.StatusCode, Body: body}, nil
}

func AddQueryParams(url string, params map[string]string) string {
    var queryParams string
    for k, v := range params {
        queryParams = queryParams + "&" + k + "=" + v
    }
    url = url + "?" + queryParams[1:]
    return url
}

func NewError(statusCode int, body []byte) error {
    errorMsg := string(body)
    if errorMsg == "" {
        errorMsg = http.StatusText(statusCode)
    }
    return &httpError{StatusCode: statusCode, Message: errorMsg}
}

type httpError struct {
    StatusCode int
    Message    string
}

func (e *httpError) Error() string {
    return e.Message
}

func (r *Response) BindJSON(v interface{}) error {
    return json.Unmarshal(r.Body, v)
}

func (r *Response) BindText() string {
    return string(r.Body)
}

三、总结

通过以上的讨论，我们可以发现，封装一个Golang的HTTP请求库并不是一件特别困难的事情。关键在于我们应该清楚我们的需求、了解网络请求的一些细节，然后我们就可以在Golang中使用标准库提供的方法封装一个优秀的HTTP请求库了。同时，在实现的过程中，我们也需要考虑到一些细节问题，例如异常处理、RESTful API支持、对返回值的处理等等。通过认真的设计和实现，我们可以开发一个高质量的HTTP请求库，使我们的Golang开发更加高效和便捷。

以上是golang 封装 http请求的详细内容。更多信息请关注PHP中文网其他相关文章！