Comment implémenter la mise en cache des demandes de routage en langage Go

Comment implémenter la mise en cache des requêtes routées en langage Go

Dans le développement Web, le routage est un concept très important pour mapper les requêtes des clients aux gestionnaires correspondants. Dans des situations de concurrence élevée, le traitement fréquent des requêtes peut entraîner une dégradation des performances du serveur. Afin de réduire la charge sur le serveur et d'améliorer la vitesse de réponse, les requêtes acheminées peuvent être mises en cache.

En langage Go, vous pouvez utiliser la structure des données cartographiques pour implémenter la mise en cache des demandes de routage. Une carte est une collection non ordonnée de paires clé-valeur, chaque paire clé-valeur est unique.

Tout d'abord, nous devons créer une variable de carte globale pour stocker les données du cache. Dans la fonction de traitement d'itinéraire, vous pouvez décider d'utiliser ou non le cache en vérifiant si la requête spécifiée existe dans le cache. Si elles existent, les données mises en cache sont renvoyées directement ; sinon, la logique de traitement correspondante est exécutée et les résultats du traitement sont stockés dans le cache.

Ce qui suit est un exemple de code qui montre comment implémenter la mise en cache des demandes de routage dans le langage Go :

package main

import (
    "fmt"
    "sync"
)

var cache = make(map[string]string) // 全局缓存变量
var mutex = sync.Mutex{}            // 互斥锁，用于在并发情况下保护缓存的读写操作

func main() {
    http.HandleFunc("/hello", routeHandler) // 注册路由处理函数
    http.ListenAndServe(":8080", nil)        // 启动HTTP服务
}

func routeHandler(w http.ResponseWriter, r *http.Request) {
    // 检查缓存中是否存在请求的数据
    key := r.URL.Path
    mutex.Lock()
    if data, ok := cache[key]; ok {
        mutex.Unlock()
        w.Write([]byte(data)) // 直接返回缓存数据
        return
    }
    mutex.Unlock()

    // 从数据库或其他数据源中获取数据并进行处理
    result := fetchDataFromDB()

    // 将处理结果保存到缓存中
    mutex.Lock()
    cache[key] = result
    mutex.Unlock()

    w.Write([]byte(result)) // 返回处理结果
}

func fetchDataFromDB() string {
    // 数据库查询或其他数据处理逻辑
    // ...
}

Dans le code ci-dessus, une variable de carte globale est d'abord créée via la fonction <code>make. cache, utilisé pour stocker les données du cache. Ensuite, un verrou mutex mutex est défini pour protéger les opérations de lecture et d'écriture du cache dans des conditions concurrentes. make函数创建了一个全局的map变量cache，用于存储缓存数据。然后定义了一个互斥锁mutex，用于在并发情况下保护缓存的读写操作。

在routeHandler函数中，首先检查缓存中是否存在请求的数据。如果存在，则直接从缓存中获取数据并返回。如果不存在，则从数据库或其他数据源中获取数据，然后将处理结果保存到缓存中。

需要注意的是，在对缓存进行读写操作时，需要先获取互斥锁mutex

Dans la fonction routeHandler, vérifiez d'abord si les données demandées existent dans le cache. S'il existe, récupérez les données directement du cache et renvoyez-les. Si elles n'existent pas, les données sont extraites de la base de données ou d'une autre source de données et les résultats du traitement sont enregistrés dans le cache.

Il convient de noter que lors de l'exécution d'opérations de lecture et d'écriture sur le cache, vous devez d'abord obtenir le verrou mutex mutex pour vous assurer qu'aucune condition de concurrence ne se produira dans des situations concurrentes. Une fois les opérations de lecture et d'écriture terminées, le verrou mutex doit être libéré. 🎜🎜En implémentant la mise en cache des demandes de routage, la charge du serveur peut être réduite dans une certaine mesure et la vitesse de réponse peut être améliorée. En particulier pour certaines demandes de données relativement stables, un traitement fréquent peut être évité grâce à la mise en cache. Cependant, lorsque vous utilisez le cache, vous devez également faire attention au délai d'expiration du cache et à la stratégie de mise à jour des données pour garantir la validité des données mises en cache. 🎜

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!