Cache em Kotlin: Redis, Caffeine e Ehcache — guia completo

Cache em Kotlin: Redis e outras ferramentas para acelerar aplicações

Cache é um dos mecanismos-chave para melhorar o desempenho de aplicações modernas. No ecossistema Kotlin (assim como no Java), várias bibliotecas poderosas estão disponíveis para organizar o cache: desde soluções simples in-memory até sistemas distribuídos baseados em Redis. Neste artigo, abordaremos ferramentas populares, sua configuração e exemplos de uso na linguagem Kotlin.

Por que usar cache?

O cache permite reduzir o tempo de resposta da aplicação, diminuir a carga no banco de dados e em APIs externas. Principais cenários:

• Requisições repetidas aos mesmos dados (por exemplo, tabelas de referência, configurações);
• Cálculos com tempo de execução longo (geração de relatórios, agregações complexas);
• Trabalho com serviços externos (limitação de taxa, latências de rede).

1. Redis — cache distribuído

Redis é um armazenamento de dados in-memory frequentemente usado como cache distribuído. No ecossistema Kotlin/Java, os principais clientes são Lettuce e Jedis. Para Spring Boot, recomenda-se usar spring-boot-starter-data-redis.

Exemplo de integração Redis com Kotlin e Spring Boot

// build.gradle.ktsimplementation("org.springframework.boot:spring-boot-starter-data-redis")implementation("org.springframework.boot:spring-boot-starter-cache")

// application.ymlspring:  cache:    type: redis  redis:    host: localhost    port: 6379

// Serviço com cache@Serviceclass UserService(private val userRepository: UserRepository) {

    @Cacheable("users")    fun getUserById(id: Long): User {        // Simulação de requisição longa        Thread.sleep(2000)        return userRepository.findById(id).orElseThrow()    }

    @CacheEvict("users", key = "#id")    fun deleteUser(id: Long) {        userRepository.deleteById(id)    }}

A anotação @Cacheable salva automaticamente o resultado no Redis, enquanto @CacheEvict remove a entrada quando os dados são alterados.

2. Caffeine — cache in-memory de alto desempenho

Caffeine é uma biblioteca moderna para cache local, superando significativamente o Guava Cache em velocidade e funcionalidade. É ideal para arquiteturas single-thread ou de microsserviços.

Configuração do Caffeine em Kotlin

// Dependênciaimplementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

// Criação do cacheval cache: Cache<String, User> = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(1000)    .recordStats()    .build()

// Usofun getUser(id: String): User {    return cache.get(id) { key ->        // Função de carregamento se a chave não existir        userRepository.findById(key).orElseThrow()    }}

// Obtendo estatísticasprintln("Hit rate: ${cache.stats().hitRate()}")

Caffeine suporta remoção automática de entradas antigas (expire after write/access), limite de tamanho e coleta de estatísticas para monitoramento.

3. Ehcache — solução madura com suporte a armazenamento em disco

Ehcache é uma das bibliotecas de cache mais antigas para Java. Suporta armazenamento em múltiplos níveis (heap, off-heap, disk) e clusterização. Para Kotlin, usa-se a API Java padrão.

Exemplo com Ehcache 3 e configuração XML

// Dependênciaimplementation("org.ehcache:ehcache:3.10.8")

// Configuração (ehcache.xml)<config xmlns="http://www.ehcache.org/v3">    <cache alias="users">        <key-type>java.lang.Long</key-type>        <value-type>com.example.User</value-type>        <resources>            <heap unit="entries">100</heap>            <offheap unit="MB">10</offheap>        </res