Caching in Kotlin: Redis und andere Lösungen

Caching in Kotlin: Redis und andere Lösungen

Caching ist einer der wichtigsten Mechanismen zur Leistungsoptimierung in modernen Anwendungen. Im Kotlin-Ökosystem stehen dank der vollständigen Kompatibilität mit Java und der umfangreichen JVM-Bibliotheksbasis alle wichtigen Werkzeuge für die Arbeit mit dem Cache zur Verfügung. In diesem Artikel betrachten wir, wie man Caching in Kotlin mit Redis, Caffeine und Ehcache organisiert, und analysieren, wann welches Werkzeug gewählt werden sollte.

Warum ist Caching notwendig?

Der Cache ermöglicht es, die Antwortzeit der Anwendung zu verkürzen, indem häufig angeforderte Daten im schnellen Speicher abgelegt werden. Dies ist besonders relevant für:

• hochlastige REST-APIs;
• Arbeit mit externen APIs und Datenbanken;
• ressourcenintensive Berechnungen;
• Sitzungsdaten von Benutzern.

Grundlegende Caching-Strategien

Bevor Sie eine Bibliothek auswählen, ist es wichtig, die grundlegenden Strategien zu verstehen:

• Cache-Aside — Die Anwendung verwaltet den Cache selbst: Sie prüft zuerst den Cache, lädt bei einem Fehlschlag die Daten aus der Datenbank und legt sie im Cache ab.
• Read-Through — Der Cache lädt bei einem Fehlschlag automatisch Daten aus der Quelle.
• Write-Through / Write-Behind — Das Schreiben von Daten erfolgt gleichzeitig (oder asynchron) in den Cache und in den primären Speicher.

1. Redis aus Kotlin

Redis ist ein In-Memory-Key-Value-Speicher, der häufig als verteilter Cache verwendet wird. Für die Arbeit mit Redis in Kotlin wird der Client Lettuce (asynchron, reaktiv) oder Jedis (synchron) verwendet.

Einbindung von Lettuce

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

Beispiel für die Arbeit mit Redis über Lettuce (Kotlin)

import io.lettuce.core.RedisClientimport io.lettuce.core.api.coroutines

suspend fun main() {    val client = RedisClient.create("redis://localhost:6379")    val connection = client.connect()    val commands = connection.coroutines() // Coroutine-API

    // Schreiben    commands.setex("user:123:profile", 3600, "{\\"name\\":\\"Alice\\"}")        // Lesen    val cached = commands.get("user:123:profile")    println("Aus dem Cache: $cached")        connection.close()    client.shutdown()}

Wann Redis verwenden?

• Ein verteilter Cache zwischen mehreren Anwendungsinstanzen wird benötigt.
• Hohe Ausfallsicherheit und Replikation sind erforderlich.
• Daten müssen nach einem Neustart der Anwendung verfügbar sein (Redis-Persistenz).
• Unterstützung für komplexe Strukturen (Listen, Mengen, Warteschlangen) ist notwendig.

2. Caffeine — Hochleistungs-Lokaler Cache

Caffeine ist eine Bibliothek für In-Memory-Caching auf der JVM, die in Java geschrieben ist. Sie wird häufig in Verbindung mit Spring Boot verwendet, funktioniert aber auch hervorragend in reinem Kotlin. Caffeine bietet nahezu null Latenz beim Lesen.

Einbindung von Caffeine

// build.gradle.ktsimplementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

Beispiel für die Verwendung von Caffeine in Kotlin

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

data class User(val id: Int, val name: String)

fun createCache(): Caffeine<Int, User>.() -> Unit = {    maximumSize(10_000)    expireAfterWrite(10, TimeUnit.MINUTES)    recordStats()}

val userCache = Caffeine.newBuilder()    .maximumSize(10_000)    .expireAfterWrite(10, TimeUnit.MINUTES)    .build<Int, User>()

fun getUserFromCache(id: Int): User? {    return userCache.getIfPresent(id)}

fun putUser(id: Int, user: User) {    userCache.put(id, user)}

// Beispiel mit automatischem Laden (LoadingCache)val loadingCache = Caffeine.newBuilder()    .maximumSize(5_000)    .build<Int, User>