Mise en cache en Java : Redis, Memcached et solutions intégrées

Introduction : Pourquoi mettre en cache en Java ?

Les applications Java modernes sont souvent confrontées à des problèmes de performances lors de l'interaction avec des bases de données, des API externes ou des calculs lourds. Chaque requête répétée vers une ressource lente augmente le temps de réponse et la charge sur l'infrastructure. La solution à ce problème est la mise en cache.

La mise en cache en Java permet de stocker temporairement les données fréquemment demandées dans un accès rapide (généralement en mémoire vive), afin de les restituer instantanément lors d'une demande ultérieure, en contournant les opérations coûteuses. Ceci est crucial pour les systèmes à forte charge, les applications web et les microservices.

Dans cet article, nous allons examiner trois approches principales de la mise en cache en Java : les solutions distribuées (Redis, Memcached) et les caches intégrés (in-memory). Vous apprendrez quand choisir quel outil et verrez des exemples de code pour chacun d'eux.

1. Mise en cache intégrée en Java : Ehcache, Caffeine et HashMap

Les caches intégrés sont des bibliothèques qui fonctionnent à l'intérieur de la JVM de votre application. Ils ne nécessitent pas l'installation de serveurs externes et sont parfaits pour les applications monolithiques ou les microservices avec un volume de données modeste.

1.1. Cache simple avec HashMap (pas pour la production)

La façon la plus simple est d'utiliser ConcurrentHashMap. Mais cette approche ne dispose pas de mécanismes d'expulsion, de TTL (durée de vie) et de contrôle de la mémoire.

import java.util.concurrent.ConcurrentHashMap;

public class SimpleCache<K, V> {    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();

    public V get(K key) {        return cache.get(key);    }

    public void put(K key, V value) {        cache.put(key, value);    }

    public void evict(K key) {        cache.remove(key);    }}

Inconvénients : pas de nettoyage automatique, peut conduire à une OutOfMemoryError.

1.2. Caffeine — le standard moderne en Java

Caffeine est une bibliothèque de mise en cache haute performance pour Java 8+. Elle prend en charge le nettoyage automatique basé sur le temps, la taille et la fréquence d'utilisation.

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

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

        // Écriture        cache.put("user:123", "John Doe");

        // Lecture        String user = cache.getIfPresent("user:123");        System.out.println("Utilisateur en cache : " + user);    }}

Avantages de Caffeine : vitesse élevée, politique d'éviction configurable (LRU, LFU), chargement asynchrone.

1.3. Ehcache — une valeur sûre éprouvée

Ehcache est l'une des plus anciennes bibliothèques de mise en cache pour Java. Elle prend en charge le stockage sur disque et le clustering.

import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.builders.CacheConfigurationBuilder;import org.ehcache.config.builders.CacheManagerBuilder;import org.ehcache.config.builders.ResourcePoolsBuilder;

public class EhcacheExample {    public static void main(String[] args) {        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()                .withCache("myCache",                        CacheConfigurationBuilder.newCacheConfigurationBuilder(                                String.class, String.class,                                ResourcePoolsBuilder.heap(100)))                .build();        cacheManager.init();

        Cache<String, String> cache = cacheManager.getCache("m