在Golang中重用HTTP连接

我目前正在努力寻找一种在Golang中进行HTTP发布时重用连接的方法。

我已经创建了一个运输和客户，如下所示：

// Create a new transport and HTTP client
tr := &http.Transport{}
client := &http.Client{Transport: tr}

然后，我将此客户端指针传递到goroutine中，该例程将多个帖子发布到同一个端点，如下所示：

r, err := client.Post(url, "application/json", post)

从netstat来看，这似乎导致每个帖子都有一个新的连接，从而导致大量并发连接被打开。

在这种情况下，重用连接的正确方法是什么？

确保您已阅读，直到响应完成并致电Close()。

例如

res, _ := client.Do(req)
io.Copy(ioutil.Discard, res.Body)
res.Body.Close()

再次...为了确保http.Client连接重用，请确保：

• 读取直到响应完成（即ioutil.ReadAll(resp.Body)）
• 呼叫 Body.Close()

如果有人仍在寻找答案，这就是我的做法。

package main

import (
    "bytes"
    "io/ioutil"
    "log"
    "net/http"
    "time"
)

var httpClient *http.Client

const (
    MaxIdleConnections int = 20
    RequestTimeout     int = 5
)

func init() {
    httpClient = createHTTPClient()
}

// createHTTPClient for connection re-use
func createHTTPClient() *http.Client {
    client := &http.Client{
        Transport: &http.Transport{
            MaxIdleConnsPerHost: MaxIdleConnections,
        },
        Timeout: time.Duration(RequestTimeout) * time.Second,
    }

    return client
}

func main() {
    endPoint := "https://localhost:8080/doSomething"

    req, err := http.NewRequest("POST", endPoint, bytes.NewBuffer([]byte("Post this data")))
    if err != nil {
        log.Fatalf("Error Occured. %+v", err)
    }
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    response, err := httpClient.Do(req)
    if err != nil && response == nil {
        log.Fatalf("Error sending request to API endpoint. %+v", err)
    }

    // Close the connection to reuse it
    defer response.Body.Close()

    // Let's check if the work actually is done
    // We have seen inconsistencies even when we get 200 OK response
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatalf("Couldn't parse response body. %+v", err)
    }

    log.Println("Response Body:", string(body))    
}

前往游乐场：http : //play.golang.org/p/oliqHLmzSX

总而言之，我正在创建一个不同的方法来创建HTTP客户端，并将其分配给全局变量，然后使用它进行请求。注意

defer response.Body.Close() 

这将关闭连接并使其准备好再次使用。

希望这会帮助某人。

编辑：对于为每个请求构造运输和客户的人员，这更是一个注释。

Edit2：已更改为godoc的链接。

Transport是保留连接以供重用的结构；请参阅https://godoc.org/net/http#Transport（“默认情况下，传输会缓存连接以供将来重用。”）

因此，如果您为每个请求创建一个新的传输，它将每次都创建新的连接。在这种情况下，解决方案是在客户端之间共享一个传输实例。

IIRC，默认客户端会重用连接。您是否正在关闭响应？

读取完后，呼叫者应关闭res.Body。如果未关闭resp.Body，则客户端的基础RoundTripper（通常是Transport）可能无法将与服务器的持久TCP连接重新用于后续的“保持活动”请求。

关于身体

// It is the caller's responsibility to
// close Body. The default HTTP client's Transport may not
// reuse HTTP/1.x "keep-alive" TCP connections if the Body is
// not read to completion and closed.

因此，如果要重用TCP连接，则每次读取完成后必须关闭Body。建议使用函数ReadBody（io.ReadCloser）。

package main

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

func main() {
    req, err := http.NewRequest(http.MethodGet, "https://github.com", nil)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    client := &http.Client{}
    i := 0
    for {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err.Error())
            return
        }
        _, _ = readBody(resp.Body)
        fmt.Println("done ", i)
        time.Sleep(5 * time.Second)
    }
}

func readBody(readCloser io.ReadCloser) ([]byte, error) {
    defer readCloser.Close()
    body, err := ioutil.ReadAll(readCloser)
    if err != nil {
        return nil, err
    }
    return body, nil
}

另一种方法init()是使用单例方法获取http客户端。通过使用sync.Once您可以确保所有请求仅使用一个实例。

var (
    once              sync.Once
    netClient         *http.Client
)

func newNetClient() *http.Client {
    once.Do(func() {
        var netTransport = &http.Transport{
            Dial: (&net.Dialer{
                Timeout: 2 * time.Second,
            }).Dial,
            TLSHandshakeTimeout: 2 * time.Second,
        }
        netClient = &http.Client{
            Timeout:   time.Second * 2,
            Transport: netTransport,
        }
    })

    return netClient
}

func yourFunc(){
    URL := "local.dev"
    req, err := http.NewRequest("POST", URL, nil)
    response, err := newNetClient().Do(req)
    // ...
}

这里缺少的是“ goroutine”东西。传输具有其自己的连接池，默认情况下，该池中的每个连接都将被重用（如果主体已完全读取并关闭），但是如果有多个goroutine正在发送请求，则将创建新的连接（该池中的所有连接均处于繁忙状态，并将创建新的连接） ）。为了解决这个问题，您将需要限制每个主机的最大连接数：Transport.MaxConnsPerHost（https://golang.org/src/net/http/transport.go#L205）。

可能您也想设置IdleConnTimeout和/或ResponseHeaderTimeout。

https://golang.org/src/net/http/transport.go#L196

您应该MaxConnsPerHost明确设置为http.Client。Transport确实重用了TCP连接，但是您应该限制MaxConnsPerHost（默认0表示没有限制）。

func init() {
    // singleton http.Client
    httpClient = createHTTPClient()
}

// createHTTPClient for connection re-use
func createHTTPClient() *http.Client {
    client := &http.Client{
        Transport: &http.Transport{
            MaxConnsPerHost:     1,
            // other option field
        },
        Timeout: time.Duration(RequestTimeout) * time.Second,
    }

    return client
}

有两种可能的方法：

1. 使用一个库，该库在内部重用和管理与每个请求关联的文件描述符。Http Client在内部执行相同的操作，但是您可以控制要打开的并发连接数以及如何管理资源。如果您有兴趣，请查看netpoll实现，该实现在内部使用epoll / kqueue对其进行管理。

2. 一个简单的方法是，代替池化网络连接，为您的goroutine创建一个工作池。这将是一个简单且更好的解决方案，不会妨碍您当前的代码库，并且需要进行一些小的更改。

假设您在收到请求后需要发出n个POST请求。

您可以使用渠道来实现这一点。

或者，您可以简单地使用第三方库。
像：https : //github.com/ivpusic/grpool