Caching in TypeScript: Redis, Memcached und In-Memory-Lösungen

Caching in TypeScript: Redis, Memcached und In-Memory-Lösungen

Caching ist einer der wichtigsten Mechanismen zur Optimierung der Leistung von Webanwendungen. Im Ökosystem von TypeScript und Node.js gibt es mehrere bewährte Ansätze zur Organisation von Caching: von einfachen In-Memory-Lösungen bis hin zu verteilten Systemen auf Basis von Redis und Memcached. In diesem Artikel werden wir die gängigen Bibliotheken, ihre Installation, Konfiguration und Anwendungsbeispiele im Detail besprechen.

Warum ist Caching notwendig?

Caching ermöglicht es, die Antwortzeit des Servers zu verkürzen, die Last auf Datenbanken und externe APIs zu reduzieren und die Benutzererfahrung zu verbessern. Hauptanwendungsszenarien:

• Speichern von Ergebnissen aufwändiger Berechnungen
• Caching von Antworten externer APIs
• Speichern von Benutzersitzungen
• Caching von HTML-Seitenfragmenten

1. ioredis — Erweiterter Client für Redis

ioredis ist die beliebteste Bibliothek für die Arbeit mit Redis in Node.js und TypeScript. Sie unterstützt Clustering, Pub/Sub, Transaktionen und automatische Wiederverbindung.

Installation:

npm install ioredisnpm install @types/ioredis --save-dev

Basisverwendung mit TypeScript:

import Redis from 'ioredis';

// Verbindung zu lokalem Redisconst redis = new Redis({    host: 'localhost',    port: 6379,    retryStrategy: (times) => Math.min(times * 50, 2000)});

// Funktion zum Cachen von Datenasync function getCachedData(key: string): Promise<string | null> {    const cached = await redis.get(key);    if (cached) {        console.log('Daten aus dem Cache');        return cached;    }    // Simulation des Datenabrufs aus der DB    const data = `Data for ${key} at ${new Date().toISOString()}`;    await redis.setex(key, 3600, data); // TTL 1 Stunde    return data;}

// Beispielverwendung(async () => {    const result = await getCachedData('user:123');    console.log(result);})();

Caching von Objekten:

interface User {    id: number;    name: string;    email: string;}

async function cacheUser(user: User): Promise<void> {    await redis.setex(`user:${user.id}`, 3600, JSON.stringify(user));}

async function getUserFromCache(id: number): Promise<User | null> {    const cached = await redis.get(`user:${id}`);    return cached ? JSON.parse(cached) : null;}

2. node-cache — Einfaches In-Memory-Caching

node-cache ist eine leichte Bibliothek zum Speichern von Daten im Arbeitsspeicher des Node.js-Prozesses. Ideal für kleinere Projekte oder Prototypen, bei denen kein verteiltes Caching erforderlich ist.

Installation:

npm install node-cachenpm install @types/node-cache --save-dev

Anwendungsbeispiel:

import NodeCache from 'node-cache';

const myCache = new NodeCache({    stdTTL: 600, // Standard-Lebensdauer (Sekunden)    checkperiod: 120 // Prüfintervall für abgelaufene Schlüssel});

// Speichern und Abrufen von DatenmyCache.set('key1', { value: 42 });const value = myCache.get('key1');console.log(value); // { value: 42 }

// Prüfen, ob ein Schlüssel existiertif (myCache.has('key1')) {    console.log('Schlüssel existiert');}

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

// Statistiken abrufenconst stats = myCache.getStats();console.log(`Schlüssel im Cache: ${stats.keys}`);

3. lru-cache — Cache mit LRU-Strategie

lru-cache ist eine Implementierung eines Caches mit dem Least Recently Used-Algorithmus. Es begrenzt die Anzahl der gespeicherten Einträge und entfernt automatisch die ältesten. Ideal für Caching mit fester Größe.

Installation:

npm install lru-cache
                
    

  
Auch in der Bibliothek
  

                
                  
                 TipKit für Swift: Vollständiges Tutorial mit Beispielen
      
                
                  
                 Glide/Coil für Kotlin: Komplettguide mit Beispielen
      
                
                  
                 ORM für TypeScript: Vergleich von Prisma, TypeORM und MikroORM
      
                
                  
                 Dependency Injection Container für TypeScript: Vollständiger Leitfaden
      
                
                  
                 InversifyJS: IoC-Container für TypeScript-Anwendungen