Formations — 1 037 leçons en français

Accueil › Spring Boot › Le cache avec @Cacheable

Le cache avec @Cacheable

Cache, tâches asynchrones et planifiéesintermediaire

L'abstraction de cache de Spring évite de réécrire à la main « chercher en cache, sinon exécuter et stocker ». Il suffit d'annoter une méthode.

@Configuration
@EnableCaching
public class CacheConfig { }

@Service
public class ProduitService {

    @Cacheable("produits")           // clé = l'argument id
    public Produit trouver(Long id) {
        return repository.findById(id).orElseThrow();
    }

    @CacheEvict("produits")          // retire l'entrée après la mise à jour
    public Produit modifier(Long id, Produit maj) {
        return repository.save(maj);
    }
}

Trois annotations principales : @Cacheable (lit le cache, n'exécute la méthode que si absent), @CachePut (exécute toujours, met à jour le cache) et @CacheEvict (retire une ou toutes les entrées).

Sans dépendance de cache ajoutée au projet, Spring Boot utilise par défaut un ConcurrentMapCacheManager : un cache en mémoire, sans expiration. En production, on branche généralement Caffeine (cache local avec TTL) ou Redis (cache partagé entre instances) via spring.cache.type — l'abstraction (@Cacheable…) ne change pas, seule la configuration du fournisseur change.

Comme @Transactional, ce mécanisme repose sur un proxy : un appel interne au bean (this.methode()) le contourne.

Les termes à connaître

@EnableCaching

Annotation posée sur une classe @Configuration (ou la classe principale) qui active l'abstraction de cache de Spring. Sans elle, @Cacheable, @CachePut et @CacheEvict sont silencieusement ignorées, comme @EnableAsync pour @Async.

@Cacheable

Pose la mise en cache sur une méthode : au premier appel avec un jeu d'arguments donné, la méthode s'exécute et son résultat est stocké ; aux appels suivants avec les mêmes arguments, le résultat est renvoyé depuis le cache sans exécuter la méthode.

@CachePut

Exécute toujours la méthode, puis range son résultat dans le cache (en écrasant l'entrée existante). Utile pour une méthode de mise à jour dont on veut aussi rafraîchir le cache, contrairement à @Cacheable qui n'exécute la méthode que si l'entrée est absente.

@CacheEvict

Retire une entrée du cache (ou toutes, avec allEntries = true). Peut s'exécuter avant la méthode (beforeInvocation = true) ou après (comportement par défaut, seulement si la méthode ne lève pas d'exception).

Clé de cache

Par défaut, la clé est calculée à partir des arguments de la méthode (via SimpleKeyGenerator). L'attribut key (en SpEL, ex. key = "#produit.id") permet de la personnaliser ; condition décide avant l'appel si le cache s'applique ; unless décide après l'appel si le résultat doit être mis en cache.

CacheManager

Bean qui fournit et gère les caches nommés utilisés par @Cacheable (@Cacheable("produits")). Sans dépendance de cache tierce sur le classpath, Spring Boot utilise par défaut un ConcurrentMapCacheManager : un simple ConcurrentHashMap en mémoire, sans expiration ni éviction automatique.

Caffeine et Redis

Deux fournisseurs de cache courants avec Spring Boot. Caffeine (spring.cache.type=caffeine) est un cache local en mémoire, rapide, avec expiration et taille maximale configurables. Redis (spring.cache.type=redis) est un cache partagé entre plusieurs instances de l'application, avec un TTL configuré côté client Redis. Dans les deux cas, l'abstraction Spring (@Cacheable…) ne change pas ; seule la configuration du fournisseur change.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.