Comment utiliser le contexte dans Go pour implémenter l'actualisation automatique du cache des résultats de la requête

Comment utiliser le contexte dans Go pour implémenter l'actualisation automatique du cache des résultats des requêtes

Résumé :
Dans le développement d'applications Web, afin d'améliorer l'expérience utilisateur, nous devons parfois mettre en cache les résultats de certaines requêtes pour réduire l'accès à la base de données ou autre services. Cependant, la période de validité des données mises en cache constitue un problème. Un cache expiré peut amener les utilisateurs à obtenir des données expirées, ce qui entraîne un affichage et des opérations erronés. Dans cet article, nous explorerons comment utiliser le package de contexte de Go pour implémenter la fonction d'actualisation automatique du cache des résultats de la demande afin de garantir l'actualité des données mises en cache.

1. Qu'est-ce que le package de contexte ? Le langage Go fournit un package de contexte comme outil pour transférer des informations de contexte entre les coroutines. Le type Context dans le package context fournit certaines méthodes et propriétés pour contrôler et annuler l'exécution des coroutines. Lors du traitement des requêtes Web, nous pouvons transmettre les informations contextuelles de la requête via le package de contexte et contrôler l'exécution de certaines opérations associées.
   
Implémentation de la mise en cache des résultats de la requête
2. Tout d'abord, nous devons définir une structure de cache pour stocker les résultats de la requête et leur heure d'expiration. Le code est le suivant :
   

type CacheItem struct {
    result      interface{}
    expireAt    time.Time
}

type Cache struct {
    cacheMap    map[string]CacheItem
    mutex       sync.RWMutex
}

Dans le code ci-dessus, nous utilisons une carte pour stocker les éléments du cache, où les clés sont des identifiants uniques liés à la requête et les valeurs sont les détails des éléments du cache (tels que les résultats et l'expiration). temps). Pour garantir la sécurité de la concurrence, nous utilisons un verrou mutex.

Ensuite, nous devons écrire une fonction pour obtenir les données du cache. Cette fonction vérifie d'abord si le résultat de la requête existe dans le cache et détermine s'il a expiré. Si le résultat mis en cache existe et n'a pas expiré, les données mises en cache sont renvoyées directement. Sinon, nous devons faire la requête réelle et mettre le résultat en cache. Le code est le suivant :

func (c *Cache) Get(key string) interface{} {
    c.mutex.RLock()
    defer c.mutex.RUnlock()

    item, ok := c.cacheMap[key]
    if ok && item.expireAt.After(time.Now()) {
        return item.result
    }

    // 发起请求并更新缓存
    result := makeRequest(key)
    c.cacheMap[key] = CacheItem{result: result, expireAt: time.Now().Add(time.Minute)}

    return result
}

Dans le code ci-dessus, nous utilisons des verrous de lecture pour lire les éléments du cache afin de garantir la sécurité de la concurrence. Si l'élément du cache existe et n'a pas expiré, le résultat du cache est renvoyé directement ; sinon, nous lançons une requête réelle et stockons le résultat de la requête dans le cache.

Actualiser le cache
3. Afin de garantir l'actualité des données mises en cache, nous devons actualiser le cache régulièrement. Dans Go, nous pouvons utiliser la fonction WithDeadline du package de contexte pour définir une date limite et annuler automatiquement l'opération correspondante après le délai d'attente. Nous pouvons utiliser cette fonctionnalité pour actualiser automatiquement le cache. Le code est le suivant :
   

func (c *Cache) RefreshCache(ctx context.Context, key string) {
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            result := makeRequest(key)
            c.mutex.Lock()
            c.cacheMap[key] = CacheItem{result: result, expireAt: time.Now().Add(time.Minute)}
            c.mutex.Unlock()
        case <-ctx.Done():
            return
        }
    }
}

Dans le code ci-dessus, nous utilisons un objet Ticker pour appeler régulièrement la fonction makeRequest pour mettre à jour le cache. En même temps, nous utilisons l'instruction select pour écouter le signal d'annulation de contexte pour quitter. la boucle de rafraîchissement après l'annulation du contexte.

Exemple d'utilisation
4. Ensuite, nous utiliserons une application Web simple pour démontrer comment utiliser l'implémentation de cache ci-dessus. Le code est le suivant :
   

package main

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

type CacheItem struct {
    result   interface{}
    expireAt time.Time
}

type Cache struct {
    cacheMap map[string]CacheItem
    mutex    sync.RWMutex
}

func makeRequest(key string) interface{} {
    // 模拟请求耗时
    time.Sleep(time.Second)
    return fmt.Sprintf("result for %s", key)
}

func (c *Cache) Get(key string) interface{} {
    c.mutex.RLock()
    defer c.mutex.RUnlock()

    item, ok := c.cacheMap[key]
    if ok && item.expireAt.After(time.Now()) {
        return item.result
    }

    result := makeRequest(key)
    c.cacheMap[key] = CacheItem{result: result, expireAt: time.Now().Add(time.Minute)}

    return result
}

func (c *Cache) RefreshCache(ctx context.Context, key string) {
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            result := makeRequest(key)
            c.mutex.Lock()
            c.cacheMap[key] = CacheItem{result: result, expireAt: time.Now().Add(time.Minute)}
            c.mutex.Unlock()
        case <-ctx.Done():
            return
        }
    }
}

func main() {
    cache := &Cache{cacheMap: make(map[string]CacheItem)}

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*5))
        defer cancel()

        key := r.URL.Path

        result := cache.Get(key)
        fmt.Fprintf(w, "%s: %s", key, result)

        // 启动刷新缓存的协程
        go cache.RefreshCache(ctx, key)
    })

    http.ListenAndServe(":8080", nil)
}

Dans l'exemple de code ci-dessus, nous définissons un simple serveur HTTP Lorsqu'une requête est reçue, la méthode Get mise en cache est appelée pour obtenir les données et renvoyée au client. Dans le même temps, nous utilisons le package de contexte pour créer un contexte avec un délai de 5 secondes et le transmettons à la méthode RefreshCache pour contrôler le temps de rafraîchissement du cache.

Conclusion :

Cet article explique comment utiliser le package de contexte de Go pour implémenter la fonction d'actualisation automatique du cache des résultats de la requête. En utilisant des structures de cache et des verrous mutex pour garantir la sécurité de la concurrence, et en utilisant les fonctionnalités du package de contexte pour actualiser régulièrement le cache, nous pouvons simplement mettre en cache les résultats de la requête et garantir l'actualité des données. L'exemple de code ci-dessus n'est qu'une simple démonstration. L'utilisation réelle peut nécessiter une modification et une optimisation appropriées en fonction de besoins spécifiques.

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!