Caching in JavaScript: Redis, Memcached und integrierte Lösungen (Fortgeschrittenenniveau)

Caching in JavaScript: Redis, Memcached und integrierte Lösungen (Fortgeschrittenenniveau)

In der modernen Webentwicklung hängt die Anwendungsleistung oft von der Geschwindigkeit des Datenzugriffs ab. Jede zusätzliche Datenbankabfrage oder jeder Aufruf einer externen API erhöht die Antwortzeit und die Serverlast. Caching ist nicht einfach nur „Ergebnis speichern", sondern eine ganze Wissenschaft mit der Wahl der richtigen Strategie, des richtigen Tools und des richtigen Invalidierungsmechanismus. In diesem Artikel behandeln wir fortgeschrittene Caching-Techniken in Node.js: von integrierten Lösungen bis hin zu den produktionsreifen Systemen Redis und Memcached.

1. Integriertes Caching in Node.js: Einfachheit und Grenzen

Bevor externe Dienste angebunden werden, sollte man die Möglichkeiten von Node.js selbst bewerten. Integriertes Caching wird mit Map- oder WeakMap-Objekten sowie einfachen globalen Variablen realisiert. Dies ist ideal für Daten, die sich selten ändern und innerhalb eines einzelnen Prozesses leben.

// Einfachster In-Memory-Cache mit TTL (Time To Live)class MemoryCache {  constructor(ttl = 60000) {    this.cache = new Map();    this.ttl = ttl;  }

  set(key, value) {    this.cache.set(key, {      value,      expiry: Date.now() + this.ttl    });  }

  get(key) {    const item = this.cache.get(key);    if (!item) return null;    if (Date.now() > item.expiry) {      this.cache.delete(key);      return null;    }    return item.value;  }

  delete(key) {    this.cache.delete(key);  }

  clear() {    this.cache.clear();  }}

// Verwendungconst cache = new MemoryCache(30000); // 30 Sekunden TTLcache.set('user:42', { name: 'Alice', role: 'admin' });console.log(cache.get('user:42')); // { name: 'Alice', role: 'admin' }

Vorteile: keine Netzwerkverzögerung, einfache Implementierung, keine externen Abhängigkeiten erforderlich.
Nachteile: Daten gehen beim Neustart des Prozesses verloren, nicht auf mehrere Server skalierbar, auf den Arbeitsspeicher eines einzelnen Knotens beschränkt.

Für Microservices, die in einem einzigen Prozess laufen, oder zum Caching von Ergebnissen rechenintensiver Operationen (z. B. Template-Rendering) ist die integrierte Lösung eine ausgezeichnete Wahl. Für verteilte Systeme reicht sie jedoch nicht aus.

2. Redis: Der König des Cachings in Node.js

Redis ist ein In-Memory-Datenspeicher, der häufig als Hochleistungs-Cache verwendet wird. Seine Hauptvorteile: Unterstützung komplexer Datenstrukturen (Strings, Listen, Sets, Hashes), integrierter TTL, Pub/Sub und Persistenz auf der Festplatte.

Redis in Node.js einbinden

Für die Arbeit mit Redis in Node.js wird das Paket ioredis (empfohlen) oder redis verwendet. Betrachten wir ein Beispiel mit ioredis:

const Redis = require('ioredis');

const redis = new Redis({  host: 'localhost',  port: 6379,  retryStrategy: (times) => Math.min(times * 50, 2000) // Wiederverbindungsstrategie});

// Basisoperationenawait redis.set('mykey', 'Hallo, Redis!', 'EX', 60); // TTL 60 Sekundenconst value = await redis.get('mykey');console.log(value); // "Hallo, Redis!"

// Verwendung eines Hashes zum Speichern komplexer Objekteawait redis.hmset('user:100', {  name: 'Bob',  email: 'bob@example.com',  age: 30});const user = await redis.hgetall('user:100');console.log(user); // { name: 'Bob', email: 'bob@example.com', age: '30' }

Fortgeschrittene Strategien mit Redis

Cache-Aside (Lazy Loading): Die Anwendung prüft zuerst den Cache und greift nur bei einem Fehlschlag auf die Datenbank zu und füllt den Cache.

async function getUser(userId) {  const cacheKey = `user:${userId}`;  let user = await redis.get(cacheKey);  if (user) {    return JSON.parse(user);  }  // Cache-Fehlschlag — aus der DB laden  user = await db.findUserById(userId);  if (user) {    await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600); // Cache für 1 Stunde  }  ret