Mise en cache en Kotlin : Redis, Caffeine et autres solutions

Mise en cache en Kotlin : Redis, Caffeine et alternatives

La mise en cache est l'un des outils clés pour améliorer les performances des applications. En Kotlin, grâce à la compatibilité avec Java et au riche écosystème JVM, de nombreuses solutions sont disponibles : du cache léger en mémoire aux systèmes distribués basés sur Redis. Dans cet article, nous examinerons les bibliothèques populaires, leur configuration et des exemples d'utilisation.

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

Les principaux objectifs de la mise en cache :

• Réduire le temps de réponse (latence) en stockant les données fréquemment demandées dans une mémoire rapide.
• Diminuer la charge sur les bases de données et les API externes.
• Économiser les ressources de calcul lors de requêtes répétitives.

Kotlin permet d'utiliser à la fois des bibliothèques Java natives et des wrappers Kotlin spécialisés.

1. Redis via Lettuce ou Redisson

Redis est le magasin de données en mémoire le plus populaire pour la mise en cache distribuée. En Kotlin, on y accède via les clients Lettuce (réactif) ou Redisson (synchrone/asynchrone).

Exemple : mise en cache avec Lettuce

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

// CacheService.ktimport io.lettuce.core.RedisClientimport io.lettuce.core.api.sync.RedisCommands

class RedisCache(private val host: String = "localhost", private val port: Int = 6379) {    private val client: RedisClient = RedisClient.create("redis://$host:$port")    private val connection = client.connect()    private val sync: RedisCommands<String, String> = connection.sync()

    fun get(key: String): String? = sync.get(key)    fun set(key: String, value: String, ttlSeconds: Long = 60) {        sync.setex(key, ttlSeconds, value)    }    fun delete(key: String) = sync.del(key)    fun close() {        connection.close()        client.shutdown()    }}

// Utilisationfun main() {    val cache = RedisCache()    cache.set("user:123", """{"name":"Alice","role":"admin"}""", 120)    val data = cache.get("user:123")    println(data) // {"name":"Alice","role":"admin"}    cache.close()}

Redisson — une API de plus haut niveau

implementation("org.redisson:redisson:3.27.2")

val config = Config().apply {    useSingleServer().setAddress("redis://127.0.0.1:6379")}val redisson = Redisson.create(config)val map = redisson.getMap<String, String>("userCache")map["user:456"] = """{"name":"Bob"}"""val bob = map["user:456"]redisson.shutdown()

2. Caffeine — cache en mémoire rapide

Caffeine est le remplacement moderne de Guava Cache. Optimisé pour les charges élevées, il prend en charge l'expulsion automatique des entrées obsolètes.

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

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

val cache: Cache<String, String> = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(10_000)    .recordStats()    .build()

// Écriture et lecturecache.put("key1", "value1")val value = cache.getIfPresent("key1")println(value) // value1

// Statistiquesval stats = cache.stats()println("Hit rate: ${stats.hitRate()}")

3. Hazelcast — cache distribué avec clustering

Hazelcast convient aux architectures de microservices : le cache se synchronise automatiquement entre les nœuds.

implementation("com.hazelcast:hazelcast:5.3.6")

import com.hazelcast.core.Hazelcastimport com.hazelcast.map.IMap

val instance = Hazelcast.newHazelcastInstance()val map: IMap<String, String> = instance.getMap("session-cache")map.put("session:token123", "userId=42", 30, TimeUnit.MINUTES)val userId = map.get("session:token123")instance.shutdown()

4. Spring C