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

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

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

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

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

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

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

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.

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 :

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 :

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.