Mise en cache en Kotlin : Redis, Memcached et solutions intégrées de A à Z

Mise en cache en Kotlin : Redis, Memcached et solutions intégrées — de A à Z

La mise en cache est l'un des outils clés pour améliorer les performances des applications. Dans l'écosystème Kotlin, qui fonctionne sur JVM et Android, le développeur a accès à de nombreuses solutions : des systèmes distribués (Redis, Memcached) aux caches locaux intégrés (Caffeine, Guava Cache, Ehcache). Dans cet article, nous verrons comment intégrer chacun d'eux dans un projet Kotlin, nous donnerons des exemples de code et des recommandations pour faire votre choix.

1. Mise en cache intégrée sur JVM : Caffeine et Guava Cache

Pour la mise en cache locale en Kotlin, Caffeine est la meilleure option — une bibliothèque haute performance écrite en Java et entièrement compatible avec Kotlin. Elle prend en charge l'expulsion automatique basée sur le temps, la taille et le poids. L'alternative est Guava Cache de Google, mais Caffeine est plus rapide (souvent 2 à 3 fois plus).

Exemple : Caffeine + Kotlin

Ajoutez la dépendance dans build.gradle.kts :

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

Créons un cache de 1000 éléments avec un TTL de 10 minutes :

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

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

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

Exemple : 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

Quand les utiliser : pour stocker des données temporaires d'une seule instance d'application (par exemple, résultats de calculs complexes, jetons, configurations). Ne convient pas aux microservices avec plusieurs instances — les données ne sont pas synchronisées.

2. Redis — mise en cache distribuée pour les microservices

Redis est un stockage clé-valeur en mémoire utilisé comme cache distribué, courtier de messages et base de données. Pour Kotlin, le meilleur client est Lettuce (asynchrone, réactif, thread-safe).

Installation et connexion

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

Exemple : connexion et opérations de base

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

// Définir une clé avec un TTL de 60 secondescommands.setex("user:123", 60, "{\\"name\\":\\"Bob\\"}")

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

connection.close()client.shutdown()

Exemple : client réactif (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}

Quand l'utiliser : systèmes distribués, microservices, sessions partagées, rate limiting, pu