Wie kann ich ein Zeitlimit für http.Get () -Anfragen in Golang festlegen?

Ich mache einen URL-Abruf in Go und habe eine Liste der abzurufenden URLs. Ich sende http.Get()Anfragen an jede URL und erhalte deren Antwort.

resp,fetch_err := http.Get(url)

Wie kann ich für jede Get-Anfrage ein benutzerdefiniertes Zeitlimit festlegen? (Die Standardzeit ist sehr lang und das macht meinen Abruf sehr langsam.) Ich möchte, dass mein Abruf eine Zeitüberschreitung von ca. 40-45 Sekunden hat. Danach sollte er "Zeitüberschreitung bei Anforderung" zurückgeben und zur nächsten URL übergehen.

Wie kann ich das erreichen?

Anscheinend hat http.Client in Go 1.3 das Feld Timeout

client := http.Client{
    Timeout: 5 * time.Second,
}
client.Get(url)

Das ist der Trick für mich.

Sie müssen Ihren eigenen Client mit Ihrem eigenen Transport einrichten, der eine benutzerdefinierte Wählfunktion verwendet, die DialTimeout umschließt .

So etwas wie (völlig ungetestet ) diese :

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
    return net.DialTimeout(network, addr, timeout)
}

func main() {
    transport := http.Transport{
        Dial: dialTimeout,
    }

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

    resp, err := client.Get("http://some.url")
}

Um die Antwort von Volker zu ergänzen, können Sie Folgendes tun, wenn Sie zusätzlich zum Zeitlimit für die Verbindung auch das Lese- / Schreibzeitlimit festlegen möchten

package httpclient

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

func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, addr string) (c net.Conn, err error) {
    return func(netw, addr string) (net.Conn, error) {
        conn, err := net.DialTimeout(netw, addr, cTimeout)
        if err != nil {
            return nil, err
        }
        conn.SetDeadline(time.Now().Add(rwTimeout))
        return conn, nil
    }
}

func NewTimeoutClient(connectTimeout time.Duration, readWriteTimeout time.Duration) *http.Client {

    return &http.Client{
        Transport: &http.Transport{
            Dial: TimeoutDialer(connectTimeout, readWriteTimeout),
        },
    }
}

Dieser Code wird getestet und funktioniert in der Produktion. Die vollständige Liste der Tests finden Sie hier https://gist.github.com/dmichael/5710968

Beachten Sie, dass Sie für jede Anforderung einen neuen Client erstellen müssen, da conn.SetDeadlinedieser auf einen Punkt in der Zukunft verweisttime.Now()

Wenn Sie dies auf Anfrage tun möchten, wird die Fehlerbehandlung der Kürze halber ignoriert:

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

req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "https://google.com", nil)

resp, _ := http.DefaultClient.Do(req)

Ein schneller und schmutziger Weg:

http.DefaultTransport.(*http.Transport).ResponseHeaderTimeout = time.Second * 45

Dies mutiert den globalen Staat ohne jegliche Koordination. Möglicherweise ist es jedoch für Ihren URL-Abruf in Ordnung. Andernfalls erstellen Sie eine private Instanz von http.RoundTripper:

var myTransport http.RoundTripper = &http.Transport{
        Proxy:                 http.ProxyFromEnvironment,
        ResponseHeaderTimeout: time.Second * 45,
}

var myClient = &http.Client{Transport: myTransport}

resp, err := myClient.Get(url)
...

Nichts oben wurde getestet.

Sie können https://github.com/franela/goreq verwenden , um Zeitüberschreitungen auf einfache und einfache Weise zu behandeln.

timeout := time.Duration(5 * time.Second)
transport := &http.Transport{Proxy: http.ProxyURL(proxyUrl), ResponseHeaderTimeout:timeout}

Dies kann hilfreich sein, aber beachten Sie, dass dies ResponseHeaderTimeouterst beginnt, nachdem die Verbindung hergestellt wurde.