La pratique consistant à utiliser le cache pour accélérer l'efficacité de la réponse du serveur dans Golang.

Golang est un langage de programmation moderne très populaire dans le développement d'applications côté serveur. Cependant, certains goulots d'étranglement des performances du serveur peuvent entraîner un ralentissement des réponses du serveur lors du traitement des requêtes. Ces goulots d'étranglement peuvent être liés au traitement de grandes quantités de données, à la latence du réseau ou à d'autres problèmes liés aux threads. Dans cet article, nous explorerons comment utiliser la mise en cache pour accélérer l'efficacité de réponse de votre serveur Golang et fournirons quelques bonnes pratiques et des exemples de code.

1. Qu'est-ce que le cache ?

Le cache est un mécanisme de stockage temporaire de données, utilisé pour réduire l'accès à la mémoire principale ou au processeur. Lorsque les mêmes données sont demandées à plusieurs reprises, la mise en cache peut efficacement éviter les demandes et les traitements de données inutiles, améliorant ainsi les performances du serveur. Dans Golang, nous pouvons utiliser des bibliothèques tierces pour implémenter la mise en cache.

2. Types de cache

Dans Golang, nous pouvons utiliser deux types de cache : le cache local et le cache distribué.

2.1 Cache local

Le cache local fait référence au mécanisme qui stocke le cache en mémoire. Ce type de mise en cache ne convient généralement qu'aux applications à instance unique, car si nous utilisons plusieurs instances, chaque instance aura son propre cache. En fait, la mise en cache locale est très simple à mettre en œuvre et nécessite uniquement l’utilisation d’une carte. Ci-dessous, nous montrerons comment utiliser map pour implémenter la mise en cache locale.

var cache = map[string]interface{}{} // 定义一个 map 作为缓存

func Cache(key string, f func() interface{}) interface{} {
  if data, ok := cache[key]; ok { // 如果数据存在，则直接返回
    return data
  }
  result := f() // 运行函数获取数据
  cache[key] = result // 存储到缓存中
  return result // 返回结果
}

Dans le code ci-dessus, lorsque nous appelons Cache函数来获取数据时，如果数据已经存在于缓存中，则返回缓存中的数据。否则，我们将调用提供的函数（即f()) pour récupérer les données et les stocker dans le cache.

2.2 Cache distribué

Lorsque nous devons implémenter des applications multi-instances, nous devons utiliser un cache distribué. La mise en cache distribuée fait référence à un mécanisme permettant de stocker le cache sur plusieurs serveurs, qui peuvent partager les données mises en cache.

Dans Golang, nous pouvons utiliser des systèmes de mise en cache distribués open source tels que Memcached et Redis. Ces systèmes fournissent des méthodes mises en cache pour stocker et récupérer des données, et ils sont très fiables et évolutifs.

3. Pratique

Nous savons que le scénario d'utilisation du cache le plus courant consiste à stocker des données. Voyons comment utiliser la mise en cache dans Golang pour optimiser le temps de réponse de notre serveur.

3.1 Stocker les données fréquemment utilisées

Nous pouvons utiliser le cache pour stocker nos données les plus couramment utilisées. Par exemple, si nous devons récupérer les mêmes informations de la base de données à chaque requête, nous pouvons stocker ces informations dans le cache pour améliorer la vitesse de réponse du serveur. Voici un exemple de la façon de mettre en œuvre cela :

func main() {
  db.InitDB()
  userInfo := FetchUserInfoFromDB("user-id-123")
  Cache("userInfo-user-id-123", func() interface{} {
     return userInfo
  })
}

func users(w http.ResponseWriter, r *http.Request) {
  cacheData := Cache("userInfo-user-id-123", func() interface{} {
     return FindUserByID("user-id-123")
  })
  response(w, r, http.StatusOK, cacheData)
}

Dans le code ci-dessus, nous extrayons les informations utilisateur de la base de données et les mettons dans le cache lorsque l'application est initialisée. Lorsque l'utilisateur envoie une nouvelle requête, nous lirons ces données depuis le cache au lieu de redemander ces données à la base de données. Cela améliorera grandement le temps de réponse de notre application.

3.2 Stockage des résultats

Nous pouvons utiliser le cache pour stocker les résultats traités. Par exemple, nous devons parfois gérer certaines tâches gourmandes en calcul et qui prennent beaucoup de temps. Dans ce cas, nous pouvons mettre en cache ces résultats pour les utiliser dans la prochaine requête identique. Voici l'exemple de code pour implémenter cet exemple :

func main() {
  db.InitDB()
}

func fibonacci(w http.ResponseWriter, r *http.Request) {
  num, err := strconv.Atoi(r.URL.Query().Get("num"))
  if err != nil {
     http.Error(w, "Invalid Num", http.StatusBadRequest)
     return
  }

  var res int
  cacheData := Cache(fmt.Sprintf("fibonacci-%d", num), func() interface{} {
     res = fib(num)
     return res
  })
  response(w, r, http.StatusOK, cacheData)
}

func fib(n int) int {
  if n < 2 {
     return n
  }
  return fib(n-1) + fib(n-2)
}

Dans le code ci-dessus, nous utilisons le cache pour stocker les résultats de la séquence de Fibonacci. Lorsque nous recevons une requête, si les paramètres de la requête sont dans le cache, nous renverrons directement les données dans le cache. Sinon, nous calculons le résultat de la séquence de Fibonacci et stockons le résultat dans le cache.

4. Résumé

Dans les applications serveur Golang, la mise en cache peut considérablement améliorer le temps de réponse de l'application. Dans cet article, nous avons présenté deux types de cache : le cache local et le cache distribué. La mise en cache locale peut être utilisée pour les applications à instance unique, tandis que la mise en cache distribuée convient aux applications multi-instances. Nous fournissons également des exemples de code qui montrent comment la mise en cache peut être utilisée dans Golang pour optimiser les temps de réponse du serveur.

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!