Cache em Kotlin: Redis, Caffeine e outras soluções

Cache em Kotlin: Redis, Caffeine e alternativas

Cache é uma das ferramentas-chave para melhorar o desempenho de aplicações. Em Kotlin, graças à compatibilidade com Java e ao rico ecossistema JVM, estão disponíveis diversas soluções: desde cache in-memory leve até sistemas distribuídos baseados em Redis. Neste artigo, analisaremos bibliotecas populares, sua configuração e exemplos de uso.

Por que o cache é necessário?

Os principais objetivos do cache:

• Redução do tempo de resposta (latência) armazenando dados frequentemente solicitados em memória rápida.
• Diminuição da carga em bancos de dados e APIs externas.
• Economia de recursos computacionais em requisições repetitivas.

Kotlin permite usar tanto bibliotecas Java nativas quanto wrappers especializados em Kotlin.

1. Redis via Lettuce ou Redisson

Redis é o data store in-memory mais popular para cache distribuído. Em Kotlin, ele é integrado através dos clientes Lettuce (reativo) ou Redisson (síncrono/assíncrono).

Exemplo: cache com 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()    }}

// Usofun 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 — API de nível mais alto

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 in-memory rápido

Caffeine é o substituto moderno do Guava Cache. Otimizado para altas cargas, suporta remoção automática de entradas expiradas.

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

// Escrita e leituracache.put("key1", "value1")val value = cache.getIfPresent("key1")println(value) // value1

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

3. Hazelcast — cache distribuído com clusterização

Hazelcast é adequado para arquiteturas de microsserviços: o cache é automaticamente sincronizado entre os nós.

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