Caching in TypeScript: Redis und andere Lösungen für Node.js

Caching in TypeScript: Redis und andere Tools für Node.js

Caching ist einer der Schlüsselmechanismen zur Optimierung der Leistung von Webanwendungen. In TypeScript-Projekten mit Node.js ermöglicht der Cache, die Antwortzeit von APIs zu verkürzen, die Datenbanklast zu reduzieren und die Kosten für externe Aufrufe zu senken. In diesem Artikel betrachten wir beliebte Bibliotheken für das Caching, deren Konfiguration und praktische Beispiele.

Warum ist Caching notwendig?

Ohne Cache kann jede Anfrage an den Server zu einer erneuten Datenverarbeitung führen: Lesen aus der Datenbank, komplexe Berechnungen oder Zugriff auf externe APIs. Der Cache speichert das Ergebnis des ersten Aufrufs und liefert es bei wiederholten Anfragen in Millisekunden aus. Hauptanwendungsfälle:

• Caching von Antworten externer Dienste (Wetter, Wechselkurse);
• Speicherung häufig angefragter Daten (Nachschlagewerke, Konfigurationen);
• Verkürzung der Seitenrenderingzeit;
• Begrenzung der Anzahl von Datenbankabfragen.

Beliebte Bibliotheken für Caching in TypeScript

1. Redis (über ioredis)

Redis ist ein In-Memory-Datenspeicher, der als Server arbeitet. Für TypeScript ist der beste Client ioredis mit vollständiger Typunterstützung. Installation:

npm install ioredisnpm install -D @types/ioredis

Beispiel für einen einfachen Cache mit TTL (Time-to-Live):

import Redis from 'ioredis';

const redis = new Redis({    host: 'localhost',    port: 6379,});

// Daten für 60 Sekunden speichernawait redis.set('user:123', JSON.stringify({ name: 'Anna' }), 'EX', 60);

// Daten abrufenconst cached = await redis.get('user:123');if (cached) {    const user = JSON.parse(cached);    console.log(user.name); // Anna}

Vorteile: verteilte Speicherung, automatisches Löschen von Schlüsseln, Unterstützung komplexer Strukturen (Listen, Hashes). Nachteile: ein laufender Redis-Server ist erforderlich, Verzögerung durch Netzwerkaufrufe.

2. node-cache (In-Memory)

node-cache ist eine einfache Bibliothek für das Caching im Prozessspeicher. Sie benötigt keine externen Abhängigkeiten. Installation:

npm install node-cachenpm install -D @types/node-cache

Beispiel:

import NodeCache from 'node-cache';

const myCache = new NodeCache({ stdTTL: 120 }); // Standard-TTL 120 Sekunden

// SpeichernmyCache.set('config', { theme: 'dark', lang: 'de' });

// Abrufenconst config = myCache.get('config');if (config) {    console.log(config.theme); // dark}

// LöschenmyCache.del('config');

Geeignet für kleine Anwendungen, bei denen keine Synchronisation zwischen Servern erforderlich ist.

3. memory-cache

Eine weitere In-Memory-Bibliothek mit minimalistischer API. Sie zeichnet sich durch Einfachheit und fehlende Abhängigkeiten aus:

npm install memory-cache

Beispiel:

import cache from 'memory-cache';

cache.put('weather', { temp: 22, condition: 'sunny' }, 300_000); // 5 Minuten

const weather = cache.get('weather');if (weather) {    console.log(`Temperatur: ${weather.temp}°C`);}

// Prüfen, ob Schlüssel vorhanden istif (cache.keys().includes('weather')) {    // ...}

Caching-Strategien für TypeScript

Die Wahl der Strategie hängt von der Art der Daten ab:

• Write-through – Daten werden gleichzeitig in den Cache und die Datenbank geschrieben. Garantiert Konsistenz, erhöht aber die Schreibzeit.
• Write-behind – Schreiben in den Cache erfolgt sofort, in die Datenbank asynchron. Schnell, aber möglicher Datenverlust bei einem Ausfall.
• Cache-aside – Die Anwendung prüft selbst den Cache, bei einem Fehltreffer wird aus der Datenbank gelesen und der Cache befüllt. Das gängigste Muster.

Implementierung von Cache-aside in TypeScript mit ioredis:

async function getUserById(id: number) {    const cacheKey = `user:${id}`;    const cached = await redis.get(cacheKey);

    if