Bonnes pratiques pour la gestion des délais d'attente en langage Go http.Transport

Bonnes pratiques pour la gestion des délais d'attente en langage Go http.Transport

Introduction :
Lorsque vous utilisez le langage Go pour effectuer des requêtes réseau, il est très important de définir des délais d'attente raisonnablement pour éviter le blocage des requêtes et le gaspillage de ressources. Cet article présentera les meilleures pratiques d'utilisation de http.Transport pour la gestion des délais d'attente en langage Go et fournira un exemple de code pour référence.

1. Définir le délai d'expiration :
   Avant d'envoyer une demande à l'aide de http.Transport, nous pouvons utiliser certaines méthodes pour définir le délai d'expiration de la demande. Par exemple, nous pouvons utiliser le champ Timeout de la structure http.Client pour définir le délai d'attente pour l'ensemble de la requête, par exemple : http.Client结构体的Timeout字段来设置整个请求的超时时间，例如：

   client := &http.Client{
    Timeout: time.Second * 10, // 设置超时时间为10秒
   }

   上述代码中，Timeout字段表示整个请求的超时时间为10秒，当请求的处理时间超过10秒时，该请求将会返回一个net.DialTimeout错误。

此外，我们还可以在使用http.Transport发送请求之前，使用http.Request的Timeout字段来设置单个请求的超时时间。例如：

req, err := http.NewRequest("GET", "http://example.com", nil)
if err != nil {
    log.Fatal(err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "MyClient/1.0")
req.Timeout = time.Second * 5 // 设置单个请求的超时时间为5秒

resp, err := client.Do(req)
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal(err)
}

fmt.Println(string(body))

上述代码中，我们通过req.Timeout将单个请求的超时时间设置为5秒，当请求的处理时间超过5秒时，该请求将会返回一个net.DialTimeout错误。

2. 超时处理：
   当请求发生超时时，我们应该合理地处理这个错误。一种常见的方式是使用context包来控制请求的超时。我们可以创建一个带有超时时间的context.Context，并将其传递给请求的http.Request。例如：

   ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
   defer cancel()
   
   req, err := http.NewRequestWithContext(ctx, "GET", "http://example.com", nil)
   if err != nil {
    log.Fatal(err)
   }

   上述代码中，我们通过context.WithTimeout创建了一个带有10秒超时时间的context.Context，并使用http.NewRequestWithContext将该Context传递给了请求。

在发送请求时，我们可以使用context.Context来监控超时事件。例如：

resp, err := client.Do(req.WithContext(ctx))
if err != nil {
   if err == context.DeadlineExceeded {
       log.Println("请求超时")
       return
   }
   log.Fatal(err)
}
defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal(err)
}

fmt.Println(string(body))

上述代码中，当请求超时发生时，我们会通过判断错误类型是否为context.DeadlineExceededrrreee

Dans le code ci-dessus, Timeout indique que le délai d'expiration de la requête entière est de 10 secondes. Lorsque le temps de traitement de la requête dépasse 10 secondes, la requête renverra une erreur net.DialTimeout.

De plus, nous pouvons également utiliser le champ Timeout de http.Request avant d'envoyer la requête en utilisant http.Transport Définissez le délai d'expiration pour une seule demande. Par exemple :

rrreee

Dans le code ci-dessus, nous définissons le délai d'attente d'une seule requête à 5 secondes via req.Timeout. Lorsque le temps de traitement de la requête dépasse 5 secondes, la requête renverra un. net.DialTimeoutErreur.

2. Gestion du délai d'attente :
3. Lorsqu'une requête expire, nous devons gérer cette erreur de manière raisonnable. Une méthode courante consiste à utiliser le package context pour contrôler les délais d'attente des requêtes. Nous pouvons créer un context.Context avec un délai d'attente et le transmettre au http.Request de la requête. Par exemple :
rrreee
4. Dans le code ci-dessus, nous créons un context.Context avec un délai d'attente de 10 secondes via context.WithTimeout et utilisons http.NewRequestWithContext Le <code>Context est passé à la requête.

Lors de l'envoi d'une demande, nous pouvons utiliser context.Context pour surveiller les événements de délai d'attente. Par exemple : rrreee🎜Dans le code ci-dessus, lorsqu'un délai d'attente de requête se produit, nous gérerons l'événement de délai d'attente en déterminant si le type d'erreur est context.DeadlineExceeded. S'il s'agit d'un événement de délai d'attente, nous pouvons effectuer certaines opérations de traitement correspondantes, telles que renvoyer des informations d'erreur ou réessayer la demande. 🎜🎜Résumé : 🎜Lorsque vous utilisez le langage Go pour effectuer des requêtes réseau, il est très important de définir un délai d'attente raisonnable. Cet article présente les meilleures pratiques pour la gestion des délais d'attente à l'aide de http.Transport en langage Go et fournit des exemples de code. En définissant le délai d'attente de manière appropriée et en utilisant context.Context pour surveiller les événements de délai d'attente, nous pouvons mieux gérer les délais d'attente des demandes et améliorer la stabilité et la fiabilité du programme. 🎜🎜Références : 🎜🎜🎜https://golang.org/pkg/net/http/🎜🎜https://golang.org/pkg/net/http/#Client🎜🎜https://golang.org/ pkg /context/🎜🎜https://github.com/dgrijalva/jwt-go🎜🎜

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!