Wie NodeJS Caching verwendet

Mit der Entwicklung des Internets werden Netzwerkanwendungen immer komplexer und es gibt immer mehr Zugriffsanfragen. Um die Anwendungsleistung zu verbessern, ist Caching zu einer wichtigen Option geworden, und Node.js unterstützt als schnelle serverseitige JavaScript-Sprache auch mehrere Möglichkeiten, Caching zu verwenden. In diesem Artikel wird vorgestellt, wie Node.js Caching nutzt, um die Anwendungsleistung zu verbessern.

1. Grundprinzipien des Cachings

Der Cache kann einige häufig verwendete Daten im Speicher oder auf der Festplatte speichern. Wenn die Daten verwendet werden müssen, können sie direkt aus dem Cache abgerufen werden, wodurch die Zeit für jede Abfrage verkürzt und die Systemantwort verbessert wird Geschwindigkeit. Caches speichern Daten im Allgemeinen in Form von Schlüssel-Wert-Paaren, wobei Schlüssel beliebige Datentypen und Werte Zeichenfolgen, Zahlen, JavaScript-Objekte oder andere Datentypen sein können.

In Node.js können wir das Kernmodul cache verwenden, um unseren eigenen Cache zu erstellen. Dieses Modul bietet die folgenden Methoden: 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): Ruft die Daten ab, die dem angegebenen Schlüsselwert entsprechen.

cache.set(key, value, ttl): Speichern Sie den angegebenen Wert im Cache und verwenden Sie dabei den angegebenen Schlüssel als Bezeichner. ttl stellt die Lebenszeit (Time To Live auf Englisch) dar, dh innerhalb dieser Zeit kann auf die Daten aus dem Cache zugegriffen werden.

cache.del(key): Löschen Sie die Daten, die dem angegebenen Schlüsselwert entsprechen.
1. cache.clear(): Alle Caches löschen.

Es ist zu beachten, dass mit dem integrierten Caching-Modul von Node.js zwischengespeicherte Daten nur innerhalb des aktuellen Prozesses und nicht zwischen Prozessen geteilt werden können. Wenn Sie eine prozessübergreifende gemeinsame Nutzung benötigen, können Sie ein Cache-Modul eines Drittanbieters wie Memcached oder Redis verwenden.

• 2. Verwenden Sie das integrierte Cache-Modul von Node.js
• In der tatsächlichen Entwicklung können wir das integrierte cache-Modul von Node.js verwenden, um Daten zwischenzuspeichern. Hier ist ein einfaches Beispiel:
rrreee
• Im obigen Beispiel versuchen wir zunächst, die Daten aus dem Cache abzurufen, und wenn der entsprechende Schlüssel gefunden wird, verwenden wir direkt die Daten aus dem Cache. Wenn sie nicht gefunden werden, wird die Datenbank abgefragt und die abgefragten Daten werden im Cache gespeichert, um die Anzahl der Datenbankabfragen zu reduzieren. Die Überlebenszeit dieser Daten beträgt 1 Stunde. Nach Ablauf müssen Sie die Datenbank erneut abfragen und die Daten im Cache aktualisieren.
• 3. Redis-Cache verwenden

Zusätzlich zur Verwendung des integrierten Caching-Moduls von Node.js können wir auch Caching-Module von Drittanbietern wie Redis verwenden. Redis ist eine speicherbasierte Caching-Datenbank, die das Caching von Internetanwendungen ermöglicht. Das Folgende ist ein Beispiel für die Verwendung des Redis-Cache:

rrreee

Im obigen Beispiel verwenden wir die get-Methode von Redis, um Daten abzurufen. Wenn der entsprechende Schlüssel gefunden wird, werden die Daten im Cache direkt verwendet. . Wenn nicht gefunden, fragen Sie die Datenbank ab und speichern Sie die abgefragten Daten in Redis, um die Anzahl der Datenbankabfragen zu reduzieren. Die Überlebenszeit dieser Daten beträgt 1 Stunde. Nach Ablauf müssen Sie die Datenbank erneut abfragen und die Daten in Redis aktualisieren.

2. 4. Cache-Ungültigmachungsverarbeitung

Die zwischengespeicherten Daten bleiben während der Überlebenszeit immer gleich, aber wenn die zwischengespeicherten Daten ablaufen, muss die Datenbank erneut abgefragt und die Daten im Cache aktualisiert werden. Um sicherzustellen, dass die Daten in Echtzeit vorliegen, können wir einen Timer verwenden, um abgelaufene Daten regelmäßig im Cache zu löschen. Leeren Sie den Cache beispielsweise alle 5 Minuten:

rrreee

Im obigen Beispiel verwenden wir die Methode setInterval, um abgelaufene Daten regelmäßig im Cache zu löschen. Das Zeitintervall beträgt 5 Minuten, also alle 5 Minuten einmal. 🎜🎜5. Caching-Strategien🎜🎜Bei der Verwendung des Caches müssen einige Caching-Strategien berücksichtigt werden, um die Anwendungsleistung zu verbessern. 🎜🎜🎜Cache-Eliminierungsstrategie🎜🎜🎜Cache-Eliminierungsstrategie bedeutet, dass einige Eliminierungsstrategien angewendet werden müssen, um die Daten im Cache zu bereinigen, nachdem der Cache eine bestimmte Größe erreicht oder die Überlebenszeit einen bestimmten Zeitraum erreicht hat. Gängige Eliminierungsstrategien sind: 🎜🎜🎜FIFO (First In, First Out): Löschen Sie die Daten, die zuerst in den Cache gelangen. 🎜🎜LIFO (last in, first out): Löscht die letzten Daten, die in den Cache gelangt sind. 🎜🎜LFU (Least Latest Used): Bereinigen Sie die Daten mit der geringsten Nutzung. 🎜🎜LRU (Least Latest Used): Löschen Sie die Daten, die am längsten nicht verwendet wurden. 🎜🎜🎜In der tatsächlichen Entwicklung können je nach Anwendungsszenario unterschiedliche Eliminierungsstrategien angewendet werden, um die Cache-Effizienz zu verbessern. 🎜🎜🎜Cache-Aktualisierungsstrategie🎜🎜🎜Die Cache-Aktualisierungsstrategie bezieht sich darauf, wie sichergestellt wird, dass die Daten im Cache mit den Daten in der Datenbank synchronisiert werden, wenn die Daten in der Datenbank aktualisiert werden. Gängige Cache-Aktualisierungsstrategien sind: 🎜

• Cache-Aside: Wenn wir ein Datenelement lesen müssen, durchsuchen wir es zuerst im Cache und geben es direkt zurück, wenn es gefunden wird. Andernfalls fragen wir es aus der Datenbank ab und speichern die abgefragten Daten im Cache. und geben Sie die Daten zurück. Wenn wir Daten aktualisieren müssen, aktualisieren wir zuerst die Daten in der Datenbank und löschen dann die Daten aus dem Cache. Wenn wir die Daten erneut lesen, lesen wir sie erneut aus der Datenbank und aktualisieren die Daten im Cache.
• Write-Through (Durchschreibcache): Wenn wir Daten einfügen oder aktualisieren müssen, aktualisieren wir zuerst die Daten in der Datenbank und speichern sie dann im Cache. Wenn wir ein Datenelement lesen müssen, suchen wir es zuerst im Cache und geben es direkt zurück, wenn es gefunden wird. Andernfalls fragen wir es aus der Datenbank ab, speichern die abgefragten Daten im Cache und geben die Daten zurück. Wenn Daten gelöscht werden müssen, löschen wir zuerst die Daten in der Datenbank und dann die Daten aus dem Cache.

In der tatsächlichen Entwicklung können je nach Anwendungsszenario unterschiedliche Cache-Aktualisierungsstrategien angewendet werden, um die Datenkonsistenz zwischen Cache und Datenbank sicherzustellen.

6. Zusammenfassung

Caching ist eines der wichtigen Mittel zur Verbesserung der Anwendungsleistung. In Node.js können wir das integrierte cache-Modul verwenden, um Caching zu implementieren, oder wir können Caching-Module von Drittanbietern wie Redis verwenden. Bei der Verwendung von Cache müssen Sie Cache-Eliminierungsstrategien und Cache-Aktualisierungsstrategien berücksichtigen, um die Cache-Effizienz und Datenkonsistenz zu verbessern. Während Caching die Anwendungsleistung verbessern kann, sind auch Kosten für Cache-Sicherheit und -Verwaltung zu beachten.

Das obige ist der detaillierte Inhalt vonWie NodeJS Caching verwendet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!