Comment utiliser le contexte pour implémenter le contrôle du délai d'expiration des requêtes dans Go

Comment utiliser le contexte pour implémenter le contrôle du délai d'expiration des requêtes dans Go

Introduction :
Lorsque nous effectuons des requêtes réseau, nous rencontrons souvent des problèmes de délai d'expiration des requêtes. Une requête réseau qui ne répond pas pendant une longue période gaspillera non seulement les ressources du serveur, mais affectera également les performances globales. Afin de résoudre ce problème, le langage Go a introduit le package contextuel, qui peut être utilisé pour implémenter le contrôle du délai d'attente des requêtes. Cet article expliquera comment utiliser le package de contexte pour implémenter le contrôle du délai d'expiration des requêtes dans Go et joindra des exemples de code correspondants.

1. Comprendre le package de contexte
Le package de contexte est un package fourni par la bibliothèque standard du langage Go et est utilisé pour gérer les informations de contexte liées aux requêtes. Grâce au package de contexte, nous pouvons implémenter des fonctions telles que le contrôle du délai d'attente des requêtes, l'annulation des requêtes et le transfert d'informations contextuelles entre les requêtes.

Avant d'utiliser le package de contexte, nous devons d'abord comprendre certaines fonctions et types couramment utilisés dans le package de contexte :

• WithCancel(parent Context) (ctx Context, Cancel CancelFunc) : renvoie un sous-contexte avec une fonction d'annulation. Lorsque la fonction d'annulation est appelée, le contexte et ses sous-contextes sont annulés.
• WithDeadline(parent Context, date limite time.Time) (Context, CancelFunc) : renvoie un contexte enfant avec date limite. Lorsque la date limite est atteinte, le contexte et ses sous-contextes sont annulés.
• WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) : renvoie un sous-contexte avec un délai d'expiration. Lorsque le délai d'attente est atteint, le contexte et ses sous-contextes sont annulés.
• WithValue(parent Context, key interface{}, val interface{}) Contexte : renvoie un sous-contexte avec des paires clé-valeur.

2. Utilisez le package de contexte pour implémenter le contrôle du délai d'expiration des requêtes
Ce qui suit est un exemple de code qui utilise le package de contexte pour implémenter le contrôle du délai d'expiration des requêtes :

package main

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

func main() {
    // 创建一个带有超时时间的上下文对象
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    // 创建一个带有上下文的http请求
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://www.example.com", nil)
    if err != nil {
        fmt.Println("创建请求失败：", err)
        return
    }

    // 发送请求并得到响应
    client := http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("发送请求失败：", err)
        return
    }

    defer resp.Body.Close()

    fmt.Println("请求成功！")
}

Dans l'exemple de code ci-dessus, nous appelons d'abord context.WithTimeout. Création d'un objet contextuel avec un délai d'attente de 3 secondes. Ensuite, nous utilisons la méthode http.NewRequestWithContext pour créer un objet de requête http avec contexte et envoyer la requête. Enfin, nous envoyons la requête en appelant la méthode client.Do et obtenons la réponse. context.WithTimeout创建了一个带有3秒超时时间的上下文对象。然后，我们使用http.NewRequestWithContext方法创建了一个带有上下文的http请求对象，并发送该请求。最后，我们通过调用client.Do方法发送请求，并得到响应。

注意，在使用带有上下文的http请求对象时，我们需要使用http.NewRequestWithContext方法代替原来的http.NewRequest

Notez que lors de l'utilisation de l'objet de requête http avec contexte, nous devons utiliser la méthode http.NewRequestWithContext au lieu de la méthode http.NewRequest d'origine pour créer l'objet de requête afin que les informations contextuelles sont transmises à la demande.

3. Principe de mise en œuvre du contrôle du délai d'attente des requêtes

Lorsque nous utilisons l'objet de requête http avec un contexte pour envoyer une requête, avant que la requête ne soit envoyée, il vérifiera d'abord si l'objet de contexte a expiré (c'est-à-dire s'il a expiré). a expiré, la demande sera alors annulée et aucune demande réseau ne sera effectuée. Cela implémente le contrôle du délai d’expiration des demandes.

4. Résumé

L'utilisation du package de contexte peut facilement implémenter le contrôle du délai d'expiration des requêtes. Dans le développement réel, nous pouvons définir un délai d'attente raisonnable si nécessaire pour nous aider à éviter une longue attente inutile et un gaspillage de ressources. En utilisant rationnellement le package contextuel, nous pouvons contrôler de manière plus flexible le temps d'exécution des requêtes et améliorer la stabilité et les performances du système.

Ce qui précède est une introduction à l'utilisation du package de contexte pour implémenter le contrôle du délai d'attente des requêtes dans Go. J'espère que cela vous sera utile ! 🎜

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!