Caching in Kotlin: Redis, Caffeine und Ehcache – ein vollständiger Leitfaden

Caching in Kotlin: Redis und andere Tools zur Beschleunigung von Anwendungen

Caching ist einer der Schlüsselmechanismen zur Leistungssteigerung moderner Anwendungen. Im Kotlin-Ökosystem (wie auch in Java) stehen mehrere leistungsstarke Bibliotheken für die Organisation von Caching zur Verfügung: von einfachen In-Memory-Lösungen bis hin zu verteilten Systemen auf Basis von Redis. In diesem Artikel werden wir uns mit den gängigen Tools, ihrer Konfiguration und Beispielen für die Verwendung in Kotlin befassen.

Warum ist Caching notwendig?

Ein Cache kann die Antwortzeit einer Anwendung verkürzen und die Last auf Datenbanken und externe APIs reduzieren. Die wichtigsten Szenarien sind:

• Wiederholte Anfragen an dieselben Daten (z. B. Nachschlagetabellen, Einstellungen);
• Berechnungen mit langer Ausführungszeit (Berichtserstellung, komplexe Aggregationen);
• Arbeit mit externen Diensten (Rate-Limit-Begrenzung, Netzwerkverzögerungen).

1. Redis – Verteiltes Caching

Redis ist ein In-Memory-Datenspeicher, der häufig als verteilter Cache verwendet wird. Im Kotlin/Java-Ökosystem sind die wichtigsten Clients Lettuce und Jedis. Für Spring Boot wird die Verwendung von spring-boot-starter-data-redis empfohlen.

Beispiel für die Integration von Redis mit Kotlin und Spring Boot

// build.gradle.ktsimplementation("org.springframework.boot:spring-boot-starter-data-redis")implementation("org.springframework.boot:spring-boot-starter-cache")

// application.ymlspring:  cache:    type: redis  redis:    host: localhost    port: 6379

// Service mit Caching@Serviceclass UserService(private val userRepository: UserRepository) {

    @Cacheable("users")    fun getUserById(id: Long): User {        // Simulation einer langsamen Abfrage        Thread.sleep(2000)        return userRepository.findById(id).orElseThrow()    }

    @CacheEvict("users", key = "#id")    fun deleteUser(id: Long) {        userRepository.deleteById(id)    }}

Die Annotation @Cacheable speichert das Ergebnis automatisch in Redis, während @CacheEvict den Eintrag bei Datenänderungen löscht.

2. Caffeine – Hochleistungs-In-Memory-Cache

Caffeine ist eine moderne Bibliothek für lokales Caching, die den Guava Cache in Geschwindigkeit und Funktionalität deutlich übertrifft. Sie eignet sich ideal für Single-Thread- oder Microservice-Architekturen.

Konfiguration von Caffeine in Kotlin

// Abhängigkeitimplementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

// Cache erstellenval cache: Cache<String, User> = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(1000)    .recordStats()    .build()

// Verwendungfun getUser(id: String): User {    return cache.get(id) { key ->        // Lade-Funktion, wenn der Schlüssel nicht vorhanden ist        userRepository.findById(key).orElseThrow()    }}

// Statistiken abrufenprintln("Hit rate: ${cache.stats().hitRate()}")

Caffeine unterstützt das automatische Entfernen alter Einträge (expire after write/access), eine Größenbegrenzung und die Erfassung von Statistiken für das Monitoring.

3. Ehcache – Ausgereifte Lösung mit Unterstützung für Festplattenspeicher

Ehcache ist eine der ältesten Caching-Bibliotheken für Java. Sie unterstützt mehrstufige Speicherung (Heap, Off-Heap, Disk) und Clustering. Für Kotlin wird die standardmäßige Java-API verwendet.

Beispiel mit Ehcache 3 und XML-Konfiguration

// Abhängigkeitimplementation("org.ehcache:ehcache:3.10.8")

// Konfiguration (ehcache.xml)<config xmlns="http://www.ehcache.org/v3">    <cache alias="users">        <key-type>java.lang.Long</key-type>        <value-type>com.example.User</value-type>        <resources>            <heap unit="entries">100</heap>            <offheap unit="MB">10</offheap>        </res