Comment nodejs utilise la mise en cache

Avec le développement d'Internet, les applications réseaux deviennent de plus en plus complexes, et les demandes d'accès se multiplient. Afin d'améliorer les performances des applications, la mise en cache est devenue une option importante et Node.js, en tant que langage JavaScript rapide côté serveur, prend également en charge plusieurs façons d'utiliser la mise en cache. Cet article présentera comment Node.js utilise la mise en cache pour améliorer les performances des applications.

1. Principes de base de la mise en cache

Le cache peut enregistrer certaines données fréquemment utilisées en mémoire ou sur le disque. Lorsque les données doivent être utilisées, elles peuvent être obtenues directement à partir du cache, réduisant ainsi le temps de chaque requête et améliorant la réponse du système. vitesse. Les caches stockent généralement les données sous la forme de paires clé-valeur, où les clés peuvent être n'importe quel type de données et les valeurs peuvent être des chaînes, des nombres, des objets JavaScript ou d'autres types de données.

Dans Node.js, nous pouvons utiliser le module principal cache pour créer notre propre cache. Ce module fournit les méthodes suivantes : cache来创建我们自己的缓存。该模块提供了以下方法：

• cache.get(key): 获取指定键值对应的数据。
• cache.set(key, value, ttl): 将指定的值存储到缓存中，使用指定的键作为标识符。ttl表示存活时间（英文为Time To Live），即在该时间内，数据能够从缓存中被访问到。
• cache.del(key): 删除指定键值对应的数据。
• cache.clear(): 清空所有缓存。

需要注意的是，使用Node.js内置的缓存模块缓存的数据只能在当前的进程中共享，不能实现进程间的共享。如果需要实现进程间的共享，可以使用第三方的缓存模块，例如Memcached或Redis。

二、使用Node.js内置缓存模块

在实际开发中，我们可以使用Node.js内置的cache模块来实现缓存数据。下面是一个简单的例子：

const cache = require('cache');
let data = null;

if (cache.get('data')) {
  data = cache.get('data');
} else {
  // 数据库查询操作
  data = db.query('SELECT * FROM users');
  // 将数据存储到缓存中，使用'users'作为键，存活时间为1小时
  cache.set('users', data, 3600);
}

// 使用data数据

在上面的例子中，我们首先尝试从缓存中获取数据，如果找到了相应的键，则直接使用缓存中的数据。如果没有找到，则查询数据库，并将查询到的数据存储到缓存中，以减少数据库查询的次数。该数据的存活时间为1小时，过期后需要重新查询数据库，并更新缓存中的数据。

三、使用Redis缓存

除了使用Node.js内置的缓存模块，我们还可以使用第三方的缓存模块，例如Redis。Redis是一个基于内存的缓存数据库，可以实现互联网应用程序的高速缓存。下面是一个使用Redis缓存的例子：

const redis = require('redis');
const client = redis.createClient();

let data = null;
client.get('users', (err, result) => {
  if (result) {
    data = result;
  } else {
    // 数据库查询操作
    data = db.query('SELECT * FROM users');
    // 将数据存储到Redis中，使用'users'作为键，存活时间为1小时
    client.setex('users', 3600, JSON.stringify(data));
  }
});

// 使用data数据

在上面的例子中，我们使用了Redis的get方法来获取数据，如果找到了相应的键，则直接使用缓存中的数据。如果没有找到，则查询数据库，并将查询到的数据存储到Redis中，以减少数据库查询的次数。该数据的存活时间为1小时，过期后需要重新查询数据库，并更新Redis中的数据。

四、缓存失效处理

缓存的数据在存活时间内始终保持相同，但是当缓存的数据过期后，需要重新查询数据库，并更新缓存中的数据。为了确保数据的实时性，我们可以使用定时器来定时清理缓存中过期的数据。例如，每5分钟清理一次缓存：

setInterval(() => {
  cache.clear();
}, 300000);

在上面的例子中，我们使用setInterval

cache.get(key) : Récupère les données correspondant à la valeur de clé spécifiée.

cache.set(key, value, ttl) : stocke la valeur spécifiée dans le cache, en utilisant la clé spécifiée comme identifiant. ttl représente le temps de vie (Time To Live en anglais), c'est-à-dire que pendant ce temps, les données sont accessibles depuis le cache.

cache.del(key) : Supprimez les données correspondant à la valeur de clé spécifiée.
1. cache.clear() : Effacez tous les caches.

Il convient de noter que les données mises en cache à l'aide du module de mise en cache intégré de Node.js ne peuvent être partagées qu'au sein du processus en cours et ne peuvent pas être partagées entre les processus. Si vous devez réaliser un partage inter-processus, vous pouvez utiliser un module de cache tiers, tel que Memcached ou Redis.

• 2. Utilisez le module de cache intégré de Node.js
• Dans le développement réel, nous pouvons utiliser le module cache intégré de Node.js pour mettre les données en cache. Voici un exemple simple :
rrreee
• Dans l'exemple ci-dessus, on essaie d'abord d'extraire les données du cache, et si la clé correspondante est trouvée, on utilise directement les données du cache. Si elle n'est pas trouvée, la base de données est interrogée et les données interrogées sont stockées dans le cache pour réduire le nombre de requêtes sur la base de données. La durée de survie de ces données est d'une heure. Après expiration, vous devez réinterroger la base de données et mettre à jour les données dans le cache.
• 3. Utiliser le cache Redis

En plus d'utiliser le module de mise en cache intégré de Node.js, nous pouvons également utiliser des modules de mise en cache tiers, tels que Redis. Redis est une base de données de cache basée sur la mémoire qui permet la mise en cache des applications Internet. Voici un exemple d'utilisation du cache Redis :

rrreee

Dans l'exemple ci-dessus, nous utilisons la méthode get de Redis pour obtenir des données. Si la clé correspondante est trouvée, les données du cache sont utilisées directement. . S'il n'est pas trouvé, interrogez la base de données et stockez les données interrogées dans Redis pour réduire le nombre de requêtes de base de données. La durée de survie de ces données est d'une heure. Après expiration, vous devez réinterroger la base de données et mettre à jour les données dans Redis.

2. 4. Traitement d'invalidation du cache

Les données mises en cache restent toujours les mêmes pendant la durée de survie, mais lorsque les données mises en cache expirent, la base de données doit être réinterrogeée et les données dans le cache doivent être mises à jour. Afin de garantir la nature en temps réel des données, nous pouvons utiliser une minuterie pour effacer régulièrement les données expirées dans le cache. Par exemple, effacez le cache toutes les 5 minutes :

rrreee

Dans l'exemple ci-dessus, nous utilisons la méthode setInterval pour effacer régulièrement les données expirées dans le cache. L'intervalle de temps est de 5 minutes, c'est-à-dire toutes les 5 minutes. 5 minutes une fois. 🎜🎜5. Stratégies de mise en cache🎜🎜Certaines stratégies de mise en cache doivent être prises en compte lors de l'utilisation du cache pour améliorer les performances des applications. 🎜🎜🎜Stratégie d'élimination du cache🎜🎜🎜La stratégie d'élimination du cache signifie qu'une fois que le cache atteint une certaine taille ou que le temps de survie atteint une certaine période, certaines stratégies d'élimination doivent être adoptées pour nettoyer les données dans le cache. Les stratégies d'élimination courantes sont : 🎜🎜🎜FIFO (premier entré, premier sorti) : efface les données qui entrent en premier dans le cache. 🎜🎜LIFO (dernier entré, premier sorti) : effacez les dernières données entrées dans le cache. 🎜🎜LFU (Least Récemment Utilisé) : Nettoyez les données les moins utilisées. 🎜🎜LRU (Les moins récemment utilisées) : Effacez les données qui n'ont pas été utilisées depuis le plus longtemps. 🎜🎜🎜En développement réel, différentes stratégies d'élimination peuvent être adoptées selon des scénarios d'application spécifiques pour améliorer l'efficacité du cache. 🎜🎜🎜Stratégie de mise à jour du cache🎜🎜🎜La stratégie de mise à jour du cache fait référence à la façon de garantir que les données du cache sont synchronisées avec les données de la base de données lorsque les données de la base de données sont mises à jour. Les stratégies courantes de mise à jour du cache sont : 🎜

• Cache-Aside : lorsque nous avons besoin de lire une donnée, nous la recherchons d'abord dans le cache, et la renvoyons directement si elle est trouvée. Sinon, nous l'interrogeons dans la base de données, stockons les données interrogées dans le cache, et renvoyez-le aux données. Lorsque nous devons mettre à jour les données, nous mettons d'abord à jour les données dans la base de données, puis supprimons les données du cache. Lorsque nous lirons à nouveau les données, nous les lirons à nouveau dans la base de données et mettrons à jour les données dans le cache.
• Write-Through (cache en écriture) : lorsque nous devons insérer ou mettre à jour une donnée, nous mettons d'abord à jour les données dans la base de données, puis stockons les données dans le cache. Lorsque nous avons besoin de lire une donnée, nous la recherchons d'abord dans le cache et la renvoyons directement si elle est trouvée. Sinon, nous l'interrogeons dans la base de données, stockons les données interrogées dans le cache et renvoyons les données. Lorsque des données doivent être supprimées, nous supprimons d'abord les données de la base de données, puis supprimons les données du cache.

En développement réel, différentes stratégies de mise à jour du cache peuvent être adoptées selon des scénarios d'application spécifiques pour assurer la cohérence des données entre le cache et la base de données.

6. Résumé

La mise en cache est l'un des moyens importants pour améliorer les performances des applications. Dans Node.js, nous pouvons utiliser le module cache intégré pour implémenter la mise en cache, ou nous pouvons utiliser des modules de mise en cache tiers, tels que Redis. Lorsque vous utilisez le cache, vous devez envisager des stratégies d'élimination du cache et des stratégies de mise à jour du cache pour améliorer l'efficacité du cache et la cohérence des données. Même si la mise en cache peut améliorer les performances des applications, il existe également des coûts de sécurité et de gestion du cache dont il faut être conscient.

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!