Caching in Kotlin: Redis, Caffeine und andere Lösungen

Caching in Kotlin: Redis, Caffeine und Alternativen

Caching ist eines der wichtigsten Werkzeuge zur Steigerung der Anwendungsleistung. In Kotlin stehen dank der Kompatibilität mit Java und dem reichhaltigen JVM-Ökosystem viele Lösungen zur Verfügung: vom leichten In-Memory-Cache bis hin zu verteilten Systemen auf Basis von Redis. In diesem Artikel werden wir beliebte Bibliotheken, ihre Konfiguration und Anwendungsbeispiele besprechen.

Warum ist Caching notwendig?

Die Hauptziele des Cachings sind:

• Reduzierung der Antwortzeit (Latenz) durch Speicherung häufig angefragter Daten im schnellen Speicher.
• Verringerung der Last auf Datenbanken und externe APIs.
• Einsparung von Rechenressourcen bei wiederholten Anfragen.

Kotlin ermöglicht die Verwendung sowohl nativer Java-Bibliotheken als auch spezialisierter Kotlin-Wrapper.

1. Redis über Lettuce oder Redisson

Redis ist der beliebteste In-Memory-Datenspeicher für verteiltes Caching. In Kotlin wird es über die Clients Lettuce (reaktiv) oder Redisson (synchron/asynchron) angebunden.

Beispiel: Caching mit Lettuce

// build.gradle.ktsimplementation("io.lettuce:lettuce-core:6.3.1.RELEASE")

// CacheService.ktimport io.lettuce.core.RedisClientimport io.lettuce.core.api.sync.RedisCommands

class RedisCache(private val host: String = "localhost", private val port: Int = 6379) {    private val client: RedisClient = RedisClient.create("redis://$host:$port")    private val connection = client.connect()    private val sync: RedisCommands<String, String> = connection.sync()

    fun get(key: String): String? = sync.get(key)    fun set(key: String, value: String, ttlSeconds: Long = 60) {        sync.setex(key, ttlSeconds, value)    }    fun delete(key: String) = sync.del(key)    fun close() {        connection.close()        client.shutdown()    }}

// Verwendungfun main() {    val cache = RedisCache()    cache.set("user:123", """{"name":"Alice","role":"admin"}""", 120)    val data = cache.get("user:123")    println(data) // {"name":"Alice","role":"admin"}    cache.close()}

Redisson — eine höherwertige API

implementation("org.redisson:redisson:3.27.2")

val config = Config().apply {    useSingleServer().setAddress("redis://127.0.0.1:6379")}val redisson = Redisson.create(config)val map = redisson.getMap<String, String>("userCache")map["user:456"] = """{"name":"Bob"}"""val bob = map["user:456"]redisson.shutdown()

2. Caffeine — schneller In-Memory-Cache

Caffeine ist der moderne Ersatz für Guava Cache. Optimiert für hohe Lasten, unterstützt automatisches Entfernen veralteter Einträge.

implementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

import com.github.benmanes.caffeine.cache.Cacheimport com.github.benmanes.caffeine.cache.Caffeineimport java.util.concurrent.TimeUnit

val cache: Cache<String, String> = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(10_000)    .recordStats()    .build()

// Schreiben und Lesencache.put("key1", "value1")val value = cache.getIfPresent("key1")println(value) // value1

// Statistikval stats = cache.stats()println("Hit rate: ${stats.hitRate()}")

3. Hazelcast — verteilter Cache mit Clustering

Hazelcast eignet sich für Microservice-Architekturen: Der Cache wird automatisch zwischen den Knoten synchronisiert.

implementation("com.hazelcast:hazelcast:5.3.6")

import com.hazelcast.core.Hazelcastimport com.hazelcast.map.IMap

val instance = Hazelcast.newHazelcastInstance()val map: IMap<String, String> = instance.getMap("session-cache")map.put("session:token123", "userId=42", 30, TimeUnit.MINUTES)val userId = map.get("session:token123")instance.shutdown()

4. Spring C