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

Go HTTP客户端开发

2021-07-291.8k 阅读

Go语言HTTP客户端基础

在Go语言中，net/http包提供了强大且易用的HTTP客户端功能。通过http.Client结构体，我们可以方便地发起各种HTTP请求。

创建HTTP客户端实例

首先，我们来看如何创建一个http.Client实例。http.Client结构体包含了一些控制HTTP请求行为的字段，比如超时时间、代理设置等。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{}
    // 这里创建了一个默认的http.Client实例，它使用默认的设置
    // 例如，没有设置超时时间，会使用系统默认的网络超时设置
}

在上面的代码中，我们通过&http.Client{}创建了一个新的HTTP客户端实例client。这个客户端使用默认的传输设置，没有设置超时时间等特殊配置。

发起GET请求

发起GET请求是HTTP客户端最常见的操作之一。我们可以使用http.Get函数或者http.Client实例的Get方法来发起GET请求。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{}
    resp, err := client.Get("https://example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()
    // 处理响应内容
}

在上述代码中，我们使用client.Get方法发起了一个GET请求到https://example.com。如果请求过程中发生错误，err会不为空，我们需要对错误进行处理。获取到响应后，resp.Body包含了响应的主体内容，在使用完后需要通过defer resp.Body.Close()关闭，以防止资源泄漏。

处理响应

当我们发起请求并得到响应后，需要对响应进行处理。响应结构体http.Response包含了很多有用的信息，如状态码、响应头和响应体。

package main

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

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

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

    fmt.Println("状态码:", resp.StatusCode)
    fmt.Println("响应头:", resp.Header)
    fmt.Println("响应体:", string(body))
}

在这段代码中，我们使用ioutil.ReadAll函数读取了响应体的全部内容。然后，我们打印出了响应的状态码、响应头以及响应体。resp.StatusCode表示HTTP状态码，resp.Header是一个http.Header类型的映射，包含了响应头的各个字段。

高级HTTP客户端功能

设置超时时间

在网络请求中，设置合适的超时时间是非常重要的，它可以防止程序因为长时间等待响应而无响应。http.Client结构体有一个Timeout字段，用于设置请求的超时时间。

package main

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

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

    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
    if err != nil {
        fmt.Println("创建请求出错:", err)
        return
    }

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()
    // 处理响应
}

在这个示例中，我们首先在创建http.Client实例时设置了Timeout为5秒。然后，我们使用context.WithTimeout创建了一个上下文，设置超时时间为3秒。通过http.NewRequestWithContext创建请求时传入这个上下文。这样，请求的实际超时时间会以较短的那个时间为准，即3秒。如果在3秒内没有得到响应，请求会被取消并返回错误。

处理重定向

在HTTP请求过程中，有时服务器会返回重定向响应（状态码301、302等）。http.Client有一个CheckRedirect字段，用于控制如何处理重定向。

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            if len(via) >= 10 {
                return fmt.Errorf("过多重定向")
            }
            return nil
        },
    }

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

在上述代码中，我们自定义了CheckRedirect函数。这个函数会在每次遇到重定向时被调用，req是即将要发送的重定向请求，via是已经经过的重定向请求的切片。我们通过检查via的长度来防止过多的重定向，如果重定向次数超过10次，就返回错误。

设置代理

在实际开发中，有时需要通过代理服务器来发送HTTP请求。http.Client的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
    }

    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    client := &http.Client{
        Transport: transport,
    }

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

在这个示例中，我们首先使用url.Parse解析代理服务器的URL。然后创建一个http.Transport实例，并设置其Proxy字段为通过http.ProxyURL创建的代理函数。最后，将这个http.Transport实例设置到http.Client的Transport字段上。这样，后续通过这个http.Client发起的请求都会通过指定的代理服务器。

发起其他类型的HTTP请求

POST请求

发起POST请求时，我们需要在请求体中发送数据。在Go语言中，可以使用http.NewRequest函数创建POST请求，并设置请求体。

package main

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

func main() {
    data := []byte("key1=value1&key2=value2")
    req, err := http.NewRequest("POST", "https://example.com/api", bytes.NewBuffer(data))
    if err != nil {
        fmt.Println("创建请求出错:", err)
        return
    }
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

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

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

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

在这段代码中，我们首先定义了要发送的数据data，这里使用的是application/x-www-form-urlencoded格式的数据。然后通过http.NewRequest创建一个POST请求，将数据放入bytes.NewBuffer作为请求体。同时，设置请求头的Content-Type为application/x-www-form-urlencoded。最后通过http.Client的Do方法发送请求并处理响应。

PUT、DELETE等请求

除了GET和POST请求，Go语言的http.Client也可以方便地发起PUT、DELETE等其他类型的HTTP请求。

package main

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

func main() {
    req, err := http.NewRequest("PUT", "https://example.com/api/resource", nil)
    if err != nil {
        fmt.Println("创建请求出错:", err)
        return
    }

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

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

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

上述代码展示了如何发起PUT请求。通过http.NewRequest函数创建请求时，第一个参数指定请求方法为PUT。同样，对于DELETE请求，只需要将请求方法设置为DELETE即可。

处理HTTP请求中的认证

基本认证

基本认证是一种常见的HTTP认证方式，它在请求头中添加Authorization字段。在Go语言中，我们可以使用net/http包中的RoundTripper接口来实现基本认证。

package main

import (
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "net/http"
)

func basicAuthTransport(username, password string) http.RoundTripper {
    auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(username+":"+password))
    return &authRoundTripper{
        rt: http.DefaultTransport,
        auth: auth,
    }
}

type authRoundTripper struct {
    rt   http.RoundTripper
    auth string
}

func (a *authRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
    req.Header.Set("Authorization", a.auth)
    return a.rt.RoundTrip(req)
}

func main() {
    client := &http.Client{
        Transport: basicAuthTransport("user", "pass"),
    }

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

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

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

在这段代码中，我们定义了一个basicAuthTransport函数，它返回一个实现了http.RoundTripper接口的结构体authRoundTripper。在RoundTrip方法中，我们在请求头中添加了Authorization字段，值为经过Base64编码的用户名和密码。然后，我们将这个Transport设置到http.Client中，这样后续发起的请求都会带有基本认证信息。

OAuth认证

OAuth是一种更复杂的认证方式，常用于第三方应用授权。在Go语言中，有一些开源库可以帮助我们实现OAuth认证，比如golang.org/x/oauth2。

package main

import (
    "fmt"
    "golang.org/x/oauth2"
    "io/ioutil"
    "net/http"
)

func main() {
    oauth2Config := &oauth2.Config{
        ClientID:     "your_client_id",
        ClientSecret: "your_client_secret",
        Scopes:       []string{"scope1", "scope2"},
        Endpoint: oauth2.Endpoint{
            AuthURL:  "https://example.com/oauth/authorize",
            TokenURL: "https://example.com/oauth/token",
        },
    }

    token := &oauth2.Token{
        AccessToken: "your_access_token",
    }

    client := oauth2Config.Client(oauth2.NoContext, token)

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

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

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

在这个示例中，我们首先创建了一个oauth2.Config实例，配置了客户端ID、客户端密钥、授权范围以及认证服务器的端点。然后，我们创建了一个oauth2.Token实例，包含了获取到的访问令牌。通过oauth2Config.Client方法创建一个带有OAuth认证的http.Client实例，使用这个客户端发起请求就会包含OAuth认证信息。

处理HTTP响应中的复杂数据格式

JSON数据处理

在现代的Web开发中，JSON是最常用的数据交换格式之一。在Go语言中，encoding/json包可以方便地处理JSON数据。

package main

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

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

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

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

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

    fmt.Println("用户名:", user.Name)
    fmt.Println("年龄:", user.Age)
}

在这段代码中，我们定义了一个User结构体，它的字段标签json:"name"和json:"age"用于指定JSON数据中的字段名。通过json.Unmarshal函数将响应体中的JSON数据解析到User结构体实例中，然后我们就可以方便地访问解析后的数据。

XML数据处理

虽然JSON更为流行，但在一些场景下，仍然会遇到XML数据。Go语言的encoding/xml包可以帮助我们处理XML数据。

package main

import (
    "encoding/xml"
    "fmt"
    "io/ioutil"
    "net/http"
)

type Book struct {
    XMLName xml.Name `xml:"book"`
    Title   string   `xml:"title"`
    Author  string   `xml:"author"`
}

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

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

    var book Book
    err = xml.Unmarshal(body, &book)
    if err != nil {
        fmt.Println("解析XML出错:", err)
        return
    }

    fmt.Println("书名:", book.Title)
    fmt.Println("作者:", book.Author)
}

在这个示例中，我们定义了一个Book结构体，通过xml.Name指定了XML根元素的名称，字段标签xml:"title"和xml:"author"指定了XML元素的名称。使用xml.Unmarshal函数将XML数据解析到Book结构体实例中，从而可以方便地获取XML中的数据。

优化HTTP客户端性能

连接池复用

http.Transport默认实现了连接池功能，它可以复用已建立的TCP连接，减少连接建立和关闭的开销。

package main

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

func main() {
    transport := &http.Transport{
        MaxIdleConns:       10,
        MaxIdleConnsPerHost: 5,
        IdleConnTimeout:    30 * time.Second,
    }

    client := &http.Client{
        Transport: transport,
    }

    // 多次发起请求，连接会被复用
    for i := 0; i < 10; i++ {
        resp, err := client.Get("https://example.com")
        if err != nil {
            fmt.Println("请求出错:", err)
            continue
        }
        defer resp.Body.Close()
    }
}

在上述代码中，我们通过http.Transport的MaxIdleConns设置最大空闲连接数为10，MaxIdleConnsPerHost设置每个主机的最大空闲连接数为5，IdleConnTimeout设置空闲连接的超时时间为30秒。这样，在多次发起请求时，连接会被复用，提高了性能。

并发请求优化

在需要同时发起多个HTTP请求时，合理的并发控制可以提高效率。

package main

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

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

func main() {
    urls := []string{
        "https://example.com",
        "https://example.org",
        "https://example.net",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls))

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

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

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

在这段代码中，我们定义了一个fetchURL函数，用于发起HTTP请求。通过sync.WaitGroup来等待所有的并发请求完成，通过chan来收集每个请求的结果。这样可以有效地控制并发请求，并处理每个请求的结果。

总结

通过以上内容，我们深入了解了Go语言HTTP客户端开发的各个方面，从基础的请求发起、响应处理，到高级的功能如超时设置、代理配置、认证处理，以及复杂数据格式的处理和性能优化。Go语言的net/http包提供了强大且灵活的功能，使得我们可以轻松地构建高效、可靠的HTTP客户端应用。在实际开发中，根据具体的需求合理地运用这些知识，可以提升应用的质量和性能。