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

Einleitung: Warum Caching für TypeScript-Anwendungen entscheidend wichtig ist

Moderne TypeScript-Webanwendungen stehen vor wachsenden Last- und Geschwindigkeitsanforderungen. Caching ist nicht nur eine Option, sondern eine Notwendigkeit für jede produktionsreife Anwendung. Ohne Caching wird jede Anfrage an eine Datenbank oder externe API zu einer teuren Operation, die die Antwortzeit um das 10- bis 100-fache erhöht.

In diesem Artikel werden wir drei Hauptansätze für Caching in TypeScript aufschlüsseln: Redis — ein verteilter Cache, Memcached — eine leichte Alternative und integrierte Lösungen (In-Memory-Cache). Sie erfahren, wie Sie das richtige Tool auswählen und mit Codebeispielen implementieren.

1. Integriertes Caching: In-Memory-Cache in TypeScript

Der einfachste und schnellste Weg ist die direkte Speicherung von Daten im RAM des Prozesses. Für TypeScript/Node.js ist dies ideal für monolithische Anwendungen oder Microservices mit einer einzigen Instanz.

Implementierung eines einfachen In-Memory-Caches

Erstellen wir eine SimpleCache-Klasse mit TTL-Unterstützung (Time-to-Live):

interface CacheEntry<T> {  value: T;  expiresAt: number;}

class SimpleCache<T> {  private store = new Map<string, CacheEntry<T>>();  private defaultTTL: number; // in Millisekunden

  constructor(defaultTTL: number = 60000) {    this.defaultTTL = defaultTTL;  }

  set(key: string, value: T, ttl?: number): void {    const expiresAt = Date.now() + (ttl ?? this.defaultTTL);    this.store.set(key, { value, expiresAt });  }

  get(key: string): T | null {    const entry = this.store.get(key);    if (!entry) return null;    if (Date.now() > entry.expiresAt) {      this.store.delete(key);      return null;    }    return entry.value;  }

  has(key: string): boolean {    return this.get(key) !== null;  }

  delete(key: string): void {    this.store.delete(key);  }

  clear(): void {    this.store.clear();  }}

// Nutzungsbeispielconst userCache = new SimpleCache<User>(30000); // TTL 30 SekundenuserCache.set('user:123', { id: 123, name: 'Anna' });const cachedUser = userCache.get('user:123');

Vor- und Nachteile des In-Memory-Caches

• Vorteile: maximale Geschwindigkeit (Nanosekunden), keine Netzwerklatenz, einfache Implementierung.
• Nachteile: Daten gehen beim Neustart der Anwendung verloren, begrenzt durch den RAM eines einzelnen Prozesses, funktioniert nicht mit horizontaler Skalierung.

Wann verwenden: zum Caching von Ergebnissen aufwändiger Berechnungen, Konfigurationen, statischer Daten, die sich selten ändern.

2. Redis: Verteiltes Caching für TypeScript

Redis ist der beliebteste In-Memory-Datenspeicher, der als Cache, Message Broker und Datenbank verwendet wird. Für TypeScript verwenden wir die ioredis-Bibliothek.

Installation und grundlegende Einrichtung

npm install ioredisnpm install @types/ioredis -D

Erstellen wir einen Dienst für die Arbeit mit Redis:

import Redis from 'ioredis';

class RedisCacheService {  private client: Redis;  private defaultTTL: number;

  constructor(ttlSeconds: number = 3600) {    this.client = new Redis({      host: process.env.REDIS_HOST || 'localhost',      port: Number(process.env.REDIS_PORT) || 6379,      retryStrategy: (times) => Math.min(times * 50, 2000),    });    this.defaultTTL = ttlSeconds;  }

  async set<T>(key: string, value: T, ttl?: number): Promise<void> {    const serialized = JSON.stringify(value);    const ttlToUse = ttl ?? this.defaultTTL;    await this.client.setex(key, ttlToUse, serialized);  }

  async get<T>(key: string): Promise<T | null> {    const data = await this.client.get(key);    if (!data) return null;    try {      return