Caching in JavaScript (Node.js): Redis und andere Lösungen…

Caching in JavaScript (Node.js): Redis und andere Tools

Caching ist eine der effektivsten Methoden, um die Leistung von Webanwendungen in Node.js zu steigern. Es verkürzt die Antwortzeit, reduziert die Datenbanklast und senkt die Infrastrukturkosten. In diesem Artikel behandeln wir die wichtigsten Caching-Tools in der Node.js-Umgebung: Redis, Memcached und integriertes In-Memory-Caching. Sie erfahren, wann Sie welches Tool wählen sollten, und sehen funktionierende Codebeispiele.

Warum ist Caching in Node.js wichtig?

Node.js ist single-threaded, aber asynchron. Jede Anfrage an eine Datenbank oder eine externe API bedeutet Wartezeit (I/O). Ein Cache speichert das Ergebnis einer teuren Operation (z. B. einer komplexen SQL-Abfrage oder HTML-Parsing) und liefert es sofort aus. Hauptanwendungsfälle sind:

Speichern von Datenbankabfrageergebnissen (insbesondere aggregierende)
Caching von Antworten externer APIs (Wetter, Wechselkurse)
Speichern von Benutzersitzungen
Zwischenspeicherung berechneter Daten (z. B. Template-Rendering)

1. Redis – der König des Cachings

Redis ist ein In-Memory-Datenspeicher, der häufig als Cache verwendet wird. Er läuft in einem separaten Prozess, unterstützt komplexe Datenstrukturen (Strings, Hashes, Listen, Sets) und verfügt über integrierte TTL-Mechanismen (Time-to-Live).

Installation und Verbindung

Für die Nutzung wird ein installierter Redis-Server benötigt (lokal oder in Docker). In Node.js verwenden wir das Paket redis:

npm install redis

Beispiel: Daten-Caching mit TTL

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

client.on('error', (err) => console.error('Redis-Fehler:', err));

// Asynchrone Funktion zum Abrufen von Daten mit Cacheasync function getCachedData(key, fetchFunction, ttlSeconds = 60) {  // Versuchen, aus dem Cache zu laden  const cached = await client.get(key);  if (cached) {    return JSON.parse(cached);  }

  // Falls nicht vorhanden – teure Funktion aufrufen  const freshData = await fetchFunction();

  // Im Cache mit TTL speichern  await client.setEx(key, ttlSeconds, JSON.stringify(freshData));  return freshData;}

// Verwendung: Ergebnis einer Datenbankabfrage cachenconst users = await getCachedData('users:list', () => db.query('SELECT * FROM users'), 120);

Vorteile von Redis

Hohe Leistung (Millionen Operationen pro Sekunde)
Unterstützung von TTL, Pub/Sub, Transaktionen
Persistenz (kann auf Festplatte gespeichert werden)
Geeignet für verteilte Systeme (mehrere Node.js-Server)

Nachteile

Erfordert einen separaten Server/Container
Verbraucht Arbeitsspeicher
Für einfache Single-Thread-Anwendungen überdimensioniert

2. Memcached – leicht und schnell

Memcached ist ein weiterer beliebter In-Memory-Cache, aber einfacher als Redis: nur Strings, keine Persistenz, keine komplexen Strukturen. Ideal für einfaches Daten-Caching.

Installation und Beispiel

npm install memcached

const Memcached = require('memcached');const memcached = new Memcached('localhost:11211');

async function getCachedData(key, fetchFunction, ttlSeconds = 60) {  return new Promise((resolve, reject) => {    memcached.get(key, async (err, data) => {      if (data) return resolve(JSON.parse(data));

      const freshData = await fetchFunction();      memcached.set(key, JSON.stringify(freshData), ttlSeconds, (err) => {        if (err) reject(err);        resolve(freshData);      });    });  });}