Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Java Spring
  3. Spring Boot
Extrait - Java Spring Le socle technique des applications Jakarta EE (5e édition)
Extraits du livre
Java Spring Le socle technique des applications Jakarta EE (5e édition) Revenir à la page d'achat du livre

Spring Boot

Introduction

Spring est un framework de développement d’applications et d’inversion de contrôle pour Java. Il fournit des infrastructures de support pour diverses applications, y compris les applications web. Spring Boot, quant à lui, est une extension de Spring qui simplifie le processus initial de configuration et de déploiement des applications Spring. Spring Boot offre une configuration par défaut pour les projets Spring, ce qui rend le processus de développement plus rapide et plus facile, notamment en éliminant le besoin de configuration XML.

Spring Boot a été lancé en avril 2014 par VMware. Il utilise une approche de « convention sur la configuration ». Il automatise la configuration en se basant sur les dépendances incluses dans le projet. Spring Boot détecte automatiquement les composants requis et configure l’application en conséquence, réduisant ainsi la nécessité de spécifier manuellement les configurations dans un fichier XML. De plus, il utilise des annotations et des propriétés pour permettre aux développeurs de personnaliser facilement leur application sans avoir besoin de configurations XML détaillées.

Les projets modernes privilégient souvent Spring Boot par rapport à l’utilisation de Spring seul pour plusieurs raisons clés :...

Avantages de Spring Boot

1. Configuration automatisée

Spring Boot simplifie la configuration des applications Spring en offrant une configuration automatique basée sur les dépendances du projet. Par exemple, si vous incluez une dépendance Spring Data JPA dans votre fichier de build Maven ou Gradle, Spring Boot configure automatiquement votre application pour utiliser JPA. Cela élimine le besoin de configurer manuellement des aspects tels que les sources de données ou les gestionnaires d’entités, rendant le processus de développement plus rapide et plus efficace.

Voici un exemple de configuration Spring Boot dans un fichier pom.xml et un extrait de code :

pom.xml :

<dependencies> 
  <!-- Spring Data JPA Dependency --> 
  <dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-data-jpa</artifactId> 
  </dependency> 
  <!-- Base de données H2 pour les tests --> 
  <dependency> 
    <groupId>com.h2database</groupId> 
    <artifactId>h2</artifactId> 
    <scope>runtime</scope> 
  </dependency> 
</dependencies> 

Toutes les dépendances sont configurées pour utiliser JPA, comme ici :

@Repository 
public interface UserRepository extends JpaRepository<User, Long> { 
  // Spring Boot configure automatiquement ce repository 
} 

Dans cet exemple, en ajoutant la dépendance spring-boot-starter-data-jpa, Spring Boot configure automatiquement le support JPA pour l’application, y compris la connexion à la base de données et la gestion des entités. 

2. Démarrage rapide

Spring Boot rend le démarrage de nouveaux projets rapide et efficace en minimisant la configuration initiale. Par exemple, si aucune base de données spécifique n’est définie dans le projet, Spring Boot configure automatiquement une base de données H2 en mémoire. Cela permet de démarrer rapidement le développement sans se soucier de la configuration de la base de données. De plus, Spring Boot...

Facilitations des développements

Spring Boot facilite le développement d’applications de plusieurs façons. Par exemple, avec spring-boot-devtools, il offre une fonction de rechargement à chaud (hot swapping) qui permet aux développeurs de voir les changements en temps réel sans redémarrer le serveur. Cela accélère considérablement le cycle de développement.

Application Spring MVC minimum

Le code source de cet exemple est disponible dans les fichiers en téléchargement.

Classe SampleController :

@Controller 
@EnableAutoConfiguration 
public class SampleController { 
 @RequestMapping("/") 
 @ResponseBody 
 String home() { 
 return "Hello World!"; 
 } 
 public static void main(String[] args) throws Exception { 
   SpringApplication.run(SampleController.class, args); 
 } 
} 

L’écosystème de Spring MVC que nous connaissons avec le framework Spring classique reste applicable lorsque nous travaillons avec Spring Boot. Cependant, Spring Boot simplifie considérablement le processus de configuration. Les annotations comme @RestController et @RequestMapping fonctionnent de la même manière que dans une application Spring traditionnelle, sans nécessiter l’utilisation explicite...

Détails sur l’autoconfiguration Spring Boot

L’autoconfiguration de Spring Boot est une fonctionnalité clé qui permet à Spring Boot de deviner les composants nécessaires pour votre application en se basant sur les dépendances du classpath. Cela signifie que si Spring Boot détecte, par exemple, une dépendance à une base de données H2 dans votre projet, il configurera automatiquement votre application pour utiliser cette base de données pour le développement.

Spring Boot recherche des classes dans le classpath, des propriétés de configuration, et des beans déjà configurés pour prendre des décisions d’autoconfiguration. Par exemple, si Spring Boot voit que vous avez une dépendance pour Spring MVC dans votre fichier pom.xml, il configurera votre application pour être une application web, en configurant des éléments comme DispatcherServlet.

L’autoconfiguration vise à minimiser la quantité de configuration manuelle. Elle est activée par l’annotation @EnableAutoConfiguration ou plus communément @SpringBootApplication, qui est souvent placée sur votre classe principale. Cette annotation est essentiellement un raccourci qui inclut @Configuration, @EnableAutoConfiguration, et @ComponentScan.

Cela ne signifie pas que vous n’avez aucun contrôle sur la configuration....

Personnalisation de la bannière

Au lancement de l’application Spring Boot, nous avons l’affichage d’une bannière dans les logs. Cette bannière est personnalisable. Il suffit d’ajouter un fichier texte banner.txt dans le classpath ou de préciser sa location via le banner.location dans la configuration. Le charset d’encodage peut être spécifié si ce n’est pas de l’UTF-8. Il est également possible d’utiliser une image : banner.gif, banner.jpg ou banner.png qui est transformée en ASCII Art au lancement.

Nous pouvons utiliser ce site pour faire de l’ASCII Art : http://patorjk.com/software/taag

La propriété spring.main.banner-mode est utilisée pour déterminer si la bannière est affichée sur la console System.out, les logs log, ou pas du tout off.

Événements d’applications

Dans Spring Boot 3, divers événements sont publiés au cours du cycle de vie de l’application, permettant aux développeurs d’interagir à différents stades du processus de démarrage.

1. ApplicationStartingEvent

Cet événement est publié en tout début de démarrage de l’application Spring Boot, juste après que le démarrage a commencé et avant que n’importe quelle configuration soit traitée. C’est l’un des premiers événements que vous pouvez écouter.

2. ApplicationContextInitializedEvent

Publié lorsque l’ApplicationContext de Spring est initialisé, mais pas encore rafraîchi. À ce stade, les beans ne sont pas encore chargés.

3. ApplicationEnvironmentPreparedEvent

Cet événement est déclenché lorsque l’environnement de l’application Spring Boot est connu, mais avant que le contexte de l’application soit créé. Cela permet de manipuler l’environnement (par exemple, les propriétés configurées) avant que l’application ne soit complètement démarrée.

4. ApplicationPreparedEvent

Publié juste avant le rafraîchissement du contexte de l’application. À ce stade, les beans sont sur le point d’être...

Récupération des arguments de la ligne de commande

Spring Boot propose deux interfaces qui permettent d’exécuter du code personnalisé ou une logique d’initialisation après le démarrage de l’application, mais avant qu’elle ne soit complètement prête à traiter les requêtes. Ces interfaces offrent une opportunité d’intervenir dans le processus de démarrage pour des configurations ou des actions spécifiques.

Nous avons tout d’abord l’interface CommandLineRunner qui est utilisée pour accéder aux arguments de la ligne de commande passés au démarrage de l’application. Elle définit une méthode run(String... args) qui peut être implémentée pour exécuter du code au démarrage de l’application.

Nous avons aussi l’ApplicationRunner qui est similaire à CommandLineRunner, mais qui utilise une abstraction ApplicationArguments, ce qui offre des fonctionnalités supplémentaires pour traiter les arguments de la ligne de commande.

Les deux interfaces sont fonctionnellement similaires, mais ApplicationRunner offre une approche un peu plus orientée objet pour manipuler les arguments de la ligne de commande.

1. CommandLineRunner

Cette interface permet d’obtenir les arguments de la ligne de commande sous forme d’un tableau.

@SpringBootApplication 
public class SpringBootWebApplication implements CommandLineRunner { 
 public static void main(String[] args) throws Exception { 
   SpringApplication.run(SpringBootWebApplication.class, args); 
 } 
 @Override 
 public void run(String... args) throws Exception { 
   logger.info("Application Started !!"); ...

Annotation

@EnableConfigurationProperties est une annotation de Spring Boot qui est utilisée pour activer la prise en charge de la configuration des propriétés via des classes Java. Elle permet de définir des propriétés dans un fichier de configuration (comme application.properties ou application.yml) et de les mapper automatiquement sur un bean de configuration personnalisé.

Voici un exemple de la manière dont vous pouvez l’utiliser :

Création d’une classe de configuration de propriétés :

Vous commencez par créer une classe qui représentera vos paramètres de configuration. Utilisez l’annotation @ConfigurationProperties pour définir le préfixe des propriétés.

   @Data 
   @ConfigurationProperties(prefix = "app") 
   public class AppConfig { 
     private String name; 
     private int version; 
 
   } 

Activation de la configuration de propriétés :

Ensuite, dans votre classe de configuration ou classe principale, utilisez @EnableConfigurationProperties pour activer la classe de configuration de propriétés que vous avez définie.

   @SpringBootApplication 
   @EnableConfigurationProperties(AppConfig.class) ...

Configuration des logs

Spring Boot utilise le Commons Logging pour tous les logs, mais il est possible de changer le comportement par défaut. Les configurations par défaut sont fournies pour Java Util Logging, Log4J2 et Logback. Dans chaque cas, les enregistreurs sont préconfigurés pour utiliser la sortie de la console avec la sortie de fichier facultative.

Par défaut, si vous utilisez les starters, Logback sera utilisé pour les logs. Le routage Logback approprié est également inclus pour garantir que les bibliothèques dépendantes qui utilisent Java Util Logging, Commons Logging, Log4J ou SLF4J fonctionnent correctement.

Nous avons à notre disposition les niveaux de logs classiques FATAL (sauf pour Logback), ERROR, WARN, INFO, DEBUG et TRACE.

1. Logs en couleur

Si on ne spécifie rien, les logs sont monochromes, mais il est possible de mettre de la couleur dans les logs. Le système utilisé par défaut est Logback qui supporte les couleurs.

Pour ce faire, il faut positionner la variable de configuration : spring.output.ansi.enabled=always.

La première possibilité consiste à mettre un format pour le log dans le fichier de configuration de l’application :

Dans le fichier de configuration :

logging.pattern.console=%d{dd-MM-yyyy HH:mm:ss.SSS} 
%magenta([%thread]) %highlight(%-5level) %logger.%M - %msg%n 

Ici nous créons des logs pour les voir en couleur :

LOGGER.trace("Test des logs:trace"); 
LOGGER.debug("Test des logs:debug"); 
LOGGER.info("Test des logs:info"); 
LOGGER.warn("Test des logs:warn"); 
LOGGER.error("Test des logs:error"); 

Log affichée :

12:42:27.545 [main] TRACE 
fr.eni.spring5.logs.Ex1Logs.run - Test des logs:trace 
12:42:27.545 [main] DEBUG 
fr.eni.spring5.logs.Ex1Logs.run - Test des logs:debug 
12:42:27.545 [main] INFO 
fr.eni.spring5.logs.Ex1Logs.run - Test des logs:info 
12:42:27.545 [main] WARN 
fr.eni.spring5.logs.Ex1Logs.run - Test des logs:warn 
12:42:27.545 [main] ERROR 
fr.eni.spring5.logs.Ex1Logs.run - Test des logs:error 

Nous avons alors :

  • pour les blocs [main] avec le thread en rose ;

  • TRACE et DEBUG en noir ;

  • INFO en bleu ;

  • WARN en orange ;

  • ERROR en rouge.

Une autre possibilité est d’utiliser le format...

Autoconfiguration pour Spring MVC

Spring Boot offre une autoconfiguration pour Spring MVC à travers le starter spring-boot-starter-web, qui apporte plusieurs fonctionnalités clés pour les applications web. Cette configuration inclut automatiquement le bean ContentNegotiatingViewResolver et le bean BeanNameViewResolver, qui sont essentiels pour la résolution des vues. Elle assure également la prise en charge des ressources statiques, permettant l’intégration d’un fichier index.html, d’un Favicon personnalisé et des WebJars pour gérer les dépendances côté client. De plus, elle gère l’enregistrement automatique de divers beans tels que Converter, GenericConverter, Formatter et MessageCodesResolver, qui sont cruciaux pour la conversion de données et la gestion des codes de message.

Enfin, l’autoconfiguration de Spring MVC dans Spring Boot supporte les HttpMessageConverters et utilise un bean ConfigurableWebBindingInitializer de manière automatique, facilitant ainsi la gestion des requêtes et des réponses HTTP ainsi que la configuration de la liaison des données web. Il est possible de ne garder que les fonctionnalités Spring MVC en ajoutant les beans de configuration intercepteurs, formateurs et contrôleurs de vues en créant notre propre classe @Configuration de type...

Gestion des sessions

Aujourd’hui, nous privilégions une architecture sans état (stateless) dans nos applications, car gérer les sessions utilisateur complique le processus de mise en cluster des serveurs, principalement en raison des défis liés au partage des données de session entre différents serveurs. Pour contourner ce problème, nous simulons la gestion des sessions en utilisant un cache partagé.

Cependant, dans certaines situations, la gestion des sessions est inévitable. Pour ces cas, Spring Session offre une solution. Spring Session est un projet qui propose une alternative à la gestion traditionnelle des sessions par des conteneurs tels que Tomcat ou Jetty. Il existe deux versions principales du projet Spring Session, chacune offrant des fonctionnalités différentes.

L’objectif principal de Spring Session est de gérer les sessions de manière transparente. Il permet de stocker les données de session en dehors du conteneur de servlet traditionnel, par exemple dans des bases de données comme Redis, des bases de données SQL, ou même dans des systèmes comme Apache Geode. Cela facilite la mise en œuvre de sessions dans des applications distribuées et en cluster, tout en offrant une évolutivité et une flexibilité accrues par rapport aux mécanismes de session traditionnels.

Spring Session...

Description avancée de Spring Boot

Nous allons aborder certains éléments avancés de Spring-boot qui permettent de comprendre son fonctionnement interne.

1. Séquence de lancement

Cette sous-section décrit le lancement d’un programme Spring Boot. Il permet de démystifier une fois de plus la « magie » apparente du système qui est en fait le résultat d’un travail intéressant et consciencieux. Spring utilise pour son compte les mécanismes de Spring Boot qu’il met à notre disposition.

Les sources de Spring Boot sont visibles ici : https://github.com/spring-projects/spring-boot. Nous pouvons étudier le comportement de Spring Boot au démarrage à partir des sources. Une application Spring Boot se caractérise par deux éléments : l’annotation @SpringBootConfiguration et la méthode statique run au sein d’un programme Java standard :

@SpringBootApplication 
public class Application { 
public static void main(String[] args) { 
 SpringApplication.run(Application.class, args); 
 } 
} 

L’annotation @SpringBootApplication est une composition des annotations @SpringBootConfiguration, @EnableAutoConfiguration et @ComponentScan avec leurs attributs par défaut.

Comme nous l’avons vu, l’annotation @SpringBootConfiguration est un alias vers l’annotation @Configuration et l’annotation @EnableAutoConfiguration indique que nous avons de la configuration embarquée dans le code. L’annotation @ComponentScan indique que le package qui contient la classe principale sert de package racine pour le scan des composants Spring. L’annotation @EnableAutoConfiguration est une annotation Spring Boot qui indique que nous allons faire usage de la mécanique d’autoconfiguration.

La séquence de démarrage indique à travers l’analyse des sources de la méthode statique run que Spring Boot démarre via ces phases :

  • chargement du BootstrapContext ;

  • lancement des listeners ;

  • paramètres d’environnement ;

  • création de l’ApplicationContext ;

  • Prepare, Refresh & PostRefresh du contexte ;

  • exécution des runners.

2. Chargement du BootstrapContext

Spring Boot commence par initialiser...

Spring Boot Admin

Spring Boot Admin est une application web qui sert à la gestion et au suivi des applications Spring Boot. Chaque application est considérée comme un client et s’enregistre auprès du serveur d’administration. Derrière le rideau, c’est l’Actuator de Spring Boot qui fournit les fonctionnalités nécessaires.

Pour configurer un serveur Spring Boot Admin, vous devez d’abord créer une application web Spring Boot simple et y ajouter une dépendance Maven spécifique. Ensuite, vous marquerez votre classe principale avec l’annotation @EnableAdminServer. Ceci est suffisant pour activer le serveur d’administration de Spring Boot. Après avoir démarré l’application, vous pouvez accéder à l’interface utilisateur via l’URL locale par défaut.

Pour configurer un client d’administration, vous devez ajouter une autre dépendance Maven à votre application Spring Boot. Cela intègrera automatiquement le jar Actuator. Vous devrez également mettre à jour le fichier application.properties avec certaines propriétés, y compris l’URL du serveur d’administration Spring Boot Admin. Pour des raisons de sécurité, il est conseillé d’ajouter une couche de sécurité à votre application, en utilisant par exemple...

Points clés

Points à retenir :

  • Spring Boot est utilisé pour les applications qui sont en production.

  • Spring Boot réduit considérablement le code à produire.

  • Spring Boot peut permettre de faire des composants autoconfigurables.