Demander des paramètres de délai d'attente et les meilleures pratiques pour http.Transport en langage Go

Paramètres de délai d'expiration des demandes et meilleures pratiques pour http.Transport en langage Go

En langage Go, http.Transport est une importante bibliothèque de requêtes réseau. Il fournit une série de méthodes et d'options pour définir le délai d'expiration des requêtes afin d'aider les développeurs à mieux contrôler le temps d'exécution des requêtes et à éviter le gaspillage de ressources. Cet article explique comment définir les délais d'expiration des requêtes et donne un exemple de code pour les meilleures pratiques.

Méthode de définition du délai d'attente

Dans http.Transport, vous pouvez utiliser les deux méthodes suivantes pour définir le délai d'expiration de la requête :

1. Utilisez le champ Timeout

Timeout est un champ de http.Transport, de type time .Durée. En définissant Timeout, vous pouvez spécifier le délai d'expiration pour l'ensemble de la demande, y compris tous les processus tels que l'établissement d'une connexion, l'envoi d'une demande et la réception d'une réponse. Un exemple est le suivant :

package main

import (
    "net/http"
    "time"
)

func main() {
    transport := &http.Transport{
        // 设置请求超时时间为5秒
        Timeout: 5 * time.Second,
    }

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

    resp, err := client.Get("http://example.com")
    if err != nil {
        // 处理错误
        return
    }

    // 处理响应
    defer resp.Body.Close()
}

2. Utilisation du champ Deadline

Deadline est un champ de http.Request de type time.Time. En définissant Deadline, vous pouvez définir des délais d'attente indépendants pour les demandes individuelles. Les exemples sont les suivants :

package main

import (
    "net/http"
    "time"
)

func main() {
    req, err := http.NewRequest("GET", "http://example.com", nil)
    if err != nil {
        // 处理错误
        return
    }

    // 设置请求超时时间为5秒
    req.Header.Set("Timeout", "5s")
    req = req.WithContext(http.TimeoutContext(req.Context(), 5*time.Second))

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // 处理错误
        return
    }

    // 处理响应
    defer resp.Body.Close()
}

Bonnes pratiques

Dans le développement réel, nous devons définir le délai d'expiration de la demande en fonction de scénarios et de besoins spécifiques. Voici un exemple de code pour quelques bonnes pratiques :

1. Définir un délai d'expiration global par défaut

Vous pouvez définir un délai d'expiration global par défaut pour toutes les requêtes dans votre application. Cela améliore la lisibilité et la maintenabilité du code. Les exemples sont les suivants :

package main

import (
    "net/http"
    "time"
)

var client = &http.Client{
    Transport: &http.Transport{
        // 设置全局默认超时时间为10秒
        Timeout: 10 * time.Second,
    },
}

func main() {
    resp, err := client.Get("http://example.com")
    if err != nil {
        // 处理错误
        return
    }

    // 处理响应
    defer resp.Body.Close()
}

2. Définir différents délais d'attente

Pour différentes demandes, vous pouvez définir différents délais d'attente. Par exemple, pour différentes interfaces API, le délai d'attente peut être défini en fonction des caractéristiques de l'interface et des exigences de temps de réponse. Un exemple est le suivant :

package main

import (
    "net/http"
    "time"
)

func main() {
    apiA := &http.Client{
        Transport: &http.Transport{
            // 设置API A的超时时间为3秒
            Timeout: 3 * time.Second,
        },
    }

    apiB := &http.Client{
        Transport: &http.Transport{
            // 设置API B的超时时间为5秒
            Timeout: 5 * time.Second,
        },
    }

    respA, err := apiA.Get("http://apiA.example.com")
    if err != nil {
        // 处理错误
        return
    }

    respB, err := apiB.Get("http://apiB.example.com")
    if err != nil {
        // 处理错误
        return
    }

    // 处理响应
    defer respA.Body.Close()
    defer respB.Body.Close()
}

Résumé

Cet article explique comment définir le délai d'expiration de la demande de http.Transport en langage Go et donne quelques exemples de codes de bonnes pratiques. Dans le développement réel, définir de manière flexible le délai d'expiration des requêtes en fonction de besoins et de scénarios spécifiques peut améliorer les performances et la fiabilité de l'application.

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!