Cache em Java: Redis e outras soluções

Cache é uma das principais técnicas de otimização de desempenho em aplicações Java. Ele permite reduzir o tempo de resposta, diminuir a carga em bancos de dados e APIs externas. Neste artigo, abordaremos ferramentas populares de cache: Redis, Caffeine, Ehcache e os recursos integrados do Spring Cache.

Por que o cache é necessário em Java?

Sem cache, cada acesso a dados pode envolver operações custosas: consultas SQL, chamadas REST API ou cálculos complexos. O cache armazena os resultados dessas operações em acesso rápido (memória RAM ou armazenamento distribuído), proporcionando:

Redução do tempo de resposta (latência)
Diminuição da carga no backend
Economia de recursos do servidor
Escalabilidade sob altas cargas

1. Redis — cache distribuído

Redis é um armazenamento de dados in-memory frequentemente usado como cache distribuído. Ele suporta estruturas de dados complexas: strings, listas, conjuntos, hashes e conjuntos ordenados. Para Java, existem clientes populares como Jedis e o mais moderno Lettuce.

Conectando Redis via Jedis

Adicione a dependência no pom.xml:

<dependency>    <groupId>redis.clients</groupId>    <artifactId>jedis</artifactId>    <version>5.0.2</version></dependency>

Exemplo de uso do cache Redis:

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Salva dados com TTL (tempo de vida)            jedis.setex("user:123", 3600, "{\\"name\\":\\"João\\",\\"age\\":30}");

            // Lê do cache            String cachedUser = jedis.get("user:123");            System.out.println("Do cache: " + cachedUser);

            // Verifica se a chave existe            if (jedis.exists("user:123")) {                System.out.println("Chave existe");            }        }    }}

Vantagens do Redis: distribuído, persistência, suporte a TTL, pub/sub, clusterização. Desvantagens: requer um servidor separado, serialização de objetos.

2. Caffeine — cache local de alto desempenho

Caffeine é uma biblioteca moderna para cache in-memory em Java. Baseada no algoritmo W-TinyLFU, oferece alta eficiência com baixo consumo de memória. O Caffeine é frequentemente usado no Spring Boot 2.x e 3.x como cache padrão.

Exemplo com Caffeine

import com.github.benmanes.caffeine.cache.Cache;import com.github.benmanes.caffeine.cache.Caffeine;import java.util.concurrent.TimeUnit;

public class CaffeineCacheExample {    public static void main(String[] args) {        Cache<String, String> cache = Caffeine.newBuilder()                .expireAfterWrite(10, TimeUnit.MINUTES)                .maximumSize(10_000)                .recordStats()                .build();

        // Escrita        cache.put("product:42", "Notebook Dell XPS 15");

        // Leitura com fallback        String product = cache.get("product:42", key -> loadFromDB(key));        System.out.println("Produto: " + product);

        // Estatísticas        System.out.println("Acertos: " + cache.stats().hitCount());    }

    private static String loadFromDB(String key) {        // Simula carregamento do banco        return "Produto pela chave " + key;    }}

Vantagens do Caffeine: alta velocidade, evicção automática, estatísticas, integração com Spring. Desvantagens: apenas local (não distribuído).