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

Aplicações modernas em Kotlin exigem alta velocidade de resposta e processamento eficiente de dados. Uma das ferramentas-chave para alcançar esse objetivo é o cache. Neste artigo, abordaremos três abordagens: uso de Redis, Memcached e soluções embutidas no nível da JVM. Você aprenderá como escolher a estratégia correta e obterá exemplos de código prontos para integração em seu projeto.

1. Cache embutido em Kotlin (In-Memory Cache)

A maneira mais simples é usar cache dentro da aplicação. Em Kotlin (rodando na JVM), você pode utilizar coleções padrão ou bibliotecas especializadas, como Caffeine ou Guava Cache.

Exemplo com Caffeine (recomendado)

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

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

Crie um serviço de cache:

import com.github.benmanes.caffeine.cache.Cache\nimport com.github.benmanes.caffeine.cache.Caffeine\nimport java.util.concurrent.TimeUnit\n\nclass UserCache {\n    private val cache: Cache<String, User> = Caffeine.newBuilder()\n        .expireAfterWrite(10, TimeUnit.MINUTES)\n        .maximumSize(1000)\n        .build()\n\n    fun getUser(id: String): User? = cache.getIfPresent(id)\n\n    fun putUser(id: String, user: User) {\n        cache.put(id, user)\n    }\n}

Vantagens: latência mínima, sem chamadas de rede, facilidade de configuração.
\nDesvantagens: o cache é perdido ao reiniciar a aplicação, limitado pela memória da JVM.

2. Cache com Redis em Kotlin

Redis é um poderoso armazenamento in-memory que suporta estruturas de dados complexas. Ideal para sistemas distribuídos.

Configuração via Spring Data Redis

Adicione a dependência:

implementation("org.springframework.boot:spring-boot-starter-data-redis")\nimplementation("org.jetbrains.kotlin:kotlin-reflect")

Configuração (application.yml):

spring:\n  redis:\n    host: localhost\n    port: 6379\n    timeout: 2000ms\n    lettuce:\n      pool:\n        max-active: 8\n        max-idle: 4

Exemplo de serviço com anotações Spring Cache:

import org.springframework.cache.annotation.Cacheable\nimport org.springframework.stereotype.Service\n\n@Service\nclass ProductService {\n\n    @Cacheable("products", key = "#id")\n    fun getProduct(id: Long): Product {\n        println("Carregando do BD: $id")\n        return Product(id, "Produto $id")\n    }\n}

Para trabalhar com Redis diretamente (sem Spring):

import io.lettuce.core.RedisClient\nimport io.lettuce.core.api.sync.RedisCommands\n\nclass RedisCache {\n    private val commands: RedisCommands<String, String>\n\n    init {\n        val client = RedisClient.create("redis://localhost:6379")\n        commands = client.connect().sync()\n    }\n\n    fun set(key: String, value: String, ttlSeconds: Long = 300) {\n        commands.setex(key, ttlSeconds, value)\n    }\n\n    fun get(key: String): String? = commands.get(key)\n}

Vantagens: cache distribuído, persistência, suporte a TTL e estruturas complexas.
\nDesvantagens: requer um servidor separado, latência ligeiramente maior (chamada de rede).

3. Cache com Memcached em Kotlin

Memcached é um armazenamento distribuído leve, otimizado para armazenar pequenos objetos em memória.

Conexão via biblioteca xmemcached

Adicione em build.gradle.kts:

implementation("com.googlecode.xmemcached:xmemcached:2.4.8")

Exemplo de uso:

import net.rubyeye.xmemcached.MemcachedClient\nimport net.rubyeye.xmemcached.XMem