Caché en Kotlin: Redis, Caffeine y Ehcache — guía completa

Caché en Kotlin: Redis y otras herramientas para acelerar aplicaciones

El caché es uno de los mecanismos clave para mejorar el rendimiento de las aplicaciones modernas. En el ecosistema de Kotlin (al igual que en Java), hay varias bibliotecas potentes disponibles para organizar el almacenamiento en caché: desde soluciones simples en memoria hasta sistemas distribuidos basados en Redis. En este artículo, analizaremos las herramientas populares, su configuración y ejemplos de uso en el lenguaje Kotlin.

¿Por qué es necesario el caché?

El caché permite reducir el tiempo de respuesta de la aplicación, disminuir la carga en la base de datos y las API externas. Escenarios principales:

• Solicitudes repetitivas a los mismos datos (por ejemplo, directorios, configuraciones);
• Cálculos con tiempo de ejecución prolongado (generación de informes, agregaciones complejas);
• Trabajo con servicios externos (limitación por rate limit, retrasos de red).

1. Redis — caché distribuido

Redis es un almacén de datos en memoria que se utiliza a menudo como caché distribuido. En el ecosistema Kotlin/Java, los principales clientes son Lettuce y Jedis. Para Spring Boot, se recomienda usar spring-boot-starter-data-redis.

Ejemplo de integración de Redis con Kotlin y Spring Boot

// build.gradle.ktsimplementation("org.springframework.boot:spring-boot-starter-data-redis")implementation("org.springframework.boot:spring-boot-starter-cache")

// application.ymlspring:  cache:    type: redis  redis:    host: localhost    port: 6379

// Servicio con caché@Serviceclass UserService(private val userRepository: UserRepository) {

    @Cacheable("users")    fun getUserById(id: Long): User {        // Simulación de una consulta larga        Thread.sleep(2000)        return userRepository.findById(id).orElseThrow()    }

    @CacheEvict("users", key = "#id")    fun deleteUser(id: Long) {        userRepository.deleteById(id)    }}

La anotación @Cacheable guarda automáticamente el resultado en Redis, y @CacheEvict elimina la entrada cuando los datos cambian.

2. Caffeine — caché en memoria de alto rendimiento

Caffeine es una biblioteca moderna para almacenamiento en caché local que supera significativamente a Guava Cache en velocidad y funcionalidad. Es ideal para arquitecturas de un solo hilo o de microservicios.

Configuración de Caffeine en Kotlin

// Dependenciaimplementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

// Creación del cachéval cache: Cache<String, User> = Caffeine.newBuilder()    .expireAfterWrite(10, TimeUnit.MINUTES)    .maximumSize(1000)    .recordStats()    .build()

// Usofun getUser(id: String): User {    return cache.get(id) { key ->        // Función de carga si la clave no existe        userRepository.findById(key).orElseThrow()    }}

// Obtener estadísticasprintln("Hit rate: ${cache.stats().hitRate()}")

Caffeine admite la expulsión automática de entradas antiguas (expire after write/access), límite de tamaño y recopilación de estadísticas para monitoreo.

3. Ehcache — solución madura con soporte de almacenamiento en disco

Ehcache es una de las bibliotecas de almacenamiento en caché más antiguas para Java. Admite almacenamiento en varios niveles (heap, off-heap, disk) y agrupación en clústeres. Para Kotlin se utiliza la API estándar de Java.

Ejemplo con Ehcache 3 y configuración XML

// Dependenciaimplementation("org.ehcache:ehcache:3.10.8")

// Configuración (ehcache.xml)<config xmlns="http://www.ehcache.org/v3">    <cache alias="users">        <key-type>java.lang.Long</key-type>        <value-type>com.example.User</value-type>        <resources>            <heap unit="entries">100</heap>            <offheap unit="MB">10</offheap>        </res