Tutoriel sur le développement full stack d'une application Web avec Angular 7 et Spring Boot 2


précédentsommairesuivant

III. Création du projet Spring Boot

Spring Boot offre la possibilité de créer deux types d'application :

  • Java archive, correspondant à une application dont le paquetage est d'extension .jar ;
  • Web archive, correspondant à une application dont le paquetage est d'extension .war.

Dans cet article et pour notre exemple, nous allons créer une application web et donc de type .war. Spring Boot nous donne la possibilité de créer un projet Java déjà préconstruit et disposant des configurations Spring de base permettant à l'application d'être immédiatement exploitable. Il fonctionne à la manière d'un Magasin à outils qui nous donne la possibilité de faire notre marché et de choisir les différents outils nécessaires à la réalisation de notre application. Les avantages de Spring Boot sont nombreux :

  • offre une interface simple de création d'un projet organisé et préconfiguré, prêt à exploitation ;
  • permet l'ajout des dépendances et la gestion de leurs versions via des Starters ;
  • permet l'autoconfiguration d'une application moyennant des annotations simples ;
  • donne la possibilité de déployer/exécuter l'application sans aucune autre ressource externe (mode standalone pour le cas des applications .jar) ;
  • simplifie la configuration du projet pour permettre de se concentrer sur le développement des règles métiers ;
  • ajouter de nouvelles dépendances reste simple pendant la phase de développement ;
  • etc.

Nous vous présentons ci-dessous les deux étapes nécessaires à la création d'un projet Spring Boot que nous guidons par les besoins de notre application de gestion de bibliothèque (appelée Library, en anglais).

Étape 1 : aller sur le site web de Spring Boot https://start.spring.io/ pour la création et la préconfiguration du projet Library.

Image non disponible

Dans cette capture d'écran, nous avons préconfiguré quatre éléments :

  • nous créons un projet de type Maven pour la gestion des dépendances, du cycle de vie et l'organisation de packages. L'autre option étant Gradle ;
  • nous créons un projet dont le langage applicatif est Java. Les autres options étant Kotlin et Groovy ;
  • nous choisissons la version 2.1.7 de Spring Boot qui est celle effectivement éprouvée lors de l'écriture de cet article ;
  • ensuite, nous paramétrons le goup id de l'application (com.gkemayo), le nom du projet (library) et le type d'artefact à générer par Maven (war) ;
  • et finalement, nous choisissons la version du langage Java utilisée pour la compilation des sources, Java 8.

Étape 2 : nous allons maintenant choisir les différentes dépendances que Spring Boot inclura dans notre projet. Pour rappel, dans la section II-BChoix et proposition d'architecture (Choix et proposition d'architecture), nous avons listé les besoins techniques de l'application. Ici, nous choisissons déjà ce que Spring Boot nous propose, le reste sera ajouté manuellement plus tard une fois le projet généré.

Image non disponible

La figure ci-dessus présente une capture d'écran montrant entre autres le choix des dépendances H2 et Spring Data JPA. Le petit onglet en haut à droite nous indique que nous avons inclus quatre dépendances dans notre projet. Les deux autres étant Spring mail et Spring web.

En cliquant enfin sur le bouton Generate the project, nous téléchargeons le projet ainsi créé (sous forme de zip) sur notre machine pour utilisation. En le dézippant et en l'ouvrant à l'aide d'un IDE comme Eclipse, il est prêt pour contenir du code métier. Mais avant d'y arriver, nous pouvons visualiser la structure de ce projet en cliquant sur le bouton Explore the project :

Image non disponible

Nous pouvons aisément remarquer sur la partie gauche de cette image, le rendu structurel d'un projet maven avec les packages src/main/java, src/main/resources et src/main/test.

IV. Exploration du projet Spring Boot

IV-A. Le pom.xml

Une fois notre projet maven créé via Spring Boot, le pom.xml généré est le suivant :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.gkemayo</groupId>
    <artifactId>library</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>library</name>
    <description>Project for managing books in a library</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <scope>runtime</scope>
            </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

Pour expliquer ce pom.xml, nous le découpons en quatre blocs :

Bloc 1 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.7.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

Ce bloc décrit le projet parent du projet library. En effet, tout projet Spring Boot créé est toujours en quelque sorte un module d'un projet parent nommé spring-boot-starter-parent dont le group id est org.springframework.boot. Pour cet exemple, ce parent est à la version 2.1.7 (celle que nous avons choisie à la section IIICréation du projet Spring Boot). C'est au sein de ce projet parent que les différentes dépendances que nous invoquerons dans le bloc 3 ci-dessous sont gérées. Le pom.xml du parent est consultable ici.

Bloc 2 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
<groupId>com.gkemayo</groupId>
<artifactId>library</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>library</name>
<description>Project for managing books in a library</description>

<properties>
    <java.version>1.8</java.version>
</properties>

Ce bloc correspond essentiellement aux différents paramètres que nous avons renseignés lors de la création du projet (cf. figure 1 de la section IIConception et choix architectural).

Bloc 3 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-mail</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
           <groupId>com.h2database</groupId>
           <artifactId>h2</artifactId>
           <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Dans ce bloc, nous demandons à Spring Boot d'injecter les dépendances concernant Spring Mail (spring-boot-starter-mail), Spring Data et Hibernate (spring-boot-starter-data-jpa), Spring Web (spring-boot-starter-web), la base de données embarquée H2 (h2) et un Tomcat embarqué (spring-boot-starter-tomcat). Par défaut, Spring Boot injecte le starter spring-boot-starter-test qui permet d'embarquer les dépendances telles que JUnit permettant de réaliser des tests unitaires dans notre application, mais cela n'est pas le point focal de cet article.

Enfin, nous pouvons remarquer (pour ceux qui connaissent nommément la dépendance maven de certains frameworks) que la plupart du temps Spring Boot n'inclut pas directement la dépendance du framework souhaité, mais utilise plutôt la notion de dépendance starter. Cette notion est introduite pour déléguer la possibilité au projet parent (spring-boot-starter-parent) de gérer lui-même les dépendances maven effectives ainsi que les versions à inclure dans notre projet. Ceci permet au développeur de s'affranchir de la gestion propre des conflits entre dépendances. Une définition complète des starters Spring Boot est disponible ici.

Bloc 4 :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Cette partie du pom.xml signifie simplement que l'on délègue la construction automatique des artefacts du projet library à Spring Boot qui utilisera maven pour le faire.

IV-B. application.properties

Si vous avez déjà eu à faire de la configuration Spring, il va sans dire que vous connaissez la difficulté à gérer et maintenir les différents fichiers ressources .properties contenant les données dont les beans injectés dans votre application ont besoin pour fonctionner correctement. Ceci est encore plus difficile lorsque vous gérer la configuration Spring effectuée dans des fichiers xml.

Pour pallier ce dispersement dans la configuration des fichiers ressources, Spring Boot propose l'unique et central fichier application.properties dans lequel il faut mettre toutes les données nécessaires aux beans injectés dans l'application. application.properties comme tout fichier ressource Spring, contient une liste de données clef=valeur.

Enfin, Spring Boot a déjà recensé pour nous, une liste de ressources standards qui peuvent être ajoutées à l'application.properties de notre application en fonction du besoin. Nous pouvons trouver la liste ici.

IV-C. LibraryApplication.java et ServletInitializer.java

Après avoir généré le projet web Spring Boot library, en le dezippant et en l'ouvrant, on constate la présence de deux classes java dans le package com.gkemayo.library : LibraryApplication.java et ServletInitializer.java.

LibraryApplication.java :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
package com.gkemayo.library;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LibraryApplication {

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

Cette classe est le point d'entrée de notre application. C'est-à-dire, la classe utilisée par Spring Boot pour démarrer (booter) notre application. En effet, Spring Boot marque toute classe comme point de démarrage d'une application par l'annotation @SpringBootApplication. Cette annotation propre à Spring Boot est en réalité l’agrégation de trois annotations Spring qui sont :

  • @configuration : cette annotation indique à Spring de considérer la classe sur laquelle elle est apposée comme étant un bean dans lequel d'autres beans peuvent être déclarés ;
  • @CompoenentScan(basePackages = "com.gkemayo.library") : cette annotation indique à Spring de scanner le package et les sous-packages passés en paramètre pour rechercher des classes qu'elle pourrait injecter comme beans dans l'application. Ces classes peuvent être marquées par des annotations telles @Component, @RestController, @Service, @Repository, @Configuration, etc. Lorsque l'annotation @ComponentScan ne prend pas de paramètre, alors c'est le package de la classe sur laquelle elle est apposée qui est considéré ;
  • @EnableAutoConfiguration : cette annotation permet de détecter et d'injecter comme bean, certaines classes contenues dans les dépendances du classpath de votre application.

ServletInitializer.java :

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
package com.gkemayo.library;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(LibraryApplication.class);
    }

}

Toute application web doit se voir configurer une classe Servlet dont le but est d'intercepter toute requête HTTP -- venant d'un client web en direction d'un serveur d'application -- dans l'optique de la contrôler et de gérer l'intercommunication. Spring Boot crée automatiquement pour tout projet web la classe ServletInitializer héritant de SpringBootServletInitializer correspondant à la servlet de notre application et utilisant toutes les ressources de la classe de démarrage, dans le cas d'espèce LibraryApplication.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2019 Georges KEMAYO. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.