délai d'expiration de la requête http golang

Lors de l'écriture d'applications HTTP dans Golang, en raison de l'instabilité de l'environnement réseau, nous pouvons rencontrer des problèmes de délai d'attente des requêtes HTTP.

Cet article explique comment définir le délai d'expiration des requêtes HTTP dans Golang pour éviter le blocage et l'attente infinie.

Qu'est-ce que le délai d'attente d'une requête HTTP ? Cette situation se produit généralement en cas de retard du réseau, de charge élevée, de ressources serveur insuffisantes, etc.

Pour les applications HTTP dans Golang, lorsqu'il n'y a pas de réponse ou une requête avec un temps de réponse long, afin d'éviter que l'application ne se bloque et n'attende indéfiniment, nous devons définir le délai d'expiration de la requête HTTP.

Pourquoi devez-vous définir le délai d'attente

Dans une application Golang, chaque requête HTTP est une goroutine, qui enverra la requête sur le réseau et attendra la réponse. Si le délai d'expiration de la requête n'est pas défini, le programme peut se bloquer et entrer dans une boucle infinie en attendant une réponse, augmentant ainsi la charge sur le serveur et réduisant les performances.

De plus, s'il y a des utilisateurs malveillants ou des attaquants dans l'application, ils peuvent envoyer de fausses requêtes pour faire attendre longtemps l'application une réponse, épuisant ainsi les ressources du serveur.

Par conséquent, définir le délai d'expiration de la requête HTTP peut garantir que trop de temps et de ressources ne seront pas gaspillés avant la réception de la réponse, et empêcher l'application d'être attaquée et de manquer de ressources.

Définir le délai d'expiration des requêtes HTTP dans Golang

Dans Golang, nous pouvons utiliser la bibliothèque net/http pour envoyer des requêtes HTTP et définir le délai d'expiration. Le type Client défini dans cette bibliothèque possède une propriété Timeout qui vous permet de définir un délai d'attente.

Voici un exemple de code :

package main

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

func main() {
    client := http.Client{
        Timeout: time.Second * 5, // 设置超时时间为5秒
    }

    req, err := http.NewRequest(http.MethodGet, "https://www.example.com", nil)
    if err != nil {
        panic(err)
    }

    res, err := client.Do(req)
    if err != nil {
        panic(err)
    }

    fmt.Println(res)
}

Dans cet exemple de code, nous créons un client HTTP et définissons le délai d'attente à 5 secondes. Nous envoyons ensuite une requête GET à https://www.example.com et attendons la réponse. Si la demande expire ou si la réponse prend trop de temps, elle se terminera dans les 5 secondes.

Comment gérer les erreurs de délai d'attente

Dans l'exemple de code ci-dessus, nous utilisons la fonction de panique pour gérer les erreurs de délai d'expiration des requêtes HTTP. Cependant, dans les applications réelles, des méthodes plus fiables doivent être utilisées pour gérer les erreurs de délai d'attente.

Ce qui suit est une méthode plus fiable : ajoutez un contexte à la requête et utilisez des instructions select pour gérer les délais d'attente et les réponses normales :

package main

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

func main() {
    client := http.Client{
        Timeout: time.Second * 5, // 设置超时时间为5秒
    }

    req, err := http.NewRequest(http.MethodGet, "https://www.example.com", nil)
    if err != nil {
        panic(err)
    }

    ctx, cancel := context.WithTimeout(req.Context(), time.Second*5)
    defer cancel() // 在函数退出时取消Context

    req = req.WithContext(ctx) // 使用带有超时的Context创建新请求

    resp, err := client.Do(req)
    if err != nil {
        select {
        case <-ctx.Done(): // 超时错误
            fmt.Println("Request timed out")
        default: // 其他错误
            panic(err)
        }
    }

    defer resp.Body.Close()
    fmt.Println(resp.StatusCode)
}

Dans cet exemple de code, nous créons Create un contexte et utilisez la fonction WithTimeout pour définir le délai d'attente. Ensuite, nous créons une nouvelle requête en utilisant un contexte avec un délai d'attente et envoyons cette requête.

Si la demande expire ou si d'autres erreurs se produisent, différentes méthodes de traitement seront adoptées en fonction des différents types d'erreurs. Cela nous permet d'avoir plus de contrôle sur l'application et de gérer les situations d'erreur avec élégance.

Résumé

Lors de l'écriture d'applications HTTP dans Golang, afin d'éviter le blocage et l'attente infinie, il est très important de définir le délai d'expiration de la requête HTTP. Nous pouvons définir le délai d'attente en utilisant le type Client de la bibliothèque net/http. Et utilisez les instructions Context et select pour gérer les erreurs de délai d'attente et autres erreurs.

Lors de l'écriture d'applications stables et performantes, vous devez définir un délai d'attente approprié en fonction de la situation réelle. Cela garantira que l’application peut toujours fonctionner correctement dans des environnements non contrôlés.

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!