Spring Boot

Spring est un framework proposant de très nombreuses fonctionnalités (Web, Sécurité, batch, accès aux données…) mais sa configuration peut s’avérer complexe et fastidieuse.

Sur le principe de “convention over configuration”, Spring Boot a été développé pour faciliter la configuration Spring grâce à :

l’auto-configuration

les starters

l’approche client lourd

On utilise des gestionnaires de dépendances (Gradle ou Maven).

On sélectionne des starters ou ensembles de dépendances regroupées par catégorie avec tout ce dont on a besoin : les dépendances (et leurs dépendances), la configuration par défaut, etc. Par exemple : Spring Web, Spring Boot Dev Tools, Jersey, Spring Data JPA…

Les librairies nécessaires sont téléchargées et ajoutées au classpath. Selon ce qu’il y a dans le classpath, l’auto-configuration lance de manière automatisée les librairies présentes (Tomcat embarqué, bases de données…).

ℹ️

On ne fait plus que du Spring Boot maintenant.

⚙

Outils : • Spring Tools : plugin pour les IDEs (Eclipse, Visual Studio, Atom IDE) • Spring initializr : https://start.spring.io/ Ces deux outils sont déjà inclus dans IntelliJ Ultimate.

Hello World

Projet GitHub : https://github.com/LSarribouette/springboot-basics/

Spring initializr = point d’entrée dans le projet, où on choisit ce dont on a besoin.

Depuis le site internet :
> Gestionnaire de dépendances ? ici, Gradle Groovy
(+) Pour l’instant, peu importe Gradle ou Maven ; peu importe Groovy ou Kotlin.
> Langage ? ici, Java
> Spring Boot ? ici, 2.7.9
(+) La problématique des versions de dépendances est maintenant gérée par Spring Boot. On choisit une version de Spring Boot et il gère les versions des dépendances et leur migration potentielle.
> Métadonnées ?
- group (propriétaire du projet et nom de domaine inversé) = fr.lsarribouette
- artifact (nom du projet) = springbootbasics
- package name (un par défaut, que l’on peut changer) = fr.lsarribouette
- packaging = jar
  (+) On n’utilise plus que le Tomcat intégré pour réaliser des applications web, donc on n’a plus besoin du war.
- java version = ici, 11
> Dépendances ? ici, Spring Web, Thymeleaf, Spring Boot Dev Tools
(+) C’est ici que l’on choisit ses starters. On peut ajouter le starter Spring Data JPA et une base de données comme H2 database.
> Generate
On obtient un zip, que l’on importe dans notre IDE.

Dans IntelliJ,
> New project > Spring initializr : même démarche qu’en 1.

⚙

Outils : Lombok est une librairie qui simplifie la création et la gestion de méthodes basiques grâce à des annotations (ex : @toString, @setter, @getter,…). —> meilleure lisibilité, mieux pour les tests (pour 80% de couverture de code, on est content que la classe soit moins longue), tout se met à jour lors de l’ajout d’un attribut. Il faut rajouter le plugin spécifique.

ℹ️

Rappel : Une classe de base = attributs privés + getter/setter + constructeurs (vide, full avec id, full sans id) + toString() + equals() + hashcode()

Pour ajouter une dépendance : mvnrepository (site central pour maven, gradle, Ivy…)

> on cherche celle qu’on veut

> on choisit sa version

> on choisit l’onglet de notre gestionnaire de dépendances

> on ajoute le code proposé dans le fichier de configuration approprié

> on clique sur le bouton pour recharger le projet

> la dépendance est téléchargée, ainsi que toutes ses dépendances à elle (et les leurs également)

Architecture du projet

On a maintenant un projet configuré selon les starters sélectionnés avec :

un dossier src qui contient
- un dossier main pour les fichiers de production
- un dossier test pour … les tests

les fichiers de configuration
ℹ️
Gradle : le fichier build.gradle contient la configuration du projet Gradle (avec les dépendances, leurs versions, etc). Maven : l’équivalent est le fichier pom.xml.

Le dossier main contient :

un dossier java avec
- la classe d’exécution (avec le main)

un dossier resources avec
- un dossier static pour les fichiers CSS, JavaScript, les medias…
- un dossier templates pour les templates de page (Thymeleaf)
- le fichier application.properties pour configurer Spring (port, profil…)

La classe d’exécution porte par défaut l’annotation @SpringBootApplication et la méthode run() qui permet de faire l’auto-configuration : tout ce qu’il nous fait est lancé (comme le serveur Tomcat et une éventuelle base de données).

ℹ️

Grâce aux starters, on a notamment les librairies : - Jakson qui gère le mapping entre objets java et autres flux textes (json,xml…) - HikariCP qui permet d’utiliser un pool de connexion (demande au serveur d’application ou à Spring de créer un conteneur avec des connexions vivantes vers la base) - Jakarta Persistence API (JPA), Hibernate, Tomcat embed (embarqué), JAXB… - plusieurs pour les tests

L’annotation @SpringBootApplication correspond en fait aux annotations :

@SpringBootConfiguration —> il indique que c’est une classe de configuration

@EnableAutoConfiguration —> il démarre ce qu’il faut en fonction de ce qui est fourni dans l’application

@ComponentScan —> (avec des paramètres) il indique à Spring qu’il faut aller voir dans ce package et tous les sous-packages s’il y a des annotations (et les prendre en compte)

Lancement d’une application web

On lance l’application.

Sur un navigateur, on va sur http://localhost:8080/.

Ca fonctionne : on a une erreur 404 puisqu’on a pas de page, mais on se connecte bien à notre application.

Dans resources/static, on crée un fichier index.html statique que l’on complète.

Ca fonctionne : on voit maintenant le index.html.