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

<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> 

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

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....

É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.

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.

@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.

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

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"); 

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 

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.

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

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...