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

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einleitung: Warum ist Caching in Java notwendig?

Moderne Java-Anwendungen arbeiten oft mit großen Datenmengen. Jede Anfrage an eine Datenbank oder eine externe API kostet Zeit und Ressourcen. Ohne Caching sinkt die Leistung bei steigender Last und die Antwortzeit erhöht sich. Caching ermöglicht es, häufig angefragte Daten schnell zugänglich zu machen (im Arbeitsspeicher), was Verzögerungen reduziert und die Last auf das Backend verringert.

In Java gibt es drei Hauptansätze für Caching: eingebaute Lösungen (z. B. HashMap oder Caffeine), verteilte Systeme (Redis und Memcached). In diesem Artikel werden wir jeden davon analysieren, Codebeispiele zeigen und Ihnen helfen, die optimale Option für Ihr Projekt auszuwählen.

1. Eingebautes Caching in Java

Eingebautes Caching ist der einfachste Weg, eine Anwendung zu beschleunigen. Die Daten werden direkt im JVM-Speicher gespeichert. Hauptvorteile: minimale Zugriffsverzögerung, einfache Konfiguration. Nachteile: begrenzter Umfang (abhängig vom Heap), Daten gehen beim Neustart der Anwendung verloren.

1.1. Einfaches Caching mit HashMap

Die grundlegendste Variante ist die Verwendung von ConcurrentHashMap mit manueller Verwaltung der Lebensdauer. Geeignet für Prototypen, aber nicht für die Produktion (keine automatische Bereinigung, mögliche Speicherlecks).

import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;

public class SimpleCache {    private final ConcurrentHashMap<String, CacheEntry> cache = new ConcurrentHashMap<>();

    public void put(String key, Object value, long ttlMillis) {        cache.put(key, new CacheEntry(value, System.currentTimeMillis() + ttlMillis));    }

    public Object get(String key) {        CacheEntry entry = cache.get(key);        if (entry == null || System.currentTimeMillis() > entry.expiry) {            cache.remove(key);            return null;        }        return entry.value;    }

    private static class CacheEntry {        private final Object value;        private final long expiry;        // Konstruktor und Getter    }}

1.2. Caffeine — moderne Caching-Bibliothek

Caffeine ist eine leistungsstarke Bibliothek für Java, die standardmäßig in Spring Cache verwendet wird. Sie unterstützt automatische Räumung nach Zeit, Größe sowie gewichtete Elemente. Caffeine arbeitet schneller als Guava Cache (auf dem es basiert).

import com.github.benmanes.caffeine.cache.Cache;import com.github.benmanes.caffeine.cache.Caffeine;import java.util.concurrent.TimeUnit;

public class CaffeineExample {    public static void main(String[] args) {        Cache<String, String> cache = Caffeine.newBuilder()                .expireAfterWrite(10, TimeUnit.MINUTES)                .maximumSize(1000)                .build();

        cache.put("user:123", "John Doe");        String user = cache.getIfPresent("user:123");        System.out.println("Cached user: " + user);    }}

Für die Produktion wird die Verwendung von Caffeine oder Ehcache (das die Speicherung auf der Festplatte unterstützt) empfohlen. Eingebaute Lösungen sind ideal für Microservices und Monolithen mit einer einzigen Instanz.

2. Memcached: Verteiltes Caching für Java

Memcached ist ein verteiltes Caching-System, das im Arbeitsspeicher arbeitet. Es ist einfach, schnell und unterstützt horizontale Skalierung. Hauptmerkmale: