Cache em Kotlin: Redis, Memcached e soluções embutidas

Introdução: Por que o cache é crítico para aplicações Kotlin de alta carga

No desenvolvimento moderno com Kotlin, especialmente na área de microsserviços e aplicações backend, o desempenho é um requisito fundamental. O cache permite reduzir drasticamente o tempo de resposta, diminuir a carga em bancos de dados e APIs externas, além de reduzir os custos de infraestrutura. Em um nível avançado, o desenvolvedor não deve apenas implementar o cache, mas escolher a estratégia ideal dependendo do cenário: cache distribuído (Redis, Memcached) ou soluções in-memory (Caffeine, Guava). Neste artigo, abordaremos técnicas avançadas de trabalho com cache em Kotlin, incluindo integração com corrotinas, configuração de TTL e padrões de invalidação.

1. Redis em Kotlin: Trabalho avançado com Lettuce e Redisson

1.1. Cache assíncrono com Lettuce

A biblioteca Lettuce é o padrão de facto para trabalhar com Redis a partir do Kotlin, devido ao suporte completo a fluxos reativos e assíncronos. Em um nível avançado, é importante usar a API Suspendable através de corrotinas.

import io.lettuce.core.RedisClientimport io.lettuce.core.api.coroutinesimport kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.map

class RedisCache(private val client: RedisClient) {    private val connection = client.connect()    private val commands = connection.coroutines() // API de corrotinas

    suspend fun get(key: String): String? = commands.get(key)

    suspend fun set(key: String, value: String, ttlSeconds: Long = 60) {        commands.setex(key, ttlSeconds, value)    }

    suspend fun invalidate(pattern: String) {        val keys = commands.keys(pattern)        if (keys.isNotEmpty()) commands.del(*keys.toTypedArray())    }}

Dica avançada: Use SCAN em vez de KEYS em produção para evitar o bloqueio do Redis em grandes conjuntos de dados.

1.2. Redisson: Bloqueios distribuídos e cache com camada local

Redisson oferece uma API de nível mais alto, incluindo bloqueios distribuídos e cache de dois níveis (Redis + Caffeine local). É ideal para cenários onde a consistência dos dados é crítica.

import org.redisson.Redissonimport org.redisson.config.Configimport org.redisson.api.RLocalCachedMap

class RedissonCache {    private val config = Config().apply {        useSingleServer().address = "redis://localhost:6379"    }    private val client = Redisson.create(config)

    fun getCachedMap<K, V>(name: String): RLocalCachedMap<K, V> {        return client.getLocalCachedMap(name, LocalCachedMapOptions.defaults())    }}

2. Memcached em Kotlin: Protocolo leve e alta velocidade

2.1. Conexão via xmemcached

Memcached continua sendo uma excelente escolha para cache simples de chave-valor sem necessidade de persistência. A biblioteca xmemcached oferece alto desempenho e suporte aos protocolos texto/binário.

import net.rubyeye.xmemcached.MemcachedClientBuilderimport net.rubyeye.xmemcached.XMemcachedClientimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.withContext

class MemcachedCache(private val client: XMemcachedClient) {    suspend fun get(key: String): Any? = withContext(Dispatchers.IO) {        client.get(key)    }

    suspend fun set(key: String, value: Any, ttl: Int = 3600) = withContext(Dispatchers.IO) {        client.set(key, ttl, value)    }}

Importante: Memcached não suporta estruturas de dados complexas; portanto, para listas ou hashes, use Redis ou serialização em JSON.

2.2. Otimização com protocolo binário

Em um nível avançado, ative o protocolo binário para reduzir a sobrecarga de análise de comandos:

val builder = Memcach