Développement accéléré avec Spring Boot DevTools

Comment accélérer le développement sur Spring Boot avec DevTools et rendre ce processus plus agréable et plus productif?

Personnalisation

Comme d'habitude lors du développement sur Spring Boot, la configuration est assez simple. Tout ce que vous avez à faire est d'ajouter la bonne dépendance et vous avez terminé. Spring Boot le trouve et configure automatiquement DevTools en conséquence.

Si vous utilisez Maven:

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

Si vous utilisez Gradle:

 configurations { developmentOnly runtimeClasspath { extendsFrom developmentOnly } } dependencies { developmentOnly("org.springframework.boot:spring-boot-devtools") } 

Veuillez noter que la dépendance est déclarée comme facultative. Ceci est important car une telle déclaration de dépendance empêche la dépendance DevTools d'être appliquée de manière transitoire à d'autres modules en fonction de votre projet.

Redémarrage automatique

Chaque fois que des modifications de fichier se produisent dans votre chemin de classe, DevTools redémarrera automatiquement votre application de travail avec les nouvelles modifications. Pour le développement local, cela peut être utile car vous n'avez pas besoin de redéployer l'application manuellement.

Cela seul ne serait pas aussi utile, car le redémarrage peut encore prendre trop de temps. Heureusement, un tel redémarrage est beaucoup plus rapide qu'un redémarrage normal en raison de l'astuce délicate utilisée par DevTools.

Le fait est que lorsque vous développez une application, vous changez généralement une classe ou plusieurs et souhaitez vérifier les résultats dans votre application en cours d'exécution pour obtenir des commentaires. Vous apportez des modifications mineures à votre application, tandis que la plupart des classes chargées proviennent de frameworks et de bibliothèques tierces.

Sous le capot de Spring DevTools, deux chargeurs de classe sont utilisés: la base et le redémarrage . Les classes qui ne changent pas sont chargées par la base du chargeur de base . Les classes avec lesquelles vous travaillez sont chargées à l'aide du chargeur de redémarrage . Chaque fois que vous redémarrez, le chargeur de démarrage est recréé. Ainsi, le redémarrage de l'application est beaucoup plus rapide que d'habitude et peut être une véritable alternative au rechargement d'une classe dynamique à l'aide d'outils tels que JRebel.

Initialisation du redémarrage dans IDE

Un redémarrage est déclenché chaque fois qu'un fichier change dans votre chemin de classe. Cependant, ce processus dépend de votre IDE. Cela signifie qu'il ne suffit pas de modifier vos fichiers java. L'important est lorsque votre IDE met réellement à jour les fichiers .class dans votre chemin de classe.

Lorsque vous utilisez IntelliJ IDEA, vous devez exécuter la commande build dans votre projet ( Ctrl + F9 ou Build → Build Project ). Vous pouvez également configurer la commande build pour qu'elle s'exécute automatiquement dans IDEA . De plus, vous pouvez ouvrir la configuration de démarrage de Spring Boot et déterminer ce qui se passe lorsque la mise à jour de l'application démarre ( Ctrl + F10 ):



Dans la première zone de liste déroulante, vous pouvez sélectionner Mettre à jour le fichier déclencheur pour démarrer le redémarrage de DevTools chaque fois que l'action de mise à jour est effectuée. Alternativement, vous pouvez même sélectionner l'option de remplacement à chaud et essayer de redémarrer l'application à l'aide de DevTools uniquement si l'exécution du remplacement à chaud a échoué.

Dans la deuxième zone de liste déroulante, vous pouvez configurer le redémarrage de toutes les ressources statiques et modèles lorsque la fenêtre IDEA perd le focus (par exemple, lors du basculement vers la fenêtre du navigateur).

Dans Eclipse, il est assez facile d'enregistrer vos fichiers.

Développement uniquement

Les Spring Boot DevTools sont destinés uniquement au développement et non au fonctionnement de production de l'application. Si votre application détecte que vous travaillez dans un environnement de production, DevTools est automatiquement désactivé.

À cet effet, chaque fois que vous lancez votre application en tant qu'artefact entièrement packagé, tel qu'un pot avec un serveur d'applications intégré, elle est considérée comme une application de production:

 java -jar devtools-example-1.0.0.jar 

Il en va de même lorsque votre application est lancée via un chargeur de classe spécial, par exemple, sur un serveur d'applications.

Au contraire, lorsque vous exécutez des artefacts décompressés (par exemple, dans votre IDE), votre application est considérée en mode développement. La même chose s'applique à l'utilisation de Spring-Boot-Plugin pour exécuter l'application:

Maven:

 mvn spring-boot:run 

Gradle:

 gradle bootRun 

LiveReload

LiveReload est un outil utile qui vous permet d'actualiser instantanément une page dans un navigateur chaque fois que vous apportez des modifications à des fichiers tels que HTML, CSS, images, etc. Il prétraite même les fichiers selon les besoins - cela signifie la compilation automatique des fichiers SASS ou LESS.



Spring DevTools démarre automatiquement une instance locale du serveur LiveReload qui suit vos fichiers. Tout ce que vous avez à faire est d'installer l' extension pour le navigateur , et vous avez terminé. Il est non seulement utile pour développer l'interface externe de votre application (dans le cas où vous la distribuez dans le cadre de l'artefact de l'application Spring), mais peut également être utilisé pour surveiller et recharger la sortie de votre API REST.

Remplacement de la propriété

Lorsque vous développez une application localement, vous avez généralement des besoins de configuration différents que lorsque vous travaillez dans un environnement de production. Un exemple serait la mise en cache. Dans un environnement de production, la dépendance à l'égard de divers caches (tels que les caches de modèles de moteur, les en-têtes de mise en cache pour les ressources statiques, etc.) est extrêmement importante. Pendant le développement, il peut utiliser d'anciennes données et ne pas refléter vos dernières modifications. Un autre exemple serait la journalisation avancée, qui peut être utile en développement mais trop détaillée pour l'environnement de production.

Il est trop difficile de gérer vous-même deux types de configuration. La bonne nouvelle est que Spring Boot DevTools, par défaut, configure de nombreuses propriétés pour votre développement local.

 spring.thymeleaf.cache=false spring.freemarker.cache=false spring.groovy.template.cache=false spring.mustache.cache=false server.servlet.session.persistent=true spring.h2.console.enabled=true spring.resources.cache.period=0 spring.resources.chain.cache=false spring.template.provider.cache=false spring.mvc.log-resolved-exception=true server.servlet.jsp.init-parameters.development=true spring.reactor.stacktrace-mode.enabled=true 

Vous pouvez trouver une liste de toutes les propriétés de la classe DevToolsPropertyDefaultsPostProcessor .

Connexion à distance

En plus du développement local, vous pouvez également vous connecter à une application distante exécutant DevTools. Cet outil n'est pas destiné aux environnements de production car il peut présenter un risque sérieux pour la sécurité. Cependant, il peut être très utile dans un environnement de pré-production.

Activation de la connexion à distance

La connexion à distance n'est pas activée par défaut. Vous devez l'activer explicitement en modifiant le fichier pom:

 <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludeDevtools>false</excludeDevtools> </configuration> </plugin> </plugins> </build> 

Ou avec gradle, vous devez définir excludeDevtools = false :

 bootWar { excludeDevtools = false } 

Ensuite, vous devez définir un mot de passe qui sera utilisé pour l'authentification lors de la connexion à l'application distante:

 spring.devtools.remote.secret=somesecret 

Se connecter à une application distante

Après avoir démarré l'application distante, vous pouvez démarrer la session de connexion à distance. Il ne vous reste plus qu'à exécuter org.springframework.boot.devtools.RemoteSpringApplication avec l'URL de votre application distante comme argument. Veuillez noter que vous devez utiliser https si possible.

Le démarrage d'une connexion à distance est facile dans votre IDE. Dans IDEA, il vous suffit de créer une nouvelle configuration de lancement. Allez dans Exécuter → Modifier les configurations ... et créez une nouvelle configuration avec l'icône + dans le coin supérieur gauche. Sélectionnez un type d'application.

Pour la classe Main, sélectionnez RemoteSpringApplication dans le module DevTools et passez l'URL de votre application distante comme argument au programme.



Après avoir démarré cette configuration, vous devriez voir une sortie similaire si la connexion à l'application distante a réussi.



Après la connexion à une application distante, DevTools surveille les modifications du chemin d'accès aux classes de la même manière que pour le développement local. Cependant, au lieu d'un redémarrage local, il transfère les modifications sur le serveur distant et y initie un redémarrage. Cela peut être beaucoup plus rapide que de créer une application et de la déployer sur une machine distante.

Configuration globale

Vous pouvez personnaliser DevTools à l'aide des propriétés de configuration, comme avec toute autre application Spring. Cela signifie généralement modifier les propriétés application.properties de votre projet. Cette configuration est distincte pour chaque application.

Cependant, dans certains scénarios, il peut être pratique d'avoir une configuration globale pour TOUTES les applications exécutées sur le même ordinateur. Vous pouvez créer un fichier de propriétés appelé .spring-boot-devtools.properties situé dans votre répertoire $ HOME . La déclaration indiquée dans ce fichier s'applique à toutes les applications utilisant DevTools.

Limitations

Rechargement en direct

Une application Spring utilisant DevTools démarre automatiquement le serveur LiveReload. Malheureusement, une seule instance de ce serveur peut être démarrée à la fois. Plus précisément, seule la première instance fonctionnera. Cela s'applique non seulement à plusieurs instances d'applications Spring avec DevTools, mais également à toutes les autres applications qui utilisent également LiverReload sous le capot, comme Gatsby en mode développement.

Si vous souhaitez configurer l'application Spring afin qu'elle ne démarre pas le serveur LiveReload, cela peut être fait dans votre fichier application.properties :

 spring.devtools.livereload.enabled=false 

Crochet d'arrêt

Les DevTools dépendent de l'attribut de hook d'arrêt de la classe SpringApplication . La classe ne fonctionnera pas correctement si vous avez désactivé manuellement l'attribut à l'aide de:

 springApplication.setRegisterShutdownHook(false); 

L'attribut est activé par défaut, vous n'avez donc pas à vous en préoccuper sauf si vous le désactivez explicitement.

Collisions avec des bibliothèques tierces

Bien que DevTools devrait généralement fonctionner correctement, ils peuvent avoir des conflits avec des bibliothèques tierces. En particulier, il existe un problème connu de désérialisation à l'aide de l' ObjectInputStream standard.

En cas d'un tel conflit, vous pouvez désactiver le redémarrage automatique en définissant:

 spring.devtools.restart.enabled=false 

Le redémarrage ne fonctionnera plus. Cependant, le redémarrage du chargeur de classe sera toujours utilisé. Si vous devez désactiver complètement le chargeur de classe, vous devez le faire avant de démarrer l'application:

 public static void main(String[] args) { System.setProperty("spring.devtools.restart.enabled", "false"); SpringApplication.run(MyApp.class, args); } 

Même si vous n'utilisez pas le redémarrage automatique, vous pouvez toujours utiliser d'autres fonctionnalités DevTools.

Activation de l'initialisation différée

Vous pouvez marquer des composants individuels comme initialisés paresseusement à l'aide d'annotations $$$@ Lazy$. Cette fonctionnalité est disponible depuis un certain temps. À partir de Spring Boot 2.2, vous pouvez basculer l'initialisation différée pour tous vos composants de bean en utilisant spring.main.lazy-initialization = true .

Cela peut être utilisé seul ou en combinaison avec DevTools pour un redémarrage encore plus rapide .

DevTools vous permet de redémarrer à chaud votre application dans la même JVM. Un avantage significatif d'un redémarrage à chaud est qu'il donne à JIT plus d'options pour optimiser le code utilisé pour lancer votre application. Après plusieurs redémarrages, le temps initial de 2500 ms est réduit de près de 80% et approche 500 ms. Avec une initialisation paresseuse, nous pouvons obtenir de meilleurs résultats. Lors de l'installation de spring.main.lazy-initialization, notre application redémarre après 400 ms directement dans l'IDE.

Il est douteux d'utiliser une initialisation retardée pour tous vos beans dans une application de production. Cette procédure offre des gains de performances de démarrage supérieurs en raison de demandes plus longues pour la première fois aux composants individuels du bean. Plus important encore, votre application ne cesse pas de fonctionner rapidement. Mais au lieu de se bloquer immédiatement au démarrage de l'application, il échouera uniquement après avoir directement demandé le composant mal configuré. Cela peut être très dangereux car vous ne trouverez pas beaucoup d'erreurs avant qu'il ne soit trop tard. Cependant, l'initialisation retardée en masse peut être utile pour accélérer le temps de développement, car lorsque vous travaillez avec une certaine fonction, vous ne travaillez généralement que sur une partie de votre application et n'utilisez pas le reste. Le compromis idéal serait d'activer l'initialisation différée en masse uniquement pour le développement local (par exemple, en utilisant un profil de ressort) et de le désactiver pour les environnements supérieurs déployés.

Conclusion

DevTools accélère et simplifie le développement d'applications Spring Boot en fournissant un redémarrage automatique et une fonctionnalité LiveReload. En plus de cela, il définit diverses propriétés pour des valeurs plus adaptées au développement local. De plus, il vous permet de vous connecter à distance à votre application et en même temps d'utiliser la plupart de ses fonctions. Lors du démarrage de l'application en production, les DevTools ne sont pas utilisés. Voir la documentation officielle pour plus de détails.