Mise en cache en Java : Redis, Ehcache, Caffeine, Hazelcast — aperçu et exemples

Mise en cache en Java : Redis et autres solutions

La mise en cache est l'une des techniques clés pour optimiser les performances des applications Java. Elle permet de réduire le temps de réponse, de diminuer la charge sur les bases de données et de réduire les coûts d'infrastructure. Dans cet article, nous allons détailler les bibliothèques et outils populaires pour la mise en cache en Java : Redis, Ehcache, Caffeine et Hazelcast. Vous apprendrez quand et quel outil choisir, et vous verrez des exemples de code fonctionnels.

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

Sans cache, chaque requête de données entraîne une lecture depuis un stockage lent (BD, API externe). Le cache stocke les données fréquemment demandées dans une mémoire rapide (in-process ou in-memory), ce qui permet :

• Un accès 10 à 100 fois plus rapide
• Une réduction de la charge sur la BD
• Une augmentation du débit du système
• Une économie de ressources

1. Redis — cache distribué

Redis est un magasin de données in-memory fonctionnant comme un serveur séparé. Il prend en charge des structures de données complexes (chaînes, listes, ensembles, hachages) et des mécanismes d'expiration des clés (TTL). Pour Java, on utilise le client Jedis ou Lettuce.

Exemple d'utilisation de Redis avec Jedis

import redis.clients.jedis.Jedis;

public class RedisCacheExample {    public static void main(String[] args) {        try (Jedis jedis = new Jedis("localhost", 6379)) {            // Définit une valeur avec un TTL de 60 secondes            jedis.setex("user:123", 60, "{\\"name\\":\\"Alice\\",\\"role\\":\\"admin\\"}");

            // Lit la valeur            String userData = jedis.get("user:123");            System.out.println("Données mises en cache : " + userData);

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

Avantages de Redis :

• Prise en charge du clustering et de la réplication
• Persistance (RDB, AOF)
• Ensemble de commandes riche (INCR, SORT, PUB/SUB)
• Excellente intégration avec Spring Boot via spring-boot-starter-data-redis

Inconvénients :

• Latence réseau (processus séparé)
• Nécessite de l'administration
• Pas adapté aux caches de très petits volumes de données (surcharge de connexion)

2. Ehcache — cache in-process mature

Ehcache est l'une des plus anciennes bibliothèques de mise en cache pour Java. Il fonctionne au sein de la JVM, prend en charge le stockage sur disque (BigMemory) et est entièrement compatible avec JCache (JSR-107). Idéal pour les applications monolithiques.

Exemple de configuration d'Ehcache via XML

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns="http://www.ehcache.org/v3"        xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.10.xsd">    <cache alias="users">        <key-type>java.lang.String</key-type>        <value-type>java.lang.String</value-type>        <heap>1000</heap>        <expiry>            <ttl unit="seconds">300</ttl>        </expiry>    </cache></config>

Exemple d'utilisation d'Ehcache dans le code

import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.builders.CacheManagerBuilder;import org.ehcache.xml.XmlConfiguration;

public class EhcacheExample {    public static void main(String[] args) {        XmlConfiguration xmlConfig = new XmlConfiguration(            EhcacheExample.class.getResource("/ehcache.xml"));        try (CacheManager cacheManager = CacheManagerBuilder.newCacheManager(xmlConfig)) {            cacheManager.init();            Cache<String, String> users = cacheManager.getCache("u