Caching en Java: Redis, Caffeine, Ehcache — guía completa

Caching en Java: Redis, Caffeine, Ehcache y JCache

El caching es una de las herramientas clave para mejorar el rendimiento de las aplicaciones Java. Permite reducir el tiempo de respuesta, disminuir la carga en las bases de datos y las API externas. En este artículo analizaremos tres soluciones populares: Redis (caché distribuido externo), Caffeine (caché en memoria de alto rendimiento) y Ehcache (caché híbrido con soporte de disco). También veremos el estándar JCache (JSR 107), que unifica el trabajo con cachés.

¿Por qué es necesario el caching en Java?

Los principales escenarios de uso son:

• Reducción de latencia — los datos de la caché se devuelven en microsegundos, no en milisegundos (como en una consulta a la BD).
• Disminución de la carga — la caché protege la base de datos de consultas repetitivas.
• Ahorro de recursos — menos llamadas a servicios externos → menos costos de infraestructura.

1. Redis — caché distribuido para microservicios

Redis es un almacén de datos en memoria que se utiliza a menudo como caché distribuido. Soporta varias estructuras de datos: cadenas, hashes, listas, conjuntos. Para Java hay dos clientes principales: Jedis y Lettuce (recomendado para Spring Boot).

Ejemplo de conexión con Spring Data Redis:

@Configurationpublic class RedisConfig {    @Bean    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {        RedisTemplate<String, Object> template = new RedisTemplate<>();        template.setConnectionFactory(connectionFactory);        template.setKeySerializer(new StringRedisSerializer());        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());        return template;    }}

@Servicepublic class UserService {    @Autowired    private RedisTemplate<String, Object> redisTemplate;

    public User getUserById(String id) {        String key = "user:" + id;        User cached = (User) redisTemplate.opsForValue().get(key);        if (cached != null) return cached;

        User user = database.findUserById(id); // consulta costosa        redisTemplate.opsForValue().set(key, user, 10, TimeUnit.MINUTES);        return user;    }}

Ventajas de Redis: distribución, soporte de TTL, pub/sub, persistencia. Desventajas: latencia de red, consumo de memoria en el servidor.

2. Caffeine — caché en memoria ultrarrápido

Caffeine es una biblioteca para caching local basada en el algoritmo W-TinyLFU. Proporciona una tasa de aciertos casi del 100% con un consumo mínimo de memoria. Ideal para aplicaciones de un solo hilo y multihilo.

Ejemplo de uso de Caffeine:

Cache<String, User> cache = Caffeine.newBuilder()    .expireAfterWrite(5, TimeUnit.MINUTES)    .maximumSize(10_000)    .recordStats()    .build();

public User getUser(String id) {    return cache.get(id, key -> database.findUserById(key));}

// Obtención de estadísticasCacheStats stats = cache.stats();System.out.println("Hit rate: " + stats.hitRate());

Ventajas de Caffeine: latencia mínima (nanosegundos), estadísticas integradas, eliminación automática de entradas antiguas. Desventajas: solo caché local, no apto para sistemas distribuidos.

3. Ehcache — caché híbrido con escritura en disco

Ehcache es una de las bibliotecas de caching más antiguas para Java. Soporta caching en memoria y en disco, así como agrupación en clúster a través de Terracotta. Se utiliza a menudo junto con Hibernate.

Ejemplo de configuración de Ehcache 3 (XML):

<config xmlns:xsi="http://www.w3.org