Caching in JavaScript: Redis, Memcached und integrierte Lösungen für Node.js

Cache in JavaScript: Redis, Memcached und integrierte Lösungen

Cache ist eine der wichtigsten Strategien zur Optimierung der Leistung von Webanwendungen. Im JavaScript-Ökosystem (insbesondere Node.js) haben Entwickler Zugriff auf leistungsstarke Tools: von integrierten Mechanismen bis hin zu verteilten Systemen wie Redis und Memcached. In diesem Artikel analysieren wir, wie und wann jeder Ansatz verwendet wird, mit realen Codebeispielen.

Warum ist Caching in Node.js notwendig?

Ohne Caching kann jede Anfrage an den Server zu teuren Operationen führen: Datenbanklesevorgänge, komplexe Berechnungen oder Aufrufe externer APIs. Der Cache speichert das Ergebnis der ersten Anfrage und gibt es bei wiederholten Aufrufen zurück. Dies reduziert die Serverlast, verkürzt die Antwortzeit und verbessert die Benutzererfahrung.

Hauptanwendungsfälle für Cache in Node.js:

• Ergebnisse von Datenbankabfragen (insbesondere Aggregationen)
• Antworten externer APIs (Wetter, Wechselkurse)
• Schwere Berechnungen (Berichtserstellung, Bildverarbeitung)
• Benutzersitzungen und Authentifizierungstoken

Integriertes Caching in JavaScript (Node.js)

Der einfachste Weg ist die Verwendung eines Map- oder Object-Objekts zum Speichern von Daten im Speicher des Prozesses. Dies ist schnell, hat aber Einschränkungen: Die Daten leben nur, solange der Server läuft, und der Speicher ist nicht unbegrenzt.

Beispiel: Cache mit Map und TTL (Time To Live)

class SimpleCache {    constructor(ttl = 60000) {        this.cache = new Map();        this.ttl = ttl; // Lebensdauer in ms (Standard 1 Minute)    }

    set(key, value) {        this.cache.set(key, {            value,            timestamp: Date.now()        });    }

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

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

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

// Verwendungconst cache = new SimpleCache(30000); // 30 Sekundencache.set('user_123', { name: 'Ivan', role: 'admin' });const user = cache.get('user_123');console.log(user); // { name: 'Ivan', role: 'admin' }

Vorteile: Null Latenz, Einfachheit, keine externen Abhängigkeiten erforderlich.
Nachteile: Daten gehen beim Neustart verloren, auf den Speicher eines einzelnen Prozesses beschränkt, nicht für verteilte Systeme geeignet.

Für einen erweiterten integrierten Cache kann das Paket node-cache verwendet werden, das automatische Bereinigung, Statistiken und Unterstützung für String-Schlüssel hinzufügt.

Redis: Verteilter Cache für Node.js

Redis ist ein In-Memory-Datenspeicher, der häufig als Cache verwendet wird. In Node.js wird für die Arbeit mit Redis das Paket ioredis verwendet (moderner als redis).

Installation und grundlegende Verbindung

npm install ioredis

const Redis = require('ioredis');const redis = new Redis({    host: 'localhost',    port: 6379,    // password: 'your-password' // falls erforderlich});

redis.on('connect', () => console.log('Mit Redis verbunden'));redis.on('error', (err) => console.error('Redis Fehler:', err));

Beispiel: Daten-Caching mit TTL

const Redis = require('ioredis');const redis = new Redis();

async function getCachedData(key, fetchFunction, ttl = 3600) {    // Versuchen, aus dem Cache zu holen    const cached = await redis.get(key);    if (cached) {        return JSON.parse(cached);    }

    // Wenn nicht vorhanden — Daten abrufen und speichern    const data = await fetchFunction();    await redis.setex(key, ttl, JSON.stringify(data));    return data;}

// Beispielverwendung: Caching