Redis-Client für Kotlin: Lettuce und Kreds

Redis-Client für Kotlin: Überblick und Vergleich beliebter Bibliotheken

Redis ist ein leistungsstarker Schlüssel-Wert-Datenspeicher, der häufig für Caching, Sitzungen, Warteschlangen und Echtzeitanwendungen verwendet wird. Für die Sprache Kotlin gibt es mehrere ausgereifte Clients, die eine effiziente Interaktion mit Redis ermöglichen. In diesem Artikel betrachten wir zwei Hauptbibliotheken: Lettuce (asynchron, nicht blockierend) und Kreds (spezialisiert für Kotlin mit Coroutinen-Unterstützung).

1. Lettuce – Leistungsstarker und flexibler Client für die JVM

Lettuce ist ein asynchroner Redis-Client in Java, der hervorragend in Kotlin-Projekten funktioniert. Er unterstützt synchrone, asynchrone (basierend auf CompletableFuture) und reaktive (Project Reactor / RxJava) APIs. Lettuce ist eine der beliebtesten Lösungen für Spring Boot und Microservices.

Einbindung (Gradle)

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

Beispiel für synchrone Verbindung und Operationen

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

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

    // Setzen und Abrufen eines Werts    commands.set("mykey", "Hello from Lettuce!")    val value = commands.get("mykey")    println("Value: $value") // Hello from Lettuce!

    // Arbeiten mit Hashes    commands.hset("user:1", "name", "Alice")    commands.hset("user:1", "age", "30")    val name = commands.hget("user:1", "name")    println("User name: $name")

    connection.close()    client.shutdown()}

Asynchroner Modus mit Coroutinen

Lettuce unterstützt eine asynchrone API über CompletableFuture, die sich leicht mit await() an Kotlin-Coroutinen anpassen lässt:

import kotlinx.coroutines.runBlockingimport kotlinx.coroutines.future.await

fun main() = runBlocking {    val client = RedisClient.create("redis://localhost:6379")    val connection = client.connect()    val asyncCommands = connection.async()

    val result = asyncCommands.set("coroutine-key", "Kotlin + Lettuce").await()    println("Set result: $result")

    val value = asyncCommands.get("coroutine-key").await()    println("Value: $value")

    connection.close()    client.shutdown()}

2. Kreds – Kotlin-First-Client mit Coroutinen

Kreds ist ein moderner Redis-Client, der vollständig in Kotlin geschrieben ist. Er unterstützt von Haus aus Coroutinen, Flow und Serialisierung über kotlinx.serialization. Kreds verwendet unter der Haube Netty, bietet aber eine reine Kotlin-API.

Einbindung (Gradle)

dependencies {    implementation("io.ktor:kreds:0.9.0")}

Beispiel für die grundlegende Verwendung

import io.kreds.client.RedisClient

suspend fun main() {    val client = RedisClient("localhost", 6379)

    client.set("kreds-key", "Hello from Kreds!")    val value = client.get("kreds-key")    println("Value: $value")

    // Arbeiten mit Listen    client.lpush("mylist", "A", "B", "C")    val item = client.rpop("mylist")    println("Popped: $item")

    client.close()}

Verwendung von Flow zum Abonnieren von Kanälen

Kreds unterstützt Pub/Sub über Kotlin Flow, was für reaktive Anwendungen praktisch ist:

import io.kreds.client.RedisClientimport kotlinx.coroutines.flow.collect

suspend fun main() {    val client = RedisClient("localhost", 6379)

    client.subscribe("channel-1").collect { message ->        println("Received: ${message.payload}")    }}