Client Redis pour Kotlin : Lettuce et Kreds

Client Redis pour Kotlin : aperçu et comparaison des bibliothèques populaires

Redis est un magasin de données clé-valeur haute performance, largement utilisé pour la mise en cache, les sessions, les files d'attente et les applications en temps réel. Pour le langage Kotlin, il existe plusieurs clients matures qui permettent d'interagir efficacement avec Redis. Dans cet article, nous examinons deux bibliothèques principales : Lettuce (asynchrone, non bloquante) et Kreds (spécialisée pour Kotlin avec prise en charge des coroutines).

1. Lettuce — un client puissant et flexible pour la JVM

Lettuce est un client Redis asynchrone en Java qui fonctionne parfaitement dans les projets Kotlin. Il prend en charge les API synchrones, asynchrones (basées sur CompletableFuture) et réactives (Project Reactor / RxJava). Lettuce est l'une des solutions les plus populaires pour Spring Boot et les microservices.

Ajout de la dépendance (Gradle)

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

Exemple de connexion synchrone et d'opérations

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()

    // Définition et récupération d'une valeur    commands.set("mykey", "Bonjour de Lettuce !")    val value = commands.get("mykey")    println("Valeur : $value") // Bonjour de Lettuce !

    // Travail avec les hachages    commands.hset("user:1", "name", "Alice")    commands.hset("user:1", "age", "30")    val name = commands.hget("user:1", "name")    println("Nom de l'utilisateur : $name")

    connection.close()    client.shutdown()}

Mode asynchrone avec les coroutines

Lettuce prend en charge l'API asynchrone via CompletableFuture, facilement adaptable aux coroutines Kotlin avec await() :

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("Résultat du set : $result")

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

    connection.close()    client.shutdown()}

2. Kreds — un client Kotlin-first avec coroutines

Kreds est un client Redis moderne, entièrement écrit en Kotlin. Il prend en charge nativement les coroutines, Flow et la sérialisation via kotlinx.serialization. Kreds utilise Netty en interne, mais fournit une API Kotlin pure.

Ajout de la dépendance (Gradle)

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

Exemple d'utilisation de base

import io.kreds.client.RedisClient

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

    client.set("kreds-key", "Bonjour de Kreds !")    val value = client.get("kreds-key")    println("Valeur : $value")

    // Travail avec les listes    client.lpush("mylist", "A", "B", "C")    val item = client.rpop("mylist")    println("Élément dépilé : $item")

    client.close()}

Utilisation de Flow pour s'abonner aux canaux

Kreds prend en charge Pub/Sub via Kotlin Flow, pratique pour les applications réactives :

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

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

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