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

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

Caching ist eines der wichtigsten Werkzeuge zur Steigerung der Anwendungsleistung. Im Kotlin-Ökosystem, das auf JVM und Android läuft, stehen Entwicklern zahlreiche Lösungen zur Verfügung: von verteilten Systemen (Redis, Memcached) bis hin zu integrierten lokalen Caches (Caffeine, Guava Cache, Ehcache). In diesem Artikel werden wir untersuchen, wie man jede dieser Lösungen in ein Kotlin-Projekt integriert, Codebeispiele liefern und Empfehlungen zur Auswahl geben.

1. Integriertes Caching auf der JVM: Caffeine und Guava Cache

Für lokales Caching in Kotlin eignet sich Caffeine am besten – eine leistungsstarke Bibliothek, die in Java geschrieben und vollständig mit Kotlin kompatibel ist. Sie unterstützt automatisches Entladen nach Zeit, nach Größe und basierend auf Gewichten. Eine Alternative ist Guava Cache von Google, aber Caffeine ist (oft 2-3 mal) schneller.

Beispiel: Caffeine + Kotlin

Fügen Sie die Abhängigkeit in build.gradle.kts hinzu:

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

Wir erstellen einen Cache für 1000 Elemente mit einer TTL von 10 Minuten:

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

val cache = Caffeine.newBuilder()    .maximumSize(1000)    .expireAfterWrite(10, TimeUnit.MINUTES)    .build<String, String>()

// Verwendungcache.put("user:42", "{\\"name\\":\\"Alice\\"}")val user = cache.getIfPresent("user:42")println(user) // {"name":"Alice"}

Beispiel: Guava Cache + Kotlin

implementation("com.google.guava:guava:33.0.0-jre")

import com.google.common.cache.CacheBuilderimport java.util.concurrent.TimeUnit

val guavaCache = CacheBuilder.newBuilder()    .maximumSize(500)    .expireAfterWrite(5, TimeUnit.MINUTES)    .build<String, String>()

guavaCache.put("session:abc", "active")println(guavaCache.getIfPresent("session:abc")) // active

Wann verwenden: zum Speichern temporärer Daten einer einzelnen Anwendungsinstanz (z. B. Ergebnisse komplexer Berechnungen, Tokens, Konfigurationen). Nicht geeignet für Microservices mit mehreren Instanzen – Daten werden nicht synchronisiert.

2. Redis – Verteiltes Caching für Microservices

Redis ist ein In-Memory-Schlüssel-Wert-Speicher, der als verteilter Cache, Message Broker und Datenbank verwendet wird. Für Kotlin ist der beste Client Lettuce (asynchron, reaktiv, thread-sicher).

Installation und Verbindung

implementation("io.lettuce:lettuce-core:6.3.2.RELEASE")

Beispiel: Verbindung und grundlegende Operationen

import io.lettuce.core.RedisClientimport io.lettuce.core.api.sync.RedisCommands

val client = RedisClient.create("redis://localhost:6379")val connection = client.connect()val commands: RedisCommands<String, String> = connection.sync()

// Schlüssel mit TTL von 60 Sekunden setzencommands.setex("user:123", 60, "{\\"name\\":\\"Bob\\"}")

// Lesenval data = commands.get("user:123")println(data) // {"name":"Bob"}

connection.close()client.shutdown()

Beispiel: Reaktiver Client (Kotlin Coroutines)

import io.lettuce.core.RedisClientimport io.lettuce.core.api.reactive.RedisReactiveCommandsimport kotlinx.coroutines.reactive.awaitFirstOrNull

suspend fun getFromRedis(key: String): String? {    val client = RedisClient.create("redis://localhost:6379")    val connection = client.connect()    val reactive: RedisReactiveCommands<String, String> = connection.reactive()

    val result = reactive.get(key).awaitFirstOrNull()    connection.close()    client.shutdown()    return result}

Wann verwenden: verteilte Systeme, Microservices, gemeinsame Sitzungen, Rate Limiting, Pu