Caché de datos en Kotlin: de principiante a experto

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é de datos en Kotlin: cómo acelerar tu aplicación 10 veces sin magia

Imagina: abres tu aplicación favorita y tarda 5 segundos en cargar, mostrando una pantalla de carga y un spinner infinito. ¿Te suena? Ahora imagina que el mismo programa se abre al instante, incluso sin internet. El secreto está en un buen caché de datos. Y hoy veremos cómo implementarlo en Kotlin para que tu código no solo sea rápido, sino también elegante.

Kotlin es un lenguaje amado por su concisión y seguridad. Pero incluso con el mejor lenguaje, puedes escribir una aplicación lenta si no piensas en el caché. En este artículo, recorreremos el camino desde un simple caché en memoria hasta soluciones avanzadas con Redis y DiskLruCache. Aprenderás a cachear datos en Kotlin para que los usuarios olviden las cargas y el servidor, las peticiones innecesarias.

¿Por qué cachear datos en Kotlin?

El caché es como un buen hábito: al principio es difícil, luego indispensable. Aquí tienes tres razones por las que tu aplicación en Kotlin necesita caché:

Velocidad: los datos en memoria se leen en microsegundos, no en segundos como desde el servidor o el disco.
Ahorro de datos: menos peticiones a la API significan menos gasto en servidores y datos móviles.
Modo offline: a los usuarios les encanta que la aplicación funcione incluso en el metro sin conexión.

Pero hay un detalle: un caché incorrecto puede provocar fugas de memoria (OutOfMemoryError, un saludo del pasado) o mostrar datos desactualizados. Así que vamos a aprender a hacerlo bien.

Caché en memoria: la forma más sencilla de acelerar tu aplicación Kotlin

Empecemos con lo básico: el caché en RAM. Es como tener las herramientas necesarias en tu escritorio, en lugar de ir al garaje cada vez.

La opción más simple es usar HashMap o ConcurrentHashMap (si trabajas con concurrencia). Pero en Kotlin podemos hacerlo de forma más elegante:

class SimpleCache<K, V>(    private val maxSize: Int = 100) {    private val cache = LinkedHashMap<K, V>(0, 0.75f, true) // access-order

    fun get(key: K): V? {        return cache[key]    }

    fun put(key: K, value: V) {        if (cache.size >= maxSize) {            val oldest = cache.keys.firstOrNull()            oldest?.let { cache.remove(it) }        }        cache[key] = value    }

    fun clear() {        cache.clear()    }}

Este caché elimina automáticamente el elemento más antiguo cuando alcanza el límite. Pero hay un problema: no tiene en cuenta el tiempo de vida de los datos. Supón que has cacheado una lista de tipos de cambio y, una hora después, el tipo ha cambiado, pero el usuario ve datos antiguos. No es bueno.

Añadiendo TTL (Time To Live)

data class CacheEntry<T>(    val data: T,    val expirationTime: Long)

class TTLCache<K, V>(    private val ttlMillis: Long = 60_000, // 1 minuto    private val maxSize: Int = 100) {    private val cache = LinkedHashMap<K, CacheEntry<V>>(0, 0.75f, true)

    fun get(key: K): V? {        val entry = cache[key] ?: return null        if (System.currentTimeMillis() > entry.expirationTime) {            cache.remove(key)            return null        }        return entry.data    }

    fun put(key: K, value: V) {        if (cache.size >= maxSize) {            val oldest = cache.keys.firstOrNull()            oldest?.let { cache.remove(it) }        }        cache[key] = CacheEntry(value, System.currentTimeMillis() + ttlMillis)    }}

Ahora los datos viven exactamente el tiempo necesario. Ideal para cachear respuestas de API cuyos datos cambian con poca frecuencia (por ejemplo, una lista de categorías de productos).