Cache em Java: Redis, Ehcache, Caffeine, Hazelcast — visão geral e exemplos

Cache em Java: Redis e outras soluções

Cache é uma das principais técnicas de otimização de desempenho de aplicações Java. Ele permite reduzir o tempo de resposta, diminuir a carga nos bancos de dados e reduzir custos de infraestrutura. Neste artigo, abordaremos em detalhes as bibliotecas e ferramentas populares para cache em Java: Redis, Ehcache, Caffeine e Hazelcast. Você aprenderá quando e qual ferramenta escolher, além de ver exemplos práticos de código.

Por que usar cache?

Sem cache, cada requisição de dados resulta em leitura de um armazenamento lento (BD, API externa). O cache armazena dados frequentemente solicitados em memória rápida (in-process ou in-memory), proporcionando:

• Aceleração de acesso de 10 a 100 vezes
• Redução da carga no BD
• Aumento da capacidade de processamento do sistema
• Economia de recursos

1. Redis — cache distribuído

Redis é um armazenamento de dados in-memory que funciona como um servidor separado. Ele suporta estruturas de dados complexas (strings, listas, conjuntos, hashes) e mecanismos de expiração de chaves (TTL). Para Java, são usados os clientes Jedis ou Lettuce.

Exemplo de uso do Redis com Jedis

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Define valor com TTL de 60 segundos            jedis.setex("user:123", 60, "{\\"name\\":\\"Alice\\",\\"role\\":\\"admin\\"}");

            // Lê o valor            String userData = jedis.get("user:123");            System.out.println("Dados em cache: " + userData);

            // Verifica existência da chave            System.out.println("Chave existe: " + jedis.exists("user:123"));        }    }}

Vantagens do Redis:

• Suporte a clusterização e replicação
• Persistência (RDB, AOF)
• Conjunto rico de comandos (INCR, SORT, PUB/SUB)
• Excelente integração com Spring Boot via spring-boot-starter-data-redis

Desvantagens:

• Latência de rede (processo separado)
• Requer administração
• Não é adequado para caches com volumes muito pequenos de dados (overhead de conexão)

2. Ehcache — cache in-process maduro

Ehcache é uma das bibliotecas de cache mais antigas para Java. Funciona dentro da JVM, suporta armazenamento em disco (BigMemory) e é totalmente compatível com JCache (JSR-107). Ideal para aplicações monolíticas.

Exemplo de configuração do Ehcache via XML

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns="http://www.ehcache.org/v3"        xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.10.xsd">    <cache alias="users">        <key-type>java.lang.String</key-type>        <value-type>java.lang.String</value-type>        <heap>1000</heap>        <expiry>            <ttl unit="seconds">300</ttl>        </expiry>    </cache></config>

Exemplo de uso do Ehcache no código

import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.builders.CacheManagerBuilder;import org.ehcache.xml.XmlConfiguration;

public class EhcacheExample {    public static void main(String[] args) {        XmlConfiguration xmlConfig = new XmlConfiguration(            EhcacheExample.class.getResource("/ehcache.xml"));        try (CacheManager cacheManager = CacheManagerBuilder.newCacheManager(xmlConfig)) {            cacheManager.init();            Cache<String, String> users = cacheManager.getCache("u