Golang-Anfrage-Timeout kehrt zurück

Golang ist eine Programmiersprache, die effizient, schnell und prägnant ist und daher eine starke Wettbewerbsfähigkeit in der Webentwicklung aufweist. Allerdings können die Netzwerkanfragen von Golang beim Zugriff auf bestimmte Websites zu Anforderungszeitüberschreitungen oder Blockierungsproblemen führen, was für Entwickler, die Golang zum Stellen von Netzwerkanfragen verwenden, Kopfzerbrechen bereitet.

In diesem Artikel wird erläutert, wie die Funktion zur Rückgabe des Anforderungszeitlimits in Golang implementiert wird, um Entwicklern bei der Lösung dieses Problems zu helfen.

Golangs Netzwerkanfrage

Golangs Standardbibliothek bietet ein „net/http“-Paket zum Senden von HTTP/HTTPS-Anfragen, zur Verarbeitung von Antworten und für andere Vorgänge. Mit diesem Paket können wir problemlos Vorgänge wie das Senden von GET- und POST-Anfragen implementieren:

// 发送GET请求
resp, err := http.Get("http://www.baidu.com")
if err != nil {
    // 处理错误
    return err
}
defer resp.Body.Close()

// 读取响应结果
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    // 处理错误
    return err
}

// 打印结果
fmt.Println(string(body))

// 发送POST请求
resp, err := http.PostForm("http://example.com/form",
url.Values{"key": {"Value"}, "id": {"123"}})
if err != nil {
    // 处理错误
    return err
}
defer resp.Body.Close()

// 读取响应结果
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    // 处理错误
    return err
}

// 打印结果
fmt.Println(string(body))

Wenn wir in tatsächlichen Anwendungen HTTP-Anfragen senden, ist dies nicht unbedingt jede Anfrage Die Anfrage wird möglicherweise innerhalb kurzer Zeit beantwortet oder aufgrund von Netzwerkverzögerungen, ausgelasteten Servern usw. blockiert.

Zeitüberschreitungsproblem bei der Anfrage

Wenn wir eine HTTP-Anfrage senden und der Remote-Server nicht rechtzeitig antwortet, befindet sich unsere Anfrage im Wartezustand. Wenn diese Wartezeit die Geduld des Benutzers überschreitet, kommt es zu einem Anforderungszeitlimit. Eine Zeitüberschreitung der Anforderung kann dazu führen, dass die Anwendung abnormal beendet wird oder sogar abstürzt.

In Bezug auf dieses Problem bietet das Paket „net/http“ in Golang keinen Standardmechanismus für das Anforderungszeitlimit, sodass wir ihn selbst implementieren müssen.

Request-Timeout implementieren

In Golang können wir das „context“-Paket verwenden, um den Request-Timeout-Mechanismus zu implementieren. Das „context“-Paket bietet einen Kontrollmechanismus auf Anforderungsebene über APIs und Prozesse hinweg, der uns dabei helfen kann, Vorgänge abzubrechen, die Wartezeiten erfordern, und Programmausnahmen zu verhindern, die durch Wartezeitüberschreitungen verursacht werden.

Das Folgende ist ein Codebeispiel zum Implementieren des Anforderungszeitlimits:

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

func httpClient() (*http.Client, error) {
    // 创建一个新的httpClient
    httpClient := http.DefaultClient

    // 设置超时时间
    timeout := time.Duration(5 * time.Second)
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    // 设置httpClient的Transport属性
    httpClient.Timeout = timeout
    httpClient.Transport = &http.Transport{
        Proxy: http.ProxyFromEnvironment,
    }

    return httpClient, nil
}

func main() {
    httpClient, err := httpClient()
    if err != nil {
        // 处理错误
        return
    }
    // 将httpClient作为参数传入http.NewRequest()方法
    // httpClient将遵循我们设置的超时时间
    req, err := http.NewRequest("GET", "https://www.baidu.com",
    strings.NewReader(""))
    if err != nil {
        // 处理错误
        return
    }

    x, err := httpClient.Do(req)
    if err != nil {
        // 处理错误
        return
    }
    defer x.Body.Close()

    // 处理响应
    ...
}

Im obigen Code verwenden wir die WithTimeout()-Methode im „context“-Paket, um die Anforderung festzulegen Timeout-Intervall, und legen Sie die Timeout-Zeit auf HttpClient fest. Beim tatsächlichen Senden der Anfrage trifft HttpClient eine Timeout-Beurteilung entsprechend der eingestellten Zeit.

Durch den obigen Code können wir die Anforderungszeitüberschreitungsfunktion implementieren und die Situation, in der die Netzwerkanforderung aufgrund einer Zeitüberschreitung fehlschlägt oder blockiert wird, effektiv bewältigen und lösen.

Fazit

In diesem Artikel wird erläutert, wie die Funktion zur Rückgabe von Anforderungs-Timeouts in Golang implementiert wird. Durch die Verwendung des Pakets „context“ zur Timeout-Kontrolle können wir unnötige Fehler effektiv vermeiden. Anforderungszeitüberschreitung oder Blockierungsprobleme aufgrund von Netzwerkverzögerung, ausgelastetem Server usw. Gleichzeitig ist zu beachten, dass wir in tatsächlichen Anwendungen auch Probleme wie die Wiederholung von Anforderungen und das Zwischenspeichern von Antwortdaten berücksichtigen müssen, um die Effizienz und Zuverlässigkeit der Anforderungsverarbeitung zu verbessern.

Das obige ist der detaillierte Inhalt vonGolang-Anfrage-Timeout kehrt zurück. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!