Caché en Java: Redis y otras soluciones

El caché es una de las técnicas clave para optimizar el rendimiento en aplicaciones Java. Permite reducir el tiempo de respuesta, disminuir la carga en bases de datos y APIs externas. En este artículo analizaremos herramientas populares de caché: Redis, Caffeine, Ehcache y las capacidades integradas de Spring Cache.

¿Por qué es necesario el caché en Java?

Sin caché, cada acceso a datos puede implicar operaciones costosas: consultas SQL, llamadas a REST API o cálculos complejos. El caché almacena los resultados de estas operaciones en acceso rápido (memoria RAM o almacenamiento distribuido), lo que proporciona:

Reducción del tiempo de respuesta (latencia)
Disminución de la carga en el backend
Ahorro de recursos del servidor
Escalabilidad bajo cargas elevadas

1. Redis — caché distribuido

Redis es un almacén de datos en memoria que se utiliza a menudo como caché distribuido. Soporta estructuras de datos complejas: cadenas, listas, conjuntos, hashes y conjuntos ordenados. Para Java existen clientes populares como Jedis y el más moderno Lettuce.

Conexión a Redis mediante Jedis

Agregue la dependencia en pom.xml:

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

Ejemplo de trabajo con caché Redis:

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Guardamos datos con TTL (tiempo de vida)            jedis.setex("user:123", 3600, "{\\"name\\":\\"Iván\\",\\"age\\":30}");

            // Leemos del caché            String cachedUser = jedis.get("user:123");            System.out.println("Desde caché: " + cachedUser);

            // Verificamos existencia de la clave            if (jedis.exists("user:123")) {                System.out.println("La clave existe");            }        }    }}

Ventajas de Redis: distribuido, persistencia, soporte de TTL, pub/sub, clustering. Desventajas: requiere un servidor separado, serialización de objetos.

2. Caffeine — caché local de alto rendimiento

Caffeine es una biblioteca moderna para caché en memoria en Java. Está basada en el algoritmo W-TinyLFU, que proporciona alta eficiencia con bajo consumo de memoria. Caffeine se utiliza a menudo en Spring Boot 2.x y 3.x como caché estándar.

Ejemplo con 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();

        // Escritura        cache.put("product:42", "Portátil Dell XPS 15");

        // Lectura con fallback        String product = cache.get("product:42", key -> loadFromDB(key));        System.out.println("Producto: " + product);

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

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

Ventajas de Caffeine: alta velocidad, expulsión automática, estadísticas, integración con Spring. Desventajas: solo local (no distribuido).