Comment implémenter la gestion des délais d'attente des requêtes à l'aide de http.Transport in Go ?

Comment utiliser http.Transport pour implémenter le traitement des requêtes hors délai dans Go ?

En langage Go, nous avons souvent besoin d'envoyer des requêtes HTTP pour obtenir des données ou interagir avec des API externes. Cependant, en raison de la complexité de l'environnement réseau, des délais d'attente des requêtes peuvent parfois être rencontrés. Afin d'éviter le problème de la longue attente et de l'incapacité d'obtenir une réponse à temps, nous pouvons utiliser http.Transport de Go pour implémenter le traitement des requêtes avec délai d'attente.

Dans Go, http.Transport est une structure qui se charge de gérer la réutilisation des connexions du client HTTP et la transmission des requêtes. Afin d'implémenter le traitement du délai d'attente, nous pouvons utiliser l'attribut Timeout dans http.Transport. Les étapes spécifiques sont les suivantes :

1. Introduire les packages nécessaires

Pour utiliser http.Transport et http.Client, nous devons d'abord introduire les packages pertinents.

package main

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

2. Créer un objet http.Client

Dans Go, http.Client représente un client HTTP et nous devons l'utiliser pour envoyer des requêtes. Nous pouvons obtenir un objet http.Transport en appelant la méthode Transport de http.Client et en définissant le délai d'attente.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }
}

Dans le code ci-dessus, nous définissons le ResponseHeaderTimeout sur 5 secondes. Cela signifie que si aucun en-tête de réponse n'est reçu dans les 5 secondes, la demande sera automatiquement annulée.

3. Envoyer une requête HTTP

Après avoir configuré l'objet http.Client, nous pouvons l'utiliser pour envoyer des requêtes HTTP.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://api.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }

    defer resp.Body.Close()

    // 处理响应
}

Dans le code ci-dessus, nous utilisons la méthode client.Get pour envoyer une requête GET à "https://api.example.com". Si aucune information d'en-tête de réponse n'est reçue dans les 5 secondes, la demande sera automatiquement annulée et une erreur sera renvoyée.

4. Traitement de la réponse

Après avoir reçu la réponse, nous pouvons la traiter. Voici juste un exemple simple pour lire le contenu de la réponse.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://api.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }

    defer resp.Body.Close()

    // 处理响应
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("响应内容:", string(body))
}

Ce qui précède explique comment utiliser http.Transport en langage Go pour implémenter le traitement des requêtes avec délai d'attente. En définissant la propriété Timeout de http.Transport et en utilisant http.Client pour envoyer des requêtes et recevoir des réponses, nous pouvons facilement implémenter une logique de traitement de délai d'attente. Cela peut non seulement améliorer la robustesse du programme, mais également éviter de bloquer le programme en raison de l'incapacité d'obtenir une réponse à temps en raison de longues attentes.

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!