MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Go HTTP客户端的实现

2021-06-067.9k 阅读

Go HTTP客户端基础

在Go语言中，net/http包为实现HTTP客户端提供了丰富且易用的功能。这个包构建在Go的标准库之上，充分利用了Go语言的并发特性，使得HTTP请求的发送变得高效且简洁。

要发起一个基本的HTTP GET请求，我们可以使用http.Get函数。以下是一个简单的示例：

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

在上述代码中，http.Get函数接受一个URL作为参数，尝试发起一个GET请求到指定的URL。如果请求成功，它会返回一个*http.Response对象，我们可以从这个对象中获取诸如状态码、响应头和响应体等信息。resp.Body是一个io.ReadCloser类型，在使用完毕后需要关闭以避免资源泄漏，这里通过defer关键字确保在函数结束时关闭。

定制HTTP请求

设置请求头

通常我们需要在HTTP请求中设置自定义的请求头。例如，许多API要求在请求头中设置身份验证信息。在Go中，我们可以通过http.NewRequest函数创建一个自定义的*http.Request对象，并设置其Header字段。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    req, err := http.NewRequest("GET", "https://www.example.com", nil)
    if err != nil {
        fmt.Println("创建请求出错:", err)
        return
    }
    req.Header.Set("User - Agent", "MyCustomAgent/1.0")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("发送请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

在这个例子中，我们首先使用http.NewRequest创建了一个GET请求，第二个参数是URL，第三个参数为nil表示这是一个没有请求体的GET请求。然后，我们通过req.Header.Set方法设置了User - Agent请求头。最后，使用http.Client的Do方法发送这个自定义的请求。

添加请求体

对于POST、PUT等需要发送请求体的HTTP方法，我们可以在http.NewRequest的第三个参数中传入一个实现了io.Reader接口的对象。例如，如果我们要发送JSON格式的数据：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type RequestData struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    data := RequestData{
        Name: "John",
        Age:  30,
    }
    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Println("JSON编码出错:", err)
        return
    }

    req, err := http.NewRequest("POST", "https://www.example.com/api", bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println("创建请求出错:", err)
        return
    }
    req.Header.Set("Content - Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("发送请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

在这段代码中，我们定义了一个RequestData结构体，将其转换为JSON格式的字节切片。然后使用bytes.NewBuffer将JSON数据包装成一个io.Reader，作为http.NewRequest的第三个参数，以发送POST请求。同时，我们设置了Content - Type请求头为application/json，以告知服务器请求体的格式。

处理HTTP响应

读取响应体

获取HTTP响应后，最常见的操作之一就是读取响应体的内容。由于resp.Body是一个io.ReadCloser，我们可以使用ioutil.ReadAll（在Go 1.16之前）或io.ReadAll（Go 1.16及之后）函数来读取其全部内容。

package main

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

func main() {
    resp, err := http.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("读取响应体出错:", err)
        return
    }

    fmt.Println("响应内容:", string(body))
}

上述代码使用io.ReadAll读取了响应体的全部内容，并将其转换为字符串后打印出来。

解析JSON响应

许多现代API返回JSON格式的数据。在Go中，我们可以使用json.Unmarshal函数将JSON响应解析为结构体。

package main

import (
    "fmt"
    "io"
    "net/http"
    "encoding/json"
)

type ResponseData struct {
    Message string `json:"message"`
    Code    int    `json:"code"`
}

func main() {
    resp, err := http.Get("https://www.example.com/api/response")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("读取响应体出错:", err)
        return
    }

    var data ResponseData
    err = json.Unmarshal(body, &data)
    if err != nil {
        fmt.Println("JSON解析出错:", err)
        return
    }

    fmt.Println("消息:", data.Message)
    fmt.Println("代码:", data.Code)
}

这里我们定义了ResponseData结构体，其字段标签与JSON数据中的键相对应。通过json.Unmarshal将读取到的JSON响应数据解析到data结构体实例中，从而方便地获取和处理响应数据。

HTTP客户端的高级特性

超时设置

为了防止HTTP请求长时间等待响应，我们可以设置超时时间。http.Client结构体有一个Timeout字段，用于设置整个请求的最长时间。

package main

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

func main() {
    client := &http.Client{
        Timeout: 5 * time.Second,
    }

    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

在上述代码中，我们创建了一个http.Client实例，并设置Timeout为5秒。如果在5秒内请求没有完成，将会返回一个超时错误。

重定向策略

HTTP请求可能会遇到重定向（例如301、302状态码）。http.Client有一个CheckRedirect字段，允许我们自定义重定向策略。默认情况下，http.Client会自动处理重定向，最多10次。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            if len(via) >= 2 {
                return http.ErrUseLastResponse
            }
            return nil
        },
    }

    resp, err := client.Get("https://www.example.com/redirect")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

在这个例子中，我们通过CheckRedirect函数自定义了重定向策略。如果重定向次数超过2次，我们返回http.ErrUseLastResponse，表示不再进行重定向，使用最后一次响应。

TLS配置

当与HTTPS服务器通信时，我们可能需要自定义TLS配置，例如忽略证书验证（不建议在生产环境中使用）或使用自定义证书。

package main

import (
    "fmt"
    "net/http"
    "crypto/tls"
)

func main() {
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr}

    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

上述代码创建了一个http.Transport，并设置其TLSClientConfig的InsecureSkipVerify为true，这样在与HTTPS服务器通信时会忽略证书验证。在生产环境中，应该使用合法的证书或进行更严格的证书验证配置。

并发HTTP请求

Go语言的并发特性使得并发发送多个HTTP请求变得非常容易。我们可以使用Go协程和通道来实现这一点。

package main

import (
    "fmt"
    "io"
    "net/http"
    "sync"
)

func fetchURL(url string, wg *sync.WaitGroup, resultChan chan string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        resultChan <- fmt.Sprintf("请求 %s 出错: %v", url, err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        resultChan <- fmt.Sprintf("读取 %s 响应体出错: %v", url, err)
        return
    }

    resultChan <- fmt.Sprintf("请求 %s 成功, 响应内容: %s", url, string(body))
}

func main() {
    urls := []string{
        "https://www.example.com",
        "https://www.google.com",
        "https://www.baidu.com",
    }

    var wg sync.WaitGroup
    resultChan := make(chan string)

    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, &wg, resultChan)
    }

    go func() {
        wg.Wait()
        close(resultChan)
    }()

    for result := range resultChan {
        fmt.Println(result)
    }
}

在这段代码中，我们定义了fetchURL函数，它在一个单独的Go协程中执行HTTP GET请求，并将结果发送到resultChan通道中。main函数中，我们为每个URL启动一个协程来并发请求，并通过sync.WaitGroup等待所有协程完成，最后从通道中读取并打印每个请求的结果。

与代理服务器一起使用

在某些网络环境中，可能需要通过代理服务器来发送HTTP请求。Go的http.Transport结构体提供了设置代理的功能。

package main

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

func main() {
    proxyURL, err := url.Parse("http://proxy.example.com:8080")
    if err != nil {
        fmt.Println("解析代理URL出错:", err)
        return
    }

    tr := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }
    client := &http.Client{Transport: tr}

    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("状态码:", resp.StatusCode)
}

这里我们首先使用url.Parse解析代理服务器的URL，然后将其设置到http.Transport的Proxy字段中，通过这个http.Transport创建的http.Client就会通过指定的代理服务器发送HTTP请求。

错误处理

在HTTP客户端编程中，错误处理非常重要。常见的错误包括网络错误、请求格式错误、服务器响应错误等。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("https://www.invalid - url.com")
    if err != nil {
        if e, ok := err.(net.Error); ok && e.Timeout() {
            fmt.Println("请求超时")
        } else {
            fmt.Println("请求出错:", err)
        }
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode >= 400 {
        fmt.Println("服务器返回错误状态码:", resp.StatusCode)
    }

    fmt.Println("状态码:", resp.StatusCode)
}

在这个例子中，我们首先检查请求过程中是否发生错误，如果发生错误，我们判断是否是超时错误。如果请求成功，我们检查响应状态码是否为400及以上，如果是，则表示服务器返回了错误状态码。通过这样细致的错误处理，可以使我们的HTTP客户端程序更加健壮。

通过上述内容，我们全面地了解了Go语言中HTTP客户端的实现，从基础的请求发送到高级的特性配置，以及并发请求、错误处理等方面，能够帮助开发者在不同场景下构建高效、稳定的HTTP客户端应用。