Cache em Kotlin: Redis, Memcached e soluções embutidas de A a Z

Cache em Kotlin: Redis, Memcached e soluções embutidas — de A a Z

Cache é uma das ferramentas-chave para melhorar o desempenho de aplicações. No ecossistema Kotlin, que roda sobre JVM e Android, o desenvolvedor tem à disposição diversas soluções: desde sistemas distribuídos (Redis, Memcached) até caches locais embutidos (Caffeine, Guava Cache, Ehcache). Neste artigo, vamos abordar como integrar cada um deles em um projeto Kotlin, fornecer exemplos de código e dar recomendações de escolha.

1. Cache embutido na JVM: Caffeine e Guava Cache

Para cache local em Kotlin, a melhor opção é o Caffeine — uma biblioteca de alto desempenho escrita em Java e totalmente compatível com Kotlin. Ela suporta remoção automática por tempo, por tamanho e com base em pesos. Uma alternativa é o Guava Cache do Google, mas o Caffeine é mais rápido (muitas vezes 2 a 3 vezes).

Exemplo: Caffeine + Kotlin

Adicione a dependência no build.gradle.kts:

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

Criamos um cache de 1000 elementos com TTL de 10 minutos:

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

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

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

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

Quando usar: para armazenar dados temporários de uma única instância da aplicação (por exemplo, resultados de cálculos complexos, tokens, configurações). Não é adequado para microsserviços com várias instâncias — os dados não são sincronizados.

2. Redis — cache distribuído para microsserviços

Redis é um armazenamento in-memory do tipo chave-valor, usado como cache distribuído, broker de mensagens e banco de dados. Para Kotlin, o melhor cliente é o Lettuce (assíncrono, reativo, thread-safe).

Instalação e conexão

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

Exemplo: conexão e operações básicas

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

// Definimos uma chave com TTL de 60 segundoscommands.setex("user:123", 60, "{\\"name\\":\\"Bob\\"}")

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

connection.close()client.shutdown()

Exemplo: cliente reativo (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}

Quando usar: sistemas distribuídos, microsserviços, sessões compartilhadas, rate limiting, pu