Mise en cache en Java : Redis, Caffeine et autres outils

Mise en cache en Java : Redis et autres solutions

La mise en cache est l'une des techniques clés d'optimisation des performances dans les applications Java. Elle permet de réduire le temps de réponse, de diminuer la charge sur les bases de données et les API externes. Dans cet article, nous examinerons les outils de mise en cache populaires : Redis, Caffeine, Ehcache et les fonctionnalités intégrées de Spring Cache.

Pourquoi la mise en cache en Java est-elle nécessaire ?

Sans cache, chaque accès aux données peut déclencher des opérations coûteuses : requêtes SQL, appels REST API ou calculs complexes. Le cache stocke les résultats de ces opérations dans un accès rapide (mémoire vive ou stockage distribué), ce qui offre :

• Réduction du temps de réponse (latence)
• Diminution de la charge sur le backend
• Économie des ressources serveur
• Scalabilité sous forte charge

1. Redis — mise en cache distribuée

Redis est un magasin de données en mémoire souvent utilisé comme cache distribué. Il prend en charge des structures de données complexes : chaînes, listes, ensembles, hachages et ensembles triés. Pour Java, il existe le client populaire Jedis et le plus moderne Lettuce.

Connexion à Redis via Jedis

Ajoutez la dépendance dans pom.xml :

<dependency>    <groupId>redis.clients</groupId>    <artifactId>jedis</artifactId>    <version>5.0.2</version></dependency>

Exemple de travail avec le cache Redis :

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Enregistrer des données avec TTL (durée de vie)            jedis.setex("user:123", 3600, "{\\"name\\":\\"Иван\\",\\"age\\":30}");

            // Lire depuis le cache            String cachedUser = jedis.get("user:123");            System.out.println("Depuis le cache : " + cachedUser);

            // Vérifier l'existence de la clé            if (jedis.exists("user:123")) {                System.out.println("La clé existe");            }        }    }}

Avantages de Redis : distribution, persistance, support TTL, pub/sub, clustering. Inconvénients : nécessite un serveur dédié, sérialisation des objets.

2. Caffeine — cache local haute performance

Caffeine est une bibliothèque moderne de mise en cache en mémoire pour Java. Elle est basée sur l'algorithme W-TinyLFU, qui offre une haute efficacité avec une faible consommation mémoire. Caffeine est souvent utilisé dans Spring Boot 2.x et 3.x comme cache par défaut.

Exemple avec Caffeine

import com.github.benmanes.caffeine.cache.Cache;import com.github.benmanes.caffeine.cache.Caffeine;import java.util.concurrent.TimeUnit;

public class CaffeineCacheExample {    public static void main(String[] args) {        Cache<String, String> cache = Caffeine.newBuilder()                .expireAfterWrite(10, TimeUnit.MINUTES)                .maximumSize(10_000)                .recordStats()                .build();

        // Écriture        cache.put("product:42", "Ноутбук Dell XPS 15");

        // Lecture avec fallback        String product = cache.get("product:42", key -> loadFromDB(key));        System.out.println("Produit : " + product);

        // Statistiques        System.out.println("Succès : " + cache.stats().hitCount());    }

    private static String loadFromDB(String key) {        // Simulation de chargement depuis la base de données        return "Produit pour la clé " + key;    }}

Avantages de Caffeine : haute vitesse, éviction automatique, statistiques, intégration avec Spring. Inconvénients : uniquement local (non distribué).

3. Ehcache — cache local mature

Ehcache