Comment implémenter un mécanisme de nouvelle tentative de demande pour un hôte spécifique à l'aide de Go et http.Transport ?

Comment implémenter un mécanisme de nouvelle tentative de requête pour un hôte spécifique à l'aide de Go et http.Transport ?

Dans les systèmes distribués modernes, les requêtes réseau sont inévitables. Parfois, les requêtes que nous lançons peuvent échouer pour diverses raisons, telles que l'instabilité du réseau, l'indisponibilité du serveur, etc. Afin de garantir la fiabilité de la requête, nous espérons pouvoir réessayer lorsque la requête échoue. Cet article explique comment utiliser le langage Go et http.Transport pour implémenter un mécanisme de nouvelle tentative de demande pour un hôte spécifique.

Le langage Go fournit le package http, qui permet d'envoyer et de recevoir facilement des requêtes réseau. La structure http.Transport est utilisée pour gérer et contrôler les opérations telles que la connexion, la redirection et le proxy des clients HTTP. Nous pouvons définir le mécanisme de nouvelle tentative dans la configuration de cette structure. Nous utiliserons ensuite un exemple spécifique pour montrer comment implémenter une nouvelle tentative de demande.

Tout d'abord, nous devons importer les bibliothèques nécessaires :

import (
    "net/http"
    "time"
)

Ensuite, nous créons une structure de transport personnalisée :

type CustomTransport struct {
    Transport http.Transport
    RetryCount int // 重试次数
}

func (ct *CustomTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    var resp *http.Response
    var err error

    for i := 0; i <= ct.RetryCount; i++ {
        resp, err = ct.Transport.RoundTrip(req)
        if err == nil || i == ct.RetryCount {
            break
        }
        time.Sleep(time.Second) // 等待1秒后进行重试
    }

    return resp, err
}

Dans CustomTransport, nous remplaçons la méthode RoundTrip pour une logique de nouvelle tentative de demande personnalisée. Après l'échec de chaque requête, nous attendrons un certain temps avant de réessayer, ici nous le fixons à 1 seconde. Notez que nous avons ajouté ici un contrôle du nombre maximum de tentatives pour éviter des tentatives infinies.

Ensuite, nous utilisons le transport personnalisé pour créer l'objet http.Client et envoyer la requête réseau :

func main() {
    retryCount := 3 // 重试次数

    transport := http.Transport{
        MaxIdleConns:    10,
        IdleConnTimeout: 30 * time.Second,
    }

    client := http.Client{
        Transport: &CustomTransport{
            Transport: transport,
            RetryCount: retryCount,
        },
    }

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

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

    defer resp.Body.Close()

    // 处理响应结果
    // ...
}

Dans le code ci-dessus, nous créons une requête GET via la méthode http.NewRequest et définissons l'URL demandée sur http : / /exemple.com. Ensuite, envoyez la demande via la méthode client.Do et obtenez la réponse. Avant cela, nous avons transmis le transport personnalisé dans http.Client pour implémenter le mécanisme de nouvelle tentative de demande pour un hôte spécifique.

À ce stade, nous avons complété l'exemple d'utilisation de Go et http.Transport pour implémenter un mécanisme de nouvelle tentative de demande pour un hôte spécifique. En personnalisant la structure de transport, nous pouvons contrôler de manière flexible le nombre de tentatives, les intervalles entre les tentatives et d'autres paramètres liés aux requêtes. Dans le développement réel, nous pouvons effectuer des personnalisations plus détaillées en fonction de nos propres besoins pour obtenir des demandes réseau plus fiables.

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!