Mise en cache en Kotlin : Redis et autres solutions

Mise en cache en Kotlin : Redis et autres solutions

La mise en cache est l'un des mécanismes clés d'optimisation des performances dans les applications modernes. Dans l'écosystème Kotlin, grâce à la compatibilité totale avec Java et à la riche bibliothèque JVM, tous les outils principaux pour travailler avec le cache sont disponibles. Dans cet article, nous verrons comment organiser la mise en cache en Kotlin en utilisant Redis, Caffeine et Ehcache, et nous analyserons quel outil choisir selon le cas.

Pourquoi la mise en cache est-elle nécessaire ?

Le cache permet de réduire le temps de réponse de l'application en stockant les données fréquemment demandées dans une mémoire à accès rapide. Cela est particulièrement pertinent pour :

• les API REST à forte charge ;
• le travail avec des API externes et des bases de données ;
• les calculs gourmands en ressources ;
• les données de session utilisateur.

Stratégies de mise en cache principales

Avant de choisir une bibliothèque, il est important de comprendre les stratégies de base :

• Cache-Aside — l'application gère elle-même le cache : elle vérifie d'abord le cache, en cas d'échec elle charge les données depuis la base de données et les place dans le cache.
• Read-Through — le cache charge automatiquement les données depuis la source en cas d'échec.
• Write-Through / Write-Behind — l'écriture des données se fait simultanément (ou de manière asynchrone) dans le cache et dans le stockage principal.

1. Redis depuis Kotlin

Redis est un stockage clé-valeur en mémoire, souvent utilisé comme cache distribué. Pour travailler avec Redis en Kotlin, on utilise le client Lettuce (asynchrone, réactif) ou Jedis (synchrone).

Ajout de Lettuce

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

Exemple de travail avec Redis via 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() // API coroutines

    // Écriture    commands.setex("user:123:profile", 3600, "{\\"name\\":\\"Alice\\"}")        // Lecture    val cached = commands.get("user:123:profile")    println("Depuis le cache : $cached")        connection.close()    client.shutdown()}

Quand utiliser Redis ?

• Besoin d'un cache distribué entre plusieurs instances de l'application.
• Haute disponibilité et réplication requises.
• Les données doivent être disponibles après le redémarrage de l'application (persistance Redis).
• Nécessité de prendre en charge des structures complexes (listes, ensembles, files d'attente).

2. Caffeine — cache local haute performance

Caffeine est une bibliothèque de mise en cache en mémoire pour la JVM, écrite en Java. Elle est souvent utilisée avec Spring Boot, mais fonctionne également très bien avec Kotlin pur. Caffeine offre une latence quasi nulle en lecture.

Ajout de Caffeine

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

Exemple d'utilisation de Caffeine en 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)}

// Exemple avec chargement automatique (LoadingCache)val loadingCache = Caffeine.newBuilder()    .maximumSize(5_000)    .build<Int, User>