So entwerfen und implementieren Sie Caching-Strategien mit Claude Code

Vorteile von Claude Code für das Caching-Strategie-Design

Ohne sorgfältiges Design kann Caching zu veralteten Datenanzeigen oder Speicherverschwendung führen. Claude Code analysiert die Datenzugriffsmuster Ihrer Anwendung und kann optimale Caching-Strategien vorschlagen und implementieren.

Redis-Cache implementieren

> Implementiere eine Cache-Schicht mit Redis.
> Mit Cache-Invalidierung, TTL-Verwaltung und Cache-Aside-Pattern.

// src/lib/cache.ts
import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL!);

interface CacheOptions {
  ttl?: number;      // in Sekunden
  prefix?: string;
}

export class CacheService {
  private defaultTTL = 300; // 5 Minuten

  async get<T>(key: string, options?: CacheOptions): Promise<T | null> {
    const fullKey = this.buildKey(key, options?.prefix);
    const data = await redis.get(fullKey);
    if (!data) return null;

    try {
      return JSON.parse(data) as T;
    } catch {
      return null;
    }
  }

  async set<T>(key: string, value: T, options?: CacheOptions): Promise<void> {
    const fullKey = this.buildKey(key, options?.prefix);
    const ttl = options?.ttl ?? this.defaultTTL;

    await redis.setex(fullKey, ttl, JSON.stringify(value));
  }

  async getOrSet<T>(
    key: string,
    fetcher: () => Promise<T>,
    options?: CacheOptions
  ): Promise<T> {
    const cached = await this.get<T>(key, options);
    if (cached !== null) return cached;

    const data = await fetcher();
    await this.set(key, data, options);
    return data;
  }

  async invalidate(key: string, prefix?: string): Promise<void> {
    const fullKey = this.buildKey(key, prefix);
    await redis.del(fullKey);
  }

  async invalidatePattern(pattern: string): Promise<void> {
    const keys = await redis.keys(pattern);
    if (keys.length > 0) {
      await redis.del(...keys);
    }
  }

  private buildKey(key: string, prefix?: string): string {
    return prefix ? `${prefix}:${key}` : key;
  }
}

export const cache = new CacheService();

Cache-Aside-Pattern implementieren

// src/services/product-service.ts
import { cache } from '@/lib/cache';
import { prisma } from '@/lib/db';

export class ProductService {
  async getProduct(id: string) {
    return cache.getOrSet(
      `product:${id}`,
      () => prisma.product.findUnique({
        where: { id },
        include: { category: true, reviews: { take: 10 } },
      }),
      { ttl: 600, prefix: 'products' }
    );
  }

  async getPopularProducts(limit = 20) {
    return cache.getOrSet(
      `popular:${limit}`,
      () => prisma.product.findMany({
        orderBy: { salesCount: 'desc' },
        take: limit,
        include: { category: true },
      }),
      { ttl: 300, prefix: 'products' }
    );
  }

  async updateProduct(id: string, data: UpdateProductInput) {
    const product = await prisma.product.update({
      where: { id },
      data,
    });

    // Zugehörigen Cache invalidieren
    await cache.invalidate(`product:${id}`, 'products');
    await cache.invalidatePattern('products:popular:*');

    return product;
  }
}

HTTP-Cache-Header konfigurieren

// src/middleware.ts
import { NextResponse, NextRequest } from 'next/server';

export function middleware(req: NextRequest) {
  const res = NextResponse.next();
  const path = req.nextUrl.pathname;

  // Statische Assets: Langzeit-Cache
  if (path.match(/\.(js|css|png|jpg|svg|woff2)$/)) {
    res.headers.set('Cache-Control', 'public, max-age=31536000, immutable');
  }

  // API: Kein Cache
  if (path.startsWith('/api/')) {
    res.headers.set('Cache-Control', 'no-store');
  }

  // Seiten: Kurzzeit-Cache + ISR
  if (!path.startsWith('/api/') && !path.match(/\.[a-z]+$/)) {
    res.headers.set('Cache-Control', 'public, s-maxage=60, stale-while-revalidate=300');
  }

  return res;
}

Speicher-Cache (Anwendungsintern)

Für kleine Datenmengen ist In-Memory-Caching effektiv.

// src/lib/memory-cache.ts
interface CacheEntry<T> {
  value: T;
  expiresAt: number;
}

export class MemoryCache {
  private store = new Map<string, CacheEntry<unknown>>();
  private maxSize: number;

  constructor(maxSize = 1000) {
    this.maxSize = maxSize;
  }

  get<T>(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 as T;
  }

  set<T>(key: string, value: T, ttlMs: number): void {
    // Größenlimit prüfen
    if (this.store.size >= this.maxSize) {
      const firstKey = this.store.keys().next().value;
      if (firstKey) this.store.delete(firstKey);
    }

    this.store.set(key, {
      value,
      expiresAt: Date.now() + ttlMs,
    });
  }

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

// Für häufig abgerufene Daten wie Konfigurationswerte
export const configCache = new MemoryCache(100);

Leitfaden zur Auswahl der Caching-Strategie

Datentyp	Empfohlener Cache	TTL-Richtwert
Konfigurationsdaten	Speicher + Redis	1 Stunde
Benutzerprofile	Redis	10 Minuten
Produktlisten	Redis + CDN	5 Minuten
Sitzungsinformationen	Redis	24 Stunden
Statische Assets	CDN	1 Jahr
API-Antworten	HTTP Cache	1 Minute

Cache-Monitoring

// Messung der Cache-Trefferquote
export class CacheMetrics {
  private hits = 0;
  private misses = 0;

  recordHit() { this.hits++; }
  recordMiss() { this.misses++; }

  getHitRate(): number {
    const total = this.hits + this.misses;
    return total === 0 ? 0 : this.hits / total;
  }

  getStats() {
    return {
      hits: this.hits,
      misses: this.misses,
      hitRate: `${(this.getHitRate() * 100).toFixed(1)}%`,
    };
  }
}

Zusammenfassung

Mit Claude Code können Sie mehrschichtige Caching-Strategien wie Redis-Cache, HTTP-Cache und Speicher-Cache effizient entwerfen und implementieren. Wenn Sie die Cache-Designrichtlinien in CLAUDE.md dokumentieren, erhalten Sie eine konsistente Implementierung im gesamten Projekt. Einen Überblick über Performance-Verbesserungen finden Sie unter Tipps zur 3-fachen Produktivität.

Weitere Informationen zu Claude Code finden Sie in der offiziellen Anthropic-Dokumentation. Details zu Redis finden Sie in der offiziellen Redis-Dokumentation.