Caching in Java: Redis, Ehcache, Caffeine, Hazelcast – Überblick und Beispiele

Caching in Java: Redis und andere Lösungen

Caching ist eine der wichtigsten Techniken zur Optimierung der Leistung von Java-Anwendungen. Es ermöglicht, die Antwortzeit zu verkürzen, die Datenbanklast zu reduzieren und die Infrastrukturkosten zu senken. In diesem Artikel werden wir die gängigen Bibliotheken und Tools für Caching in Java im Detail besprechen: Redis, Ehcache, Caffeine und Hazelcast. Sie erfahren, wann Sie welches Tool wählen sollten, und sehen funktionierende Codebeispiele.

Warum ist Caching notwendig?

Ohne Cache führt jede Datenanfrage zu einem Lesevorgang aus einem langsamen Speicher (Datenbank, externe API). Der Cache speichert häufig angefragte Daten in einem schnellen Speicher (in-process oder in-memory), was Folgendes bietet:

• Zugriffsbeschleunigung um das 10- bis 100-fache
• Reduzierung der Datenbanklast
• Erhöhung des Systemdurchsatzes
• Ressourcenschonung

1. Redis – Verteilter Cache

Redis ist ein In-Memory-Datenspeicher, der als separater Server läuft. Er unterstützt komplexe Datenstrukturen (Strings, Listen, Sets, Hashes) und Mechanismen zum Ablauf der Lebensdauer von Schlüsseln (TTL). Für Java werden die Clients Jedis oder Lettuce verwendet.

Beispiel für die Verwendung von Redis mit Jedis

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Setzt einen Wert mit einer TTL von 60 Sekunden            jedis.setex("user:123", 60, "{\\"name\\":\\"Alice\\",\\"role\\":\\"admin\\"}");

            // Liest den Wert            String userData = jedis.get("user:123");            System.out.println("Cached data: " + userData);

            // Überprüft, ob der Schlüssel existiert            System.out.println("Key exists: " + jedis.exists("user:123"));        }    }}

Vorteile von Redis:

• Unterstützung von Clustering und Replikation
• Persistenz (RDB, AOF)
• Umfangreicher Befehlssatz (INCR, SORT, PUB/SUB)
• Hervorragende Integration mit Spring Boot über spring-boot-starter-data-redis

Nachteile:

• Netzwerklatenz (separater Prozess)
• Erfordert Administration
• Nicht geeignet für Caches mit sehr kleinen Datenmengen (Verbindungs-Overhead)

2. Ehcache – Ausgereifter In-Process-Cache

Ehcache ist eine der ältesten Caching-Bibliotheken für Java. Sie läuft innerhalb der JVM, unterstützt Festplattenspeicher (BigMemory) und ist vollständig kompatibel mit JCache (JSR-107). Ideal für monolithische Anwendungen.

Beispiel für die Konfiguration von Ehcache über XML

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns="http://www.ehcache.org/v3"        xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.10.xsd">    <cache alias="users">        <key-type>java.lang.String</key-type>        <value-type>java.lang.String</value-type>        <heap>1000</heap>        <expiry>            <ttl unit="seconds">300</ttl>        </expiry>    </cache></config>

Beispiel für die Verwendung von Ehcache im Code

import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.builders.CacheManagerBuilder;import org.ehcache.xml.XmlConfiguration;

public class EhcacheExample {    public static void main(String[] args) {        XmlConfiguration xmlConfig = new XmlConfiguration(            EhcacheExample.class.getResource("/ehcache.xml"));        try (CacheManager cacheManager = CacheManagerBuilder.newCacheManager(xmlConfig)) {            cacheManager.init();            Cache<String, String> users = cacheManager.getCache("u