Comment implémenter des limites de requêtes en utilisant le contexte dans Go

Comment implémenter la limitation des requêtes à l'aide du contexte dans Go

Lors du développement d'applications Web, la limitation des requêtes est une tâche très importante, qui peut nous aider à contrôler l'utilisation des ressources et à protéger la stabilité du système. Le package de contexte est fourni dans la bibliothèque standard du langage Go, qui peut être utilisé pour gérer le contexte des requêtes et implémenter des fonctions de restriction de requêtes. Cet article expliquera comment utiliser le contexte pour implémenter des restrictions de requêtes dans Go et donnera des exemples de code correspondants.

1. Comprendre le package de contexte

Le package de contexte est une bibliothèque standard du langage Go utilisée pour transférer les informations contextuelles des requêtes. Il fournit quelques méthodes pour nous aider à gérer le cycle de vie des demandes, à annuler les demandes, à transmettre les valeurs des demandes, etc. Voici quelques méthodes couramment utilisées dans le package de contexte :

1. context.Background() : crée un contexte vide, généralement utilisé comme nœud racine de l'arborescence de contexte.
2. context.WithCancel(parent) : Créer un Contexte avec fonction d'annulation, utilisé pour annuler l'exécution du Contexte enfant.
3. context.WithDeadline(parent,deadline) : Créez un Context avec une fonction date limite pour annuler l'exécution du Context enfant avant l'heure spécifiée.
4. context.WithTimeout(parent,timeout) : Créez un contexte avec une fonction de délai d'attente pour annuler l'exécution du contexte enfant après le temps spécifié.
5. context.WithValue(parent,key,value) : créez un contexte avec une fonction de transmission de valeurs pour transmettre des valeurs dans l'arborescence de contexte.

2. Utiliser le contexte pour implémenter la restriction de requête

Ci-dessous, nous utiliserons certaines méthodes du package de contexte pour implémenter une simple fonction de restriction de requête. Supposons que nous souhaitions limiter une certaine interface à seulement 10 requêtes par seconde. Les requêtes dépassant cette limite seront rejetées. Nous pouvons réaliser cette fonction en utilisant le package context. Le code est le suivant :

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个带有取消功能的Context
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // 启动一个goroutine来执行请求处理
    go handleRequests(ctx)

    // 模拟发送100个请求
    for i := 1; i <= 100; i++ {
        select {
        case <-ctx.Done():
            fmt.Println("Too many requests, request", i, "cancelled")
        default:
            // 发送请求
            sendRequest(i)

            // 等待一秒钟
            time.Sleep(time.Second)
        }
    }
}

func handleRequests(ctx context.Context) {
    // 创建一个计数器
    counter := 0

    for {
        select {
        case <-ctx.Done():
            return
        default:
            // 检查当前请求数量是否超过限制
            if counter >= 10 {
                time.Sleep(time.Second)
            } else {
                // 处理请求
                handleRequest(counter)

                // 计数器加一
                counter++
            }
        }
    }
}

func handleRequest(requestID int) {
    fmt.Println("Handling request", requestID)
}

func sendRequest(requestID int) {
    fmt.Println("Sending request", requestID)
}

Dans le code ci-dessus, nous créons d'abord un Context avec fonction d'annulation et démarrons une goroutine pour gérer la requête. Ensuite, dans la boucle qui simule l'envoi de requêtes, nous utilisons l'instruction select pour déterminer si le nombre actuel de requêtes dépasse la limite. S'il ne dépasse pas la limite, envoyez la requête et augmentez le compteur de un, sinon attendez-en une. deuxième. Enfin, dans la fonction qui gère la requête, nous imprimons simplement l'ID de la requête.

3. Résultats d'exécution

Lorsque nous exécutons le code ci-dessus, le résultat de sortie sera similaire au suivant :

Sending request 1
Handling request 0
Sending request 2
Handling request 1
Sending request 3
Handling request 2
Sending request 4
Handling request 3
Sending request 5
Handling request 4
Sending request 6
Handling request 5
Sending request 7
Handling request 6
Sending request 8
Handling request 7
Sending request 9
Handling request 8
Too many requests, request 11 cancelled
Too many requests, request 16 cancelled
Too many requests, request 21 cancelled
...

Comme le montrent les résultats de sortie, les 10 premières requêtes peuvent être traitées normalement, mais avec le temps. par, envoi Le nombre de demandes dépasse la limite, donc les demandes dépassant la limite sont annulées.

4. Résumé

Cet article explique comment utiliser le package de contexte pour implémenter la restriction des requêtes. Grâce à des exemples de code, nous avons appris comment créer, annuler et transmettre des contextes, et comment limiter le nombre de requêtes lors de l'utilisation de contextes. J'espère que grâce à l'introduction de cet article, vous pourrez mieux comprendre comment utiliser le contexte pour implémenter des restrictions de requêtes dans 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!