Caché en Java: Redis, Memcached y soluciones integradas para profesionales

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: nivel avanzado

El almacenamiento en caché es una de las herramientas clave para mejorar el rendimiento y la escalabilidad de las aplicaciones Java. A nivel avanzado, el desarrollador se enfrenta a la elección entre sistemas distribuidos (Redis, Memcached) y cachés integrados ligeros (Caffeine, Guava). En este artículo, analizaremos las diferencias arquitectónicas, los escenarios de uso y proporcionaremos ejemplos prácticos de código para cada solución.

1. Cachés integrados: Caffeine y Guava

Los cachés integrados funcionan dentro de la JVM y no requieren servicios externos. Son ideales para almacenar datos temporales que no necesitan sincronizarse entre nodos.

Caffeine: el estándar moderno

Caffeine es una biblioteca de alto rendimiento para el almacenamiento en caché en Java que reemplazó a Guava Cache. Utiliza el algoritmo Window TinyLFU para una expulsión eficiente de entradas.

// Dependencia Maven// <dependency>//     <groupId>com.github.ben-manes.caffeine</groupId>//     <artifactId>caffeine</artifactId>//     <version>3.1.8</version>// </dependency>

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, User> userCache = Caffeine.newBuilder()                .expireAfterWrite(10, TimeUnit.MINUTES)                .maximumSize(10_000)                .recordStats()                .build();

        // Escritura        userCache.put("user:123", new User("Alice", "alice@example.com"));

        // Lectura        User user = userCache.getIfPresent("user:123");        System.out.println("Cached user: " + user);

        // Lectura atómica con carga        User result = userCache.get("user:456", key -> loadUserFromDB(key));    }

    private static User loadUserFromDB(String key) {        // Simulación de carga desde BD        return new User("Bob", "bob@example.com");    }

    static class User {        private final String name;        private final String email;

        User(String name, String email) {            this.name = name;            this.email = email;        }

        @Override        public String toString() {            return "User{name='" + name + "', email='" + email + "'}";        }    }}

Guava Cache: una solución probada

Guava Cache de Google sigue siendo una opción popular para proyectos que ya utilizan la biblioteca Guava. Admite varias estrategias de expulsión y escuchas.

import com.google.common.cache.CacheBuilder;import com.google.common.cache.CacheLoader;import com.google.common.cache.LoadingCache;

import java.util.concurrent.ExecutionException;import java.util.concurrent.TimeUnit;

public class GuavaCacheExample {    public static void main(String[] args) throws ExecutionException {        LoadingCache<String, String> cache = CacheBuilder.newBuilder()                .expireAfterAccess(5, TimeUnit.MINUTES)                .maximumSize(5000)                .removalListener(notification ->                     System.out.println("Removed: " + notification.getKey()))                .build(new CacheLoader<String, String>() {                    @Override                    public String load(String key) {                        return "Computed: " + key.toUpperCase();                    }                });

        // Escritura        cache.put("key1", "value1");

        // Lectura con carga automática        String value = cache.get("key2");        System.out.println(value); // "Computed: KEY2"    }}