L’écosystème Spring est très vaste et est beaucoup utilisé pour la construction de différents types d’applications et surtout des applications web. Quant à Spring Boot, il ne cesse de nous rendre la vie plus facile avec sa capacité de configuration automatique.

Dans cet article, j’aborderai certains outils, fournis par Spring et Spring Boot, que nous ne pensons pas nécessairement à ajouter à nos projets. Pourtant, ils pourraient nous donner les moyens d’aller plus vite en termes de configuration, de débogage et de développement.

Dev Tools

Pour améliorer davantage l’expérience de développement, un module spécifique de développement est disponible depuis Spring Boot 1.3.

	<dependency>  
	    <groupId>org.springframework.boot</groupId>  
	    <artifactId>spring-boot-devtools</artifactId>  
	</dependency>  

Avec cette nouvelle fonctionnalité, nous obtenons plusieurs avantages tels que :

  • Default Property (Propriété par défaut) : Spring Boot effectue de nombreuses configurations automatiques, notamment l’activation de la mise en cache par défaut pour améliorer les performances. Mais au cours du développement, il est plus important de voir les changements le plus rapidement possible. Le comportement par défaut de la mise en cache peut être désactivé pour thymeleaf. Par exemple, à l’aide de la propriété spring.thymeleaf.cache = false dans le fichier application.properties. Nous n’avons pas besoin de le faire manuellement, l’introduction de spring-boot-devtools le fait automatiquement pour nous.
  • Automatic Restart (Redémarrage automatique) : Dans un environnement de développement d’applications typiques, un développeur apporte certaines modifications, crée le projet et déploie/démarre l’application pour que les modifications soient prises en compte. En utilisant spring-boot-devtools, ce processus est également automatisé. Chaque fois que les fichiers changent dans le chemin d’accès aux classes, les applications utilisant spring-boot-devtools provoquent le redémarrage de l’application. L’avantage de cette fonctionnalité est que le temps requis pour vérifier les modifications apportées est considérablement réduit.
  • Live Reload (Actualisation en Live) : Le module spring-boot-devtools comprend un serveur LiveReload intégré, utilisé pour déclencher le rafraîchissement du navigateur lorsqu’une ressource est modifiée. Pour que cela se produise dans le navigateur, nous devons installer le plug-in LiveReload. Un exemple d’une telle implémentation est “Remote Live Reload” pour Chrome.
  • Global Settings (Paramètres globaux) : spring-boot-devtools fournit un moyen de configurer des paramètres globaux qui sont couplés à aucune application. Ce fichier est nommé spring-boot-devtools.properties et se trouve dans $HOME.
  • Remote Applications (Applications à distance) : spring-boot-devtools permet la mise à jour à distance. Le client distant surveille le chemin d’accès aux classes de l’application pour déterminer les modifications, comme pour la fonction de redémarrage à distance. Toute modification du chemin de classe entraîne le transfert de la ressource mise à jour vers l’application distante et le redémarrage.

Failure Analyzer

Nous avons tous déjà rencontré une exception au démarrage d’une application avec Spring, des longues exceptions avec des centaines de lignes et il n’est pas toujours facile à comprendre la cause. Dans Spring Boot, nous trouvons l’interface FailureAnalyzer.

FailureAnalyzer permet d’intercepter les exceptions qui se produisent pendant le démarrage d’une application et de remplacer la « Stack trace » de l’exception par un message plus lisible représenté par un objet FailureAnalysis contenant une description de l’erreur et un plan d’action suggéré.

Sachant que Spring Boot contient déjà une série d’analyseurs pour les exceptions de démarrage courantes telles que PortInUseException, NoUniqueBeanDefinitionException et UnsatisfiedDependencyException et qui se trouvent sous le package org.springframework.boot.diagnostics.

Il est possible aussi de créer des customs FailureAnalyzer pour les nouvelles exceptions définies pour le projet :

	package com.invivoo.toolsandtips.example.failureanalyzer;  
	  
	import org.springframework.boot.diagnostics.FailureAnalysis;  
	import org.springframework.boot.diagnostics.FailureAnalyzer;  
	  
	/** 
	 * A custom Failure Analyzer that implements FailureAnalyzer and override analyze method which will be 
	 * called automatically when application startup will get failed. 
	 */  
	public class MyFailureAnalyzer implements FailureAnalyzer {  
	    @Override  
	    public FailureAnalysis analyze(Throwable failure) {  
	        return new FailureAnalysis("My Failed Message : ",failure.getMessage(),failure);  
	    }  
	}  

Dans spring.factories :

1. org.springframework.boot.diagnostics.FailureAnalyzer=com.invivoo.toolsandtips.example.failureanalyzer.MyFailureAnalyzer  

Actuator

Nous sommes de plus en plus amenés à régler des problèmes de performances et de lenteur dans nos projets.

Spring Boot Actuator apporte des fonctionnalités permettant la surveillance de notre application, la collecte de métriques, la compréhension du trafic et de l’état de notre base de données.

Le principal avantage de cette librairie est que nous pouvons obtenir des outils de qualité de production sans avoir à implémenter réellement ces fonctionnalités nous-mêmes.

	<dependency>  
	    <groupId>org.springframework.boot</groupId>  
	    <artifactId>spring-boot-starter-actuator</artifactId>  
	</dependency>  

Une fois cette dépendance ajoutée, plusieurs informations opérationnelles sur l’application en cours d’exécution sont exposées : santé, métriques, info, dump, env, etc. En plus, et comme avec la plupart des modules de Spring Boot, nous pouvons facilement le configurer ou l’étendre de plusieurs façons. Un exemple ci-dessous :

	package com.invivoo.toolsandtips.example.actuator;  
	  
	import org.springframework.web.bind.annotation.GetMapping;  
	import org.springframework.web.bind.annotation.RestController;  
	  
	@RestController  
	public class MyRestController {  
	    @GetMapping("/example")  
	    public String example() {  
	        return "Hello Actuator !! ";  
	    }  
	}  

Une fois l’application démarrée, on peut voir ces différentes métriques :

Ci-dessous une liste non exhaustive des end-points définis :

  • /auditevents – Liste les événements liés à l’audit de sécurité, tels que la connexion / déconnexion de l’utilisateur avec la possibilité de filtrage.
  • /beans – Renvoie tous les beans disponibles dans notre BeanFactory. Contrairement à /auditevents, il ne prend pas en charge le filtrage.
  • /conditions – Génère un rapport sur les conditions de configuration automatique.
  • /configprops – Nous permet d’extraire tous les beans @ConfigurationProperties.
  • /env – Renvoie les propriétés de l’environnement en cours.
  • /flyway – Fournit des détails sur les migrations de notre base de données Flyway.
  • /health – Résume l’état de santé de notre application.
  • /heapdump – Construit et retourne un heap dump de la machine virtuelle utilisée par notre application.
  • /info – Renvoie des informations générales. Il peut s’agir de données personnalisées, d’informations de construction ou de détails sur le dernier commit.
  • /liquibase – Se comporte comme / flyway mais pour Liquibase.
  • /logfile – Renvoie les logs de l’application.
  • /loggers – Nous permet d’interroger et de modifier le niveau de log de notre application.
  • /metrics – Détaille les métriques de notre application. Cela peut inclure des mesures génériques ainsi que des mesures personnalisées.
  • /prometheus – Renvoie des métriques similaires à la précédente, mais formatées pour fonctionner avec un serveur Prometheus.
  • /scheduledtasks – Fournit des détails sur chaque tâche planifiée dans notre application.
  • /sessions – Liste les sessions HTTP étant donné que nous utilisons Spring Session.
  • /shutdown – Effectue un arrêt progressif de l’application.
  • /threaddump – Dumps de thread de la machine virtuelle Java sous-jacente.

Configuration Processor

Spring-Boot-Configuration-Processor est un système d’annotation qui génère des métadonnées sur les classes de votre application annotées avec @ConfigurationProperties. Ces métadonnées sont utilisées par votre IDE (Eclipse, IntelliJ IDEA, NetBeans ou VSCode) pour permettre la saisie automatique et la documentation des propriétés lors de la modification des fichiers application.properties et application.yaml.

Pour l’exemple ci-dessous :

	package com.invivoo.toolsandtips.example.configurationprocessor;  
	  
	import org.springframework.boot.context.properties.ConfigurationProperties;  
	  
	@ConfigurationProperties("example.properties")  
	public class MyProperties {  
	    private String myProperty = "CUSTOM_PROPERTY";  
	  
	    public String getMyProperty() {  
	        return myProperty;  
	    }  
	  
	    public void setMyProperty(String myProperty) {  
	        this.myProperty = myProperty;  
	    }  
	}  

Il faut ajouter @EnableConfigurationProperties

	package com.invivoo.toolsandtips.example.configurationprocessor;  
	package com.invivoo.toolsandtips.example;  
	  
	import com.invivoo.toolsandtips.example.configurationprocessor.MyProperties;  
	import org.springframework.boot.SpringApplication;  
	import org.springframework.boot.autoconfigure.SpringBootApplication;  
	import org.springframework.boot.context.properties.EnableConfigurationProperties;  
	  
	@SpringBootApplication  
	@EnableConfigurationProperties(MyProperties.class)  
	public class ExampleApplication {  
	  
	    public static void main(String[] args) {  
	  
	        SpringApplication.run(ExampleApplication.class, args);  
	    }  
	  
	}  

Un fichier spring-configuration-metadata.json est généré :

L’auto-complétion est désormais disponible.

La dépendance s’ajoute comme ici :

	<dependency>  
	    <groupId>org.springframework.boot</groupId>  
	    <artifactId>spring-boot-configuration-processor</artifactId>  
	    <optional>true</optional>  
	</dependency>  

IntelliJ IDEA

Le développement d’application avec Spring est beaucoup plus facile avec IntelliJ IDEA. Certes, cet IDE est payant, mais on y trouve beaucoup de fonctionnalités qui ne sont pas disponibles ailleurs.

Par exemple, IntelliJ IDEA est capable de détecter automatiquement une configuration Spring dans le code. Une fois configuré, des icônes Spring apparaîtront et marqueront les composants Spring présents :

 Il est possible maintenant :

  • Créer un contexte d’application : Ceci permettra de regrouper les fichiers de configurations Spring et de permettre à l’IDE de comprendre les relations entre ces fichiers.
  • Configurer un contexte parent : Permet de définir une hiérarchie de type parent-fils entre les fichiers de contexte. Ceci permettra aux BEANS d’utiliser la configuration du contexte parent et de visualiser leurs BEANS.
  • Diagrammes Spring : Sont de deux type et permettent de parcourir les dépendances dans « Spring tool window »
    • Diagramme de dépendances des Beans qui permet de visualiser les dépendances entre les beans.
    • Diagramme de dépendances des contextes d’application et qui permet d’analyser les dépendances entre les multiples configurations, d’afficher les erreurs et de détecter les dépendances cycliques.
  • Définir des profils : Avec Spring il est possible de configurer plusieurs profils de configuration par environnement (test, intégration, production).

 IntelliJ IDEA, pour Spring Boot, permet en plus.

  • Spring initialiseur : Est un assistant qui permet de configurer une application Spring Boot, en sélectionnant les dépendances nécessaires au projet.
  • Configurer les fichiers de configurations custom : Permet de définir un fichier de configuration par défaut ou de définir plusieurs fichiers de configuration custom.
  • Diagramme de dépendances des « Beans Runtime » : Donne un aperçu visuel des différentes dépendances entre les beans Runtimes dans une application Spring Boot. Notons que le plugin « Bundled UML » doit être activé.
  • Access HTTP request mappings : Permet d’exécuter ou d’afficher la requête.

Indexation des composants

Les rumeurs disent que le scan du classpath consomme beaucoup du temps, même si ce n’est pas toujours vrai, Spring 5 a ajouté une nouvelle fonctionnalité pour améliorer les performances de démarrage des applications volumineuses (plus de dix milles classes).

L’indexation des composants permet de créer un fichier META-INF/spring.component par JAR contenant la liste de composants candidats au moment de la compilation.

Le But, et pour un projet contenant, par exemple, dix milles classes dont une centaine de composants, est de scanner uniquement les cents composant au lieu de parcourir les dix milles classes avec le scan du classpath.

Notons que dans ce mode, tous les modules de l’application doivent utiliser ce mécanisme, car, lorsque ApplicationContext détecte cet index, il l’utilisera automatiquement au lieu d’analyser le chemin d’accès aux classes.

Pour générer l’index, il suffit d’ajouter la dépendance ci-dessous à chaque module.

	<dependency>    
	    <groupId>org.springframework</groupId>    
	    <artifactId>spring-context-indexer</artifactId>    
	</dependency>    

Sources et références