Caching in Java: Redis, Memcached und integrierte Lösungen von A bis Z

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

Caching in Java: Redis, Memcached und integrierte Lösungen: von A bis Z

Caching ist eines der wichtigsten Werkzeuge zur Leistungssteigerung von Java-Anwendungen. Es verkürzt die Antwortzeiten, reduziert die Last auf Datenbanken und externe APIs und verbessert die Benutzererfahrung. In diesem Artikel betrachten wir drei grundlegende Ansätze zum Caching in Java: integrierte Lösungen (ConcurrentHashMap, Caffeine, Ehcache), verteilte Systeme (Redis) und leichte Netzwerk-Caches (Memcached). Sie erfahren, wann Sie was wählen sollten, und erhalten fertige Codebeispiele.

Was ist Caching und warum wird es in Java benötigt?

Caching ist die temporäre Speicherung häufig angefragter Daten in einem schnellen Speicher (normalerweise im RAM). In Java ist dies besonders relevant für:

Reduzierung von Latenzen — Daten aus dem Cache werden in Mikrosekunden zurückgegeben, nicht in Millisekunden (wie aus der DB).
Verringerung der Ressourcenlast — Datenbanken, externe Dienste und Festplatten arbeiten weniger.
Ressourcenschonung — weniger CPU- und I/O-Operationen.

Die wichtigsten Cache-Kennzahlen: hit ratio (Prozentsatz erfolgreicher Zugriffe) und TTL (Lebensdauer eines Eintrags).

Integrierte Lösungen: vom Einfachen zum Fortgeschrittenen

Für kleine Projekte oder Single-Thread-Szenarien können einfache Datenstrukturen verwendet werden. Für industrielle Anwendungen sind jedoch spezialisierte Bibliotheken besser geeignet.

1. ConcurrentHashMap — einfacher Cache

Der einfachste Weg ist die Verwendung von ConcurrentHashMap. Er ist threadsicher, hat aber keine Mechanismen zur automatischen Bereinigung (TTL, Eviction).

import java.util.concurrent.ConcurrentHashMap;

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

    public void put(String key, Object value) {        cache.put(key, value);    }

    public Object get(String key) {        return cache.get(key);    }

    public void evict(String key) {        cache.remove(key);    }

    public void clear() {        cache.clear();    }}

Vorteile: Einfachheit, keine Abhängigkeiten.
Nachteile: Keine automatische Invalidierung, manuelle Speicherverwaltung.

2. Caffeine — moderner Hochleistungs-Cache

Die Bibliothek Caffeine ist der De-facto-Standard für In-Memory-Caching in Java. Sie unterstützt:

Automatische Verdrängung nach Zeit (TTL) und Größe.
Asynchrones Laden.
Statistiken (Hit-Rate, Miss-Rate).

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)                .recordStats() // für Statistik-Erfassung                .build();

        // Hinzufügen        cache.put("user:1", "Alice");

        // Abrufen mit automatischem Laden        String value = cache.get("user:2", key -> loadFromDB(key));        System.out.println(value);    }

    private static String loadFromDB(String key) {        // Simulation des Ladens aus der DB        return "Bob";    }}

Vorteile: Hohe Leistung, Flexibilität, geringe Größe (ca. 600 KB).
Nachteile: Nur lokal (nicht verteilt).