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

Einleitung: Warum ist Caching in Java notwendig?

Moderne Java-Anwendungen stehen oft vor Performance-Problemen bei der Arbeit mit Datenbanken, externen APIs oder rechenintensiven Operationen. Jede wiederholte Anfrage an eine langsame Ressource erhöht die Antwortzeit und die Last auf die Infrastruktur. Die Lösung für dieses Problem ist Caching.

Caching in Java ermöglicht es, häufig angeforderte Daten temporär im schnellen Zugriff (normalerweise im RAM) zu speichern, um sie bei einer erneuten Anfrage sofort auszuliefern, ohne teure Operationen durchführen zu müssen. Dies ist für hochlastige Systeme, Webanwendungen und Microservices von entscheidender Bedeutung.

In diesem Artikel werden wir drei Hauptansätze für Caching in Java behandeln: verteilte Lösungen (Redis, Memcached) und eingebaute (In-Memory) Caches. Sie erfahren, wann Sie welches Tool wählen sollten, und sehen Codebeispiele für jeden Ansatz.

1. Eingebautes Caching in Java: Ehcache, Caffeine und HashMap

Eingebaute Caches sind Bibliotheken, die innerhalb der JVM Ihrer Anwendung laufen. Sie erfordern keine Installation externer Server und eignen sich ideal für monolithische Anwendungen oder Microservices mit geringen Datenmengen.

1.1. Einfachster Cache mit HashMap (nicht für die Produktion)

Der einfachste Weg ist die Verwendung von ConcurrentHashMap. Dieser Ansatz hat jedoch keine Mechanismen für Bereinigung, TTL (Time-To-Live) und Speicherkontrolle.

import java.util.concurrent.ConcurrentHashMap;

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

    public V get(K key) {        return cache.get(key);    }

    public void put(K key, V value) {        cache.put(key, value);    }

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

Nachteile: Keine automatische Bereinigung, kann zu OutOfMemoryError führen.

1.2. Caffeine — der moderne Standard in Java

Caffeine ist eine hochperformante Caching-Bibliothek für Java 8+. Sie unterstützt automatische Bereinigung basierend auf Zeit, Größe und Nutzungshäufigkeit.

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();

        // Schreiben        cache.put("user:123", "John Doe");

        // Lesen        String user = cache.getIfPresent("user:123");        System.out.println("Cached user: " + user);    }}

Vorteile von Caffeine: Hohe Geschwindigkeit, konfigurierbare Verdrängungsstrategie (LRU, LFU), asynchrones Laden.

1.3. Ehcache — bewährt über die Zeit

Ehcache ist eine der ältesten Caching-Bibliotheken für Java. Es unterstützt Festplattenspeicher und Clustering.

import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.builders.CacheConfigurationBuilder;import org.ehcache.config.builders.CacheManagerBuilder;import org.ehcache.config.builders.ResourcePoolsBuilder;

public class EhcacheExample {    public static void main(String[] args) {        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()                .withCache("myCache",                        CacheConfigurationBuilder.newCacheConfigurationBuilder(                                String.class, String.class,                                ResourcePoolsBuilder.heap(100)))                .build();        cacheManager.init();

        Cache<String, String> cache = cacheManager.getCache("m