délai d'expiration de la demande Golang

Lors du développement d'applications Web, il est souvent nécessaire de faire des requêtes réseau pour obtenir des données auprès de services distants. Cependant, les requêtes réseau peuvent parfois être affectées par divers problèmes, tels qu'un réseau lent, des pannes de réseau ou une réponse lente du serveur cible. Dans ce cas, nous avons besoin d’un contrôle et d’une gestion plus précis de la demande afin qu’elle puisse être arrêtée et retraitée ou notifiée d’échec si nécessaire.

Go est un langage de programmation puissant qui fournit de nombreuses fonctionnalités réseau intégrées pour la programmation réseau. La bibliothèque standard de Go fournit le package net/http, qui fournit de nombreuses fonctionnalités pour le développement Web, notamment la fonctionnalité de requête client HTTP. Dans cet article, nous expliquerons comment gérer les délais d'attente avec les requêtes des clients HTTP dans Go.

Le traitement du délai d'attente signifie que si une demande ne peut pas recevoir de réponse dans un délai défini, elle sera forcée de s'arrêter et une erreur sera renvoyée. Dans la plupart des cas, si une requête prend trop de temps, cela peut indiquer un problème avec le service cible ou un échec de connexion réseau. La gestion des délais d'attente peut donc rendre les requêtes réseau plus sûres et plus stables.

Il est très simple d’implémenter la gestion des délais d’attente des demandes dans Go. Il nous suffit d'ajouter un délai d'attente lors du lancement d'une requête et de capturer les erreurs associées pour implémenter facilement la fonction de délai d'attente de la requête. Ci-dessous, nous expliquerons comment utiliser Go pour implémenter le traitement du délai d'attente pour certaines requêtes client HTTP courantes.

1. Traitement du délai d'expiration de la demande GET

Dans Go, nous pouvons utiliser la méthode http.Get() pour lancer une requête GET. Lors d'une demande, nous pouvons définir un contexte et définir un délai d'attente. Si aucune réponse n'est reçue dans le délai d'attente, le traitement du délai d'attente sera déclenché. Voici un exemple :

package main

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

func main() {
    client := http.Client{
        Timeout: time.Duration(1) * time.Second,
    }

    ctx, cancel := context.WithTimeout(context.Background(), time.Duration(5)*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://example.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

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

    fmt.Println("response Status:", res.Status)
}

Dans cet exemple, nous créons d'abord un objet http.Client et définissons la propriété Timeout sur 1 seconde, ce qui signifie que s'il n'y a pas de réponse dans la seconde, cela sera considéré comme un délai d'attente. Nous créons ensuite un contexte à l'aide du package de contexte et fixons le délai à 5 secondes. Ensuite, nous créons une requête GET à l'aide de la méthode http.NewRequestWithContext() et transmettons le contexte à la méthode. Enfin, nous effectuons la requête en utilisant l'objet http.Client. Si la demande expire ou si d'autres erreurs se produisent, des messages d'erreur appropriés seront générés.

2. Traitement du délai d'attente des requêtes POST

Différentes des requêtes GET, les requêtes POST doivent transmettre des données dans le corps de la requête. Dans Go, nous pouvons utiliser la méthode http.Post() pour lancer une requête POST. De même, nous pouvons définir un contexte et un délai d'attente pour garantir que la demande recevra une réponse dans le délai spécifié. Voici un exemple :

package main

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

func main() {
    client := http.Client{
        Timeout: time.Duration(1) * time.Second,
    }

    ctx, cancel := context.WithTimeout(context.Background(), time.Duration(5)*time.Second)
    defer cancel()

    requestBody := []byte(`{"id":1,"name":"John"}`)

    req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://example.com", bytes.NewBuffer(requestBody))
    if err != nil {
        fmt.Println(err)
        return
    }

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

    fmt.Println("response Status:", res.Status)
}

Dans cet exemple, nous créons une requête POST avec le corps de la requête sous forme de données au format JSON. Nous utilisons le package bytes pour convertir les données JSON en un flux d'octets et les transmettons comme corps de requête à la méthode http.NewRequestWithContext(). Le reste est traité de la même manière qu’une requête GET.

3. Délai d'expiration personnalisé côté client

Dans les applications réelles, nous devons définir le délai d'attente en fonction de différentes situations de demande. Par exemple, certaines API ont des temps de réponse très rapides et nous devons définir un délai d'expiration plus court, tandis que certaines API ont des temps de réponse plus longs et nous devons définir un délai d'expiration plus long. Dans Go, nous pouvons utiliser le package de contexte et le package de temps pour personnaliser le délai d'expiration. Voici un exemple :

package main

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

func main() {
    client := http.Client{}

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://example.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 自定义超时时间
    timeout := time.Duration(3) * time.Second

    // 发起请求
    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("response Status:", res.Status)
}

Dans cet exemple, nous créons d'abord un objet http.Client et ne définissons pas la propriété Timeout. Ensuite, nous créons un contexte à l'aide du package de contexte et définissons le délai d'attente sur 5 secondes. Nous créons ensuite une requête GET à l'aide de la méthode http.NewRequestWithContext() et transmettons le contexte à la méthode. Ensuite, nous personnalisons un délai d'attente de 3 secondes et utilisons l'objet http.Client pour lancer la requête. Si la requête expire, un message d'erreur sera renvoyé après 3 secondes et l'heure dans le contexte ne sera pas attendue.

Résumé

Dans Go, le traitement du délai d'attente pour les requêtes réseau est très simple. Il vous suffit de définir un contexte et de définir un délai d'attente lors de la demande. Nous pouvons personnaliser le délai d'attente si nécessaire pour garantir que les demandes sont traitées dans un délai raisonnable. Le traitement du délai d'attente des demandes est une partie très importante de la programmation réseau, qui peut garantir la fiabilité et la stabilité du système et éviter les attentes inutiles et le gaspillage de ressources. Dans le développement réel, nous devons utiliser de manière flexible le traitement des délais d'attente et d'autres fonctions réseau en fonction de différents scénarios et besoins commerciaux pour améliorer les performances et l'efficacité du système.

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!