Caching in TypeScript: Redis, Memcached und integrierte Lösungen

Caching in TypeScript: Redis, Memcached und integrierte Lösungen

Moderne Webanwendungen in TypeScript erfordern hohe Antwortgeschwindigkeiten und effizientes Ressourcenmanagement. Eines der wichtigsten Werkzeuge, um dieses Ziel zu erreichen, ist Caching. In diesem Artikel werden wir drei Hauptansätze für Caching im TypeScript/Node.js-Ökosystem im Detail betrachten: die Verwendung von Redis, Memcached und integrierten Lösungen (In-Memory-Cache). Sie erfahren, wie Sie das passende Werkzeug für Ihre Aufgabe auswählen und sehen funktionierende Codebeispiele.

Warum ist Caching in TypeScript notwendig?

Caching ermöglicht es, häufig angeforderte Daten temporär in einem schnellen Speicher abzulegen, um die Antwortzeit zu verkürzen und die Last auf Datenbanken oder externe APIs zu reduzieren. In TypeScript, das auf Node.js läuft, ist Caching besonders nützlich für:

• Beschleunigung wiederholter Datenbankabfragen;
• Reduzierung von Verzögerungen bei der Kommunikation mit externen Diensten;
• Optimierung rechenintensiver Operationen;
• Verwaltung von Benutzersitzungen.

Betrachten wir die drei wichtigsten Caching-Typen, die einem TypeScript-Entwickler zur Verfügung stehen.

1. Integriertes Caching (In-Memory Cache)

Der einfachste und schnellste Weg ist, Daten im Speicher des Node.js-Prozesses selbst zu speichern. Dazu kann man Map oder fortschrittlichere Bibliotheken wie node-cache verwenden.

Vorteile:

• Maximale Geschwindigkeit (keine Netzwerkaufrufe);
• Einfachheit der Implementierung;
• Erfordert keine Installation externer Dienste.

Nachteile:

• Daten gehen beim Neustart der Anwendung verloren;
• Begrenzt durch den Arbeitsspeicher eines einzelnen Prozesses;
• Funktioniert nicht im Cluster-Modus (jeder Prozess hat seinen eigenen Cache).

Beispiel mit node-cache

Installieren Sie die Bibliothek:

npm install node-cache

Implementierung eines einfachen Caching-Dienstes:

import NodeCache from 'node-cache';

class MemoryCacheService {  private cache: NodeCache;

  constructor(ttlSeconds: number = 600) {    this.cache = new NodeCache({ stdTTL: ttlSeconds, checkperiod: 120 });  }

  public get<T>(key: string): T | undefined {    return this.cache.get<T>(key);  }

  public set<T>(key: string, value: T, ttl?: number): boolean {    return this.cache.set(key, value, ttl);  }

  public has(key: string): boolean {    return this.cache.has(key);  }

  public del(key: string): number {    return this.cache.del(key);  }

  public flush(): void {    this.cache.flushAll();  }}

// Verwendungconst cacheService = new MemoryCacheService(300); // TTL = 5 Minuten

async function getData(id: string): Promise<any> {  const cached = cacheService.get<any>(`data:${id}`);  if (cached) {    return cached;  }

  // Simulation einer teuren Operation  const data = await fetchFromDatabase(id);  cacheService.set(`data:${id}`, data);  return data;}

2. Caching mit Redis

Redis ist ein leistungsstarkes In-Memory-Datenspeicher, der häufig als Cache verwendet wird. Es unterstützt komplexe Datenstrukturen (Strings, Hashes, Listen, Sets) und kann im Cluster-Modus betrieben werden.

Vorteile:

• Persistenz (optional);
• Unterstützung komplexer Datenstrukturen (z. B. sortierte Sets);
• Integrierte TTL-Mechanismen (Time-To-Live);
• Hervorragende Leistung (bis zu 100.000 Operationen/Sekunde);
• Unterstützung von Pub/Sub für den Nachrichtenaustausch.

Nachteile:

• Erfordert die Installation und Konfiguration eines separaten Servers;
• Verwendet mehr Speicher als integrierte Lösungen;
• Netzwerkverzögerungen (wenn auch minimal).

Beispiel für die Arbeit mit Redis in TypeScript