Le délai d'expiration de la demande Golang revient

Golang est un langage de programmation efficace, rapide et concis, et donc très compétitif dans le développement Web. Cependant, les requêtes réseau de Golang peuvent entraîner des délais d'attente ou des problèmes de blocage lors de l'accès à certains sites Web, ce qui constitue un casse-tête pour les développeurs qui utilisent Golang pour effectuer des requêtes réseau.

Cet article expliquera comment implémenter la fonction de retour de délai d'attente de demande dans Golang pour aider les développeurs à résoudre ce problème.

Requête réseau de Golang

La bibliothèque standard de Golang fournit un package "net/http" pour l'envoi de requêtes HTTP/HTTPS, le traitement des réponses et d'autres opérations. Grâce à ce package, nous pouvons facilement implémenter des opérations telles que l'envoi de requêtes GET et POST. Voici des exemples de code pour les opérations associées :

// 发送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))

Dans les applications réelles, lorsque nous envoyons des requêtes HTTP, toutes les requêtes ne seront pas nécessairement envoyées dans un court laps de temps. obtenez une réponse dans le délai imparti, la demande peut expirer ou être bloquée en raison d'un retard du réseau, d'un serveur occupé, etc.

Problème de délai d'expiration de la demande

Lorsque nous envoyons une requête HTTP, si le serveur distant ne répond pas à temps, alors notre requête sera en attente. Si ce temps d'attente dépasse la patience de l'utilisateur, un délai d'attente de la demande se produira. Un délai d'expiration de la demande peut entraîner la fermeture anormale de l'application, voire un crash.

Pour ce problème, le package "net/http" de Golang ne fournit pas de mécanisme de délai d'attente de requête par défaut, nous devons donc l'implémenter nous-mêmes.

Implémentation du délai d'expiration de la demande

Dans Golang, nous pouvons utiliser le package "context" pour implémenter le mécanisme de délai d'expiration de la demande. Le package « context » fournit un mécanisme de contrôle au niveau des requêtes sur les API et les processus, ce qui peut nous aider à annuler les opérations nécessitant une attente et à empêcher les exceptions de programme causées par des délais d'attente.

Ce qui suit est un exemple de code pour implémenter le délai d'expiration de la demande :

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()

    // 处理响应
    ...
}

Dans le code ci-dessus, nous utilisons la méthode WithTimeout() dans le package "context" pour définir l'intervalle de délai d'expiration de la demande et définissons le délai d'expiration sur HttpClient, avant Envoi réel Lors de la demande, HttpClient expirera en fonction de l'heure définie.

Grâce au code ci-dessus, nous pouvons implémenter la fonction de délai d'expiration de la demande et gérer et résoudre efficacement la situation dans laquelle la demande réseau échoue ou est bloquée en raison d'un délai d'attente.

Conclusion

Cet article présente comment implémenter la fonction de retour de délai d'expiration des requêtes dans Golang En utilisant le package "context" pour le contrôle des délais d'attente, nous pouvons efficacement éviter les délais d'attente des requêtes ou les requêtes causées par des retards du réseau, des serveurs occupés, etc. . Dans le même temps, il convient de noter que dans les applications réelles, nous devons également prendre en compte des problèmes tels que les nouvelles tentatives de demande et la mise en cache des données de réponse pour améliorer l'efficacité et la fiabilité du traitement des demandes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!