L’utilisation du springboot avec ehcache permet d’implémenter facilement et rapidement une logique de cache. Et le fait de l’intégrer dans notre application grâce aux différentes annotations nous permet de bénéficier de la puissance de Spring….
Dans notre précédent article, nous avons pu introduire le plus célèbre cache en java, Ehcache, et ses fonctionnalités, accompagnées d’exemples d’utilisation avec une configuration basée sur du code java (en POJO). Dans cet article, nous allons montrer comment utiliser le Spring Caching avec Ehcache dans un projet Spring boot.
Spring Caching présente une approche facile pour ajouter la mise en cache dans les applications sous Spring grâce à ces annotations.
Spring propose deux ensembles d’annotations pour la mise en cache. L’original est disponible avec Spring 3.1+, tandis que ceux conformes à la spécification JSR-107 sont introduits avec les versions 4.1 et + de Spring.
Dans ce qui suit, nous allons utiliser Spring boot version 2.3.3. Release. Les anciennes versions de Spring boot supportent Ehcache 2.x (disponible dans le package net.sf.ehcache). Les versions de Spring Boot les plus récentes supportent quant à elles Ehcache 3.x (disponibles dans le package org.ehcache).
I/ Les dépendances Maven
Dans un projet Spring boot, nous avons besoin des dépendances suivantes :
- spring-boot-starter-cache (le support du caching spring boot)
- org.ehcache:ehcache (le cache Ehcache)
- javax.cache:cache-api (le jar pour JSR-107 API)
- spring-boot-starter-web (pour le Rest Controller)
II/ Activation du Caching
Nous avons besoin d’ajouter l’annotation @EnableCaching à un bean Spring afin que la gestion du cache basée sur les annotations de Spring soit activée.
On crée ensuite un bean Spring de configuration annoté avec @EnableCaching :
L’annotation @EnableCaching déclenche un post-processeur qui inspecte chaque bean Spring pour la présence d’annotations @Cacheable sur les méthodes publiques. Si une telle annotation est trouvée, un proxy est automatiquement créé pour intercepter l’appel de la méthode et solliciter le cache.
III/ L’annotation @Cacheable
Pour mettre en cache les données renvoyées par un appel d’une méthode, nous allons utiliser l’annotation @Cacheable sur la méthode.
L’annotation @EnableCaching vue ci-dessus permet à Spring de créer un proxy du ConsultantService pour intercepter les appels à la méthode getConsultatById() (annoté par @Cacheable) et appeler Ehcache.
On a défini comme nom du cache « consultantCache » et la clé est représentée par l’« id » dans les attributs de l’annotation :
IV/ La création d’un listener personnalisé pour les évènements du cache
Nous allons créer le listener d’événements qui va logger lorsque les entrées du cache sont créées ou supprimées.
Les listeners sont enregistrés au niveau du cache. Par conséquent, ils ne recevront que les évènements des caches qui leurs sont associés.
Par ailleurs, en runtime, on peut enregistrer ou désabonner un listener d’un cache :
Dans le code ci-dessus, une instance d’une implémentation du cache listener est créée. Elle est enregistrée au runtime avec un delivery mode (ORDERED et ASYNCHRONOUS) sur les évènements du cache de type création et suppression.
PS : par défaut, le delivery mode est (UNORDERED et ASYNCHRONOUS) pour une question de performance.
Pour désabonner ce cache enregistré ci-dessus, voici comme procéder :
V/ La configuration du cache
Spring boot auto-configuration trouve l’implémentation Ehcache de la JSR-107. Cependant, aucun cache n’est créé par défaut car ni Spring, ni Ehcache ne recherche un fichier ehcache.xml par défaut.
Nous devons spécifiquement fournir le chemin du fichier de configuration ehcache qui doit être utilisé dans le fichier « application.properties » en ajoutant l’entrée suivante :
spring.cache.jcache.config=classpath:ehcache.xml
On va ensuite créer le fichier ehcache.xml dans le dossier “resources” du projet :
Dans ce fichier de configuration, nous avons renseigné :
- Le nom du cache
- Le type de la clé et la valeur (<Long, Consultant>)
- Nous avons configuré les données du cache à expirer après 30 secondes
- Nous avons fait référence à notre listener pour logger les évènements de création et de suppression des entrées du cache
- Nous avons défini le nombre limite d’entrées du cache à 20 en mémoire
VI/ Démo de l’application
Maintenant que tout est en place, nous pouvons passer au test. J’ai créé un simple Rest consultantController pour appeler le service qui remonte les consultant par id :
J’utilise l’IDE IntelliJ et Maven pour démarrer cette application Spring boot en exécutant mvn spring-boot:run.
Ensuite, via un navigateur, nous pouvons accéder à l’Endpoint Rest des « consultants » déployé par défaut sur le port 8080 en tapant : http://localhost:8080/consultant/1
Dans les logs, on trouve :
- Le log lors de l’appel de la méthode getConsultant() de la classe ConsultantController
- Le log de la méthode getConsultantById() de la classe ConsultantService
- Le log du listener CustomCacheEventLogger qui indique que l’entrée du cache vient d’être créée et qu’il n’y avait pas de valeur associée à la clé 1 (Old value = null)
Si on refait l’appel, on observe alors cette ligne de log :
Elle signifie que la méthode getConsultantById() de la classe ConsultantService n’est pas appelée et que Spring a fait appel au cache.
Comme nous avons configuré les données du cache à expirer après 30 secondes (la valeur est définie dans la balise ttl dans ehcache.xml), si on refait l’appel :
On remarque alors dans les logs que l’entrée est expirée et a été recréée à nouveau.
Conclusion
Dans cet article, nous avons vu les différentes étapes pour intégrer Ehcache 3 dans une application Spring boot.
Pour utiliser Ehcache sans les annotations dans une application Spring, il suffit d’injecter une instance du org.springframework.cache.CacheManager (avec @Autowired par exemple) dans un bean Spring. Ensuite, vous pouvez utiliser la méthode getCache(« nom du cache ») pour obtenir l’instance du cache souhaitée par son nom comme définie dans ehcache.xml. Une fois que nous avons accès au cache, nous pouvons utiliser les méthodes get() et put() pour ajouter et parvenir aux entrées du cache.
Personnellement, je trouve que l’utilisation du springboot avec ehcache permet d’implémenter facilement et rapidement une logique de cache. Et le fait de l’intégrer dans notre application grâce aux différentes annotations nous permet de bénéficier de la puissance de Spring. Peut-être vous posez-vous la question de savoir dans quel cas ne pas utiliser les annotations ? En réalité, tout dépend du cas d’utilisation. Par exemple, si vous souhaitez effectuer un traitement particulier avant / après les opérations sur le cache et que vous ne pouvez pas (ou ne voulez pas) l’insérer dans le listener. Aussi, pour avoir plus de contrôle et moins d’abstraction sur l’application, c’est-à-dire au lieu de déléguer le caching (get / put / delete) au Framework, vous pouvez le faire vous-même, ce qui ne représentera que quelques lignes de codes en plus 😁
Références :
https://www.javadevjournal.com/spring/spring-caching/
https://howtodoinjava.com/spring-boot2/ehcache3-config-example/
https://spring.io/guides/gs/rest-service/
https://www.javadevjournal.com/spring/spring-boot-auto-configuration/
https://www.baeldung.com/spring-boot-ehcache
https://www.javadevjournal.com/spring-boot/spring-boot-with-ehcache/
https://www.ehcache.org/documentation/2.8/get-started/storage-options.html
https://www.ehcache.org/documentation/3.8/cache-event-listeners.html
Pas encore de commentaires