Caching in TypeScript: Redis und andere Tools

Caching ist eine der wichtigsten Strategien zur Leistungsoptimierung von Webanwendungen. Im Ökosystem von TypeScript und Node.js gibt es mehrere leistungsstarke Bibliotheken, die eine effiziente Verwaltung des Daten-Cachings ermöglichen. In diesem Artikel werden wir die gängigen Tools, ihre Anwendung und die besten Praktiken im Detail besprechen.

Warum ist Caching notwendig?

Caching ermöglicht es, häufig angeforderte Daten temporär in einem schnellen Speicher abzulegen, um teure Operationen (Datenbankabfragen, Berechnungen, externe APIs) nicht jedes Mal ausführen zu müssen. Dies reduziert die Serverlast und verkürzt die Antwortzeiten.

Wichtige Tools für Caching in TypeScript

1. Redis über die Bibliothek `ioredis`

Redis ist ein leistungsstarkes In-Memory-Datenspeichersystem, das verschiedene Datenstrukturen unterstützt. Für TypeScript ist ioredis die beste Wahl – ein Client mit vollständiger Typ- und Promise-Unterstützung.

import Redis from 'ioredis';

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

// Funktion zum Caching mit TTLasync function cacheGet(key: string): Promise<string | null> {  const data = await redis.get(key);  return data;}

async function cacheSet(key: string, value: string, ttl: number = 3600): Promise<void> {  await redis.setex(key, ttl, value);}

// Beispiel zur Verwendungasync function getUserData(userId: string) {  const cacheKey = `user:${userId}`;  const cached = await cacheGet(cacheKey);  if (cached) {    return JSON.parse(cached);  }  // Simulation einer teuren Abfrage  const userData = { id: userId, name: 'John Doe' };  await cacheSet(cacheKey, JSON.stringify(userData), 3600);  return userData;}

2. `node-cache` – In-Memory-Cache für kleinere Projekte

node-cache ist eine einfache In-Memory-Bibliothek, die keine externen Abhängigkeiten erfordert. Ideal für Prototypen und Microservices mit geringen Datenmengen.

import NodeCache from 'node-cache';

const myCache = new NodeCache({ stdTTL: 600, checkperiod: 120 });

// Daten speichernmyCache.set('key', { data: 'value' });

// Daten abrufenconst value = myCache.get('key');if (value) {  console.log('Aus dem Cache:', value);} else {  console.log('Cache leer, Daten werden angefordert...');}

// Löschen nach SchlüsselmyCache.del('key');

// Gesamten Cache leerenmyCache.flushAll();

3. `async-cache-dedupe` – zur Vermeidung doppelter Anfragen

Diese Bibliothek löst das Problem des "Cache Stampede" (wenn viele Anfragen gleichzeitig versuchen, den Cache zu füllen). Sie dedupliziert automatisch parallele Anfragen zum selben Schlüssel.

import { createCache } from 'async-cache-dedupe';

const cache = createCache({  ttl: 60, // Lebensdauer in Sekunden  stale: 10, // Zeit, in der Daten als veraltet gelten, aber noch ausgegeben werden können});

// Asynchrone Funktion umschließenconst getData = cache.define('getData', async (id: number) => {  // Teure Anfrage  const result = await fetch(`https://api.example.com/data/${id}`);  return result.json();});

// Verwendungconst result = await getData(42);

Strategien zur Cache-Invalidierung

Eine der schwierigsten Aufgaben beim Caching ist die Invalidierung – die Aktualisierung veralteter Daten. Betrachten wir die wichtigsten Ansätze:

TTL (Time-To-Live) – Daten werden automatisch nach einer festgelegten Zeit gelöscht. Einfache und zuverlässige Methode.
Faule Invalidierung – Die Aktualität der Daten wird bei jeder Anfrage überprüft (z. B. anhand einer Version).
Event-gesteuerte Invalidierung – Bei Datenänderungen in der Datenbank wird ein Ereignis gesendet, um den entsprechenden Cache zu leeren.
Write-through – Der Cache wird gleichzeitig mit dem Schreiben in die Hauptdatenquelle aktualisiert.