Caché en Java: Redis, Memcached y soluciones integradas de la A a la Z

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Caché en Java: Redis, Memcached y soluciones integradas: de la A a la Z

El caché es una de las herramientas clave para mejorar el rendimiento de las aplicaciones Java. Permite reducir el tiempo de respuesta, disminuir la carga en bases de datos y API externas, así como mejorar la experiencia del usuario. En este artículo, analizaremos tres enfoques principales para el caché en Java: soluciones integradas (ConcurrentHashMap, Caffeine, Ehcache), sistemas distribuidos (Redis) y cachés de red ligeros (Memcached). Aprenderá cuándo y qué elegir, y obtendrá ejemplos de código listos para usar.

¿Qué es el caché y por qué es necesario en Java?

El caché es el almacenamiento temporal de datos solicitados con frecuencia en un almacenamiento rápido (generalmente en memoria RAM). En Java, esto es especialmente relevante para:

Reducir latencias — los datos del caché se devuelven en microsegundos, no en milisegundos (como desde la BD).
Disminuir la carga en recursos — las bases de datos, servicios externos y discos trabajan menos.
Ahorrar recursos — menos operaciones de CPU y E/S.

Las métricas principales del caché: hit ratio (porcentaje de accesos exitosos) y TTL (tiempo de vida de una entrada).

Soluciones integradas: de lo simple a lo avanzado

Para proyectos pequeños o escenarios de un solo hilo, se pueden usar estructuras de datos simples. Sin embargo, para aplicaciones industriales, es mejor utilizar bibliotecas especializadas.

1. ConcurrentHashMap — caché básico

La forma más simple es usar ConcurrentHashMap. Es seguro para subprocesos, pero no tiene mecanismos de limpieza automática (TTL, eviction).

import java.util.concurrent.ConcurrentHashMap;

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

    public void put(String key, Object value) {        cache.put(key, value);    }

    public Object get(String key) {        return cache.get(key);    }

    public void evict(String key) {        cache.remove(key);    }

    public void clear() {        cache.clear();    }}

Ventajas: simplicidad, dependencia cero.
Desventajas: sin invalidación automática, gestión manual de memoria.

2. Caffeine — caché moderno de alto rendimiento

La biblioteca Caffeine es el estándar de facto para el caché en memoria en Java. Soporta:

Expulsión automática por tiempo (TTL) y tamaño.
Carga asíncrona.
Estadísticas (hit rate, miss rate).

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)                .recordStats() // para recopilar estadísticas                .build();

        // Agregar        cache.put("user:1", "Alice");

        // Obtener con carga automática        String value = cache.get("user:2", key -> loadFromDB(key));        System.out.println(value);    }

    private static String loadFromDB(String key) {        // Simulación de carga desde BD        return "Bob";    }}

Ventajas: alto rendimiento, flexibilidad, tamaño pequeño (aproximadamente 600 KB).
Desventajas: solo local (no distribuido).