Mise en cache des données en Kotlin : du simple au professionnel

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Mise en cache des données en Kotlin : comment accélérer votre application 10 fois sans magie

Imaginez : vous ouvrez votre application préférée, et elle met 5 secondes à charger, affichant un écran « vide » et un spinner infini. Cela vous dit quelque chose ? Imaginez maintenant que le même programme s'ouvre instantanément, même sans Internet. Le secret réside dans une mise en cache judicieuse des données. Et aujourd'hui, nous allons voir comment l'implémenter en Kotlin pour que votre code soit non seulement rapide, mais aussi élégant.

Kotlin est un langage adoré pour sa concision et sa sécurité. Mais même avec le langage le plus performant, on peut écrire une application lente si l'on ne pense pas à la mise en cache. Dans cet article, nous passerons du simple cache in-memory aux solutions avancées avec Redis et DiskLruCache. Vous apprendrez à mettre en cache des données en Kotlin pour que vos utilisateurs oublient les temps de chargement et que votre serveur oublie les requêtes inutiles.

Pourquoi mettre en cache des données en Kotlin ?

La mise en cache, c'est comme une bonne habitude : difficile au début, indispensable ensuite. Voici trois raisons pour lesquelles votre application Kotlin a besoin d'un cache :

Vitesse : les données en mémoire se lisent en microsecondes, pas en secondes comme depuis un serveur ou un disque.
Économie de bande passante : moins de requêtes à l'API signifie moins de coûts pour les serveurs et l'Internet mobile.
Mode hors ligne : les utilisateurs adorent que l'application fonctionne même dans le métro sans connexion.

Mais attention : une mauvaise mise en cache peut entraîner des fuites mémoire (OutOfMemoryError — bonjour le passé) ou l'affichage de données obsolètes. Alors, voyons comment bien faire les choses.

Cache in-memory : le moyen le plus simple d'accélérer une application Kotlin

Commençons par les bases : la mise en cache en mémoire vive. C'est comme poser les outils nécessaires sur votre bureau plutôt que d'aller les chercher dans le garage à chaque fois.

La solution la plus simple est d'utiliser HashMap ou ConcurrentHashMap (si vous travaillez avec du multithreading). Mais en Kotlin, nous pouvons faire plus élégant :

class SimpleCache<K, V>(    private val maxSize: Int = 100) {    private val cache = LinkedHashMap<K, V>(0, 0.75f, true) // ordre d'accès

    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()    }}

Ce cache supprime automatiquement l'élément le plus ancien lorsqu'il atteint la limite. Mais il y a un problème : il ne tient pas compte de la durée de vie des données. Supposons que vous ayez mis en cache une liste de taux de change, et qu'une heure plus tard le taux ait changé, mais que l'utilisateur voie les anciennes données. Pas idéal.

Ajout du 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 minute    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)    }}

Maintenant, les données vivent exactement le temps nécessaire. Idéal pour la mise en cache des réponses API où les données changent peu souvent (par exemple, une liste de catégories de produits).