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

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

Introdução: Por que usar cache em Java?

Aplicações Java modernas frequentemente trabalham com grandes volumes de dados. Cada requisição ao banco de dados ou API externa consome tempo e recursos. Sem cache, à medida que a carga aumenta, o desempenho cai e o tempo de resposta aumenta. O cache permite armazenar dados frequentemente solicitados em acesso rápido (na memória RAM), reduzindo latências e aliviando a carga no backend.

Em Java, existem três abordagens principais para cache: soluções embutidas (por exemplo, HashMap ou Caffeine), sistemas distribuídos (Redis e Memcached). Neste artigo, analisaremos cada uma delas, forneceremos exemplos de código e ajudaremos você a escolher a opção ideal para o seu projeto.

1. Cache embutido em Java

O cache embutido é a maneira mais simples de acelerar uma aplicação. Os dados são armazenados diretamente na memória da JVM. Principais vantagens: latência de acesso mínima, facilidade de configuração. Desvantagens: volume limitado (depende do heap), os dados são perdidos ao reiniciar a aplicação.

1.1. Cache simples com HashMap

A opção mais básica é usar um ConcurrentHashMap com gerenciamento manual do tempo de vida. Adequado para protótipos, mas não para produção (sem limpeza automática, possíveis vazamentos de memória).

import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;

public class SimpleCache {    private final ConcurrentHashMap<String, CacheEntry> cache = new ConcurrentHashMap<>();

    public void put(String key, Object value, long ttlMillis) {        cache.put(key, new CacheEntry(value, System.currentTimeMillis() + ttlMillis));    }

    public Object get(String key) {        CacheEntry entry = cache.get(key);        if (entry == null || System.currentTimeMillis() > entry.expiry) {            cache.remove(key);            return null;        }        return entry.value;    }

    private static class CacheEntry {        private final Object value;        private final long expiry;        // construtor e getters    }}

1.2. Caffeine — biblioteca moderna de cache

Caffeine é uma biblioteca de alto desempenho para Java, usada por padrão no Spring Cache. Ela suporta evicção automática por tempo, tamanho e também elementos ponderados. Caffeine é mais rápido que o Guava Cache (no qual foi baseado).

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

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

        cache.put("user:123", "John Doe");        String user = cache.getIfPresent("user:123");        System.out.println("Usuário em cache: " + user);    }}

Para produção, recomenda-se usar Caffeine ou Ehcache (que suporta armazenamento em disco). Soluções embutidas são ideais para microsserviços e monolitos com uma única instância.

2. Memcached: cache distribuído para Java

Memcached é um sistema de cache distribuído que opera na memória RAM. É simples, rápido e suporta escalabilidade horizontal. Principais características: