Tutoriel Spring Boot : créer des applications Java avec Spring Boot

Depuis sa publication en 1995, Java compte au rang des langages de programmation les plus populaires et les plus utilisés. Ce langage orienté objet est particulièrement utile lorsqu’il s’agit de réaliser des applications commerciales complexes (en ligne et hors ligne). Combinées à l’environnement d’exécution Java (JRE), ces applications se démarquent principalement par leur indépendance vis-à-vis des plateformes, ce qui les rend accessibles à un vaste public.

Pour faciliter le travail avec Java, différentes infrastructures logicielles ont été développées au cours de cette dernière décennie afin de mettre à disposition de l’utilisateur une trame de base prête à l’emploi pour le programme Java qu’on souhaite développer. L’une des plus connues est l’infrastructure logicielle en open source Spring, publiée en 2003, qui diminue nettement la complexité de la spécification Java standard (« J2EE » ou « plateforme Java ») mais aussi de l’architecture de composants Enterprise JavaBeans (« EJB »). Après la mise à disposition de l’extension Spring Boot, qui simplifie encore la configuration de nouveaux projets Spring, cette trame s’est révélée un choix optimal et convivial pour toutes les personnes ne souhaitant pas commencer le développement d’une nouvelle application Java entièrement de zéro.

Dans ce tutoriel Spring Boot, vous découvrirez quels sont les prérequis à respecter pour l’utilisation de cet outil et vous apprendrez comment réaliser avec brio vos premiers pas dans cette infrastructure logicielle modulaire et « son extension Spring Boot.

Qu’est-ce que Spring Boot ?

Publiée en 2012, Spring Boot est une solution de « convention plutôt que configuration » destinée à l’infrastructure logicielle Java Spring qui réduit la complexité de la configuration de nouveaux projets Spring. À cette fin, Spring Boot définit une configuration de base incluant des directives pour l’utilisation de l’infrastructure logicielle ainsi que toutes les bibliothèques de prestataires tiers pertinentes, ce qui permet de faciliter autant que possible la création de nouveaux projets. Cette méthode simplifie considérablement la création d’applications indépendantes prêtes pour la production, ce qui explique pourquoi la majorité des nouvelles applications Spring reposent en grande partie sur Spring Boot.

Les caractéristiques de Spring Boot peuvent être résumées comme suit :

  • l’intégration directe d’applications de serveur Web/de conteneur comme Apache Tomcat ou Jetty sans utiliser de fichiers WAR (Web Application Archive)
  • la configuration simplifiée de Maven grâce à des POM (Project Object Models) « Starter »
  • lorsque c’est possible, la configuration automatique de Spring
  • la mise à disposition de capacités non fonctionnelles telles que des outils de mesure ou des configurations délocalisées

Grâce à Spring Boot, la société de développement Pivotal Software a complété l’infrastructure logicielle parue en 2005 avec une nouvelle approche moderne et tournée vers l’avenir. L’infrastructure technique de base de Spring, améliorée depuis des années, a été très largement intégrée dans l’extension Spring Boot. Vous trouverez des informations détaillées sur cette infrastructure logicielle en open source (Licence Apache 2.0) dans notre article détaillé sur cette trame de base Java très largement utilisée.

Tutoriel Spring Boot : exigences, installation et premiers pas

Depuis l’extension de Spring avec Spring Boot, le logiciel de Pivotal Software est considéré comme l’une des meilleures solutions en termes de développement de microservices sous Java. Grâce à près de 20 modules du framework de base pouvant être assemblés comme vous le souhaitez, Spring Boot convient toutefois également à une multitude d’autres scénarios et ne saurait véritablement être classé comme framework pour les applications Web ou comme solution classique pour les applications de bureau.

Avant d’aborder plus avant la configuration et la création d’un nouveau projet ainsi que la structure de Spring Boot dans ce tutoriel Spring Boot, nous traiterons dans un premier temps des exigences techniques et de la mise en place des composants de projet nécessaires.

Quels sont les prérequis logiciels de Spring Boot ?

Java est incontournable lorsqu’il s’agit de Spring Boot. C’est la raison pour laquelle l’environnement d’exécution Java (plateforme Java) est la composante logicielle indispensable au fonctionnement de l’infrastructure. Puisque que cette plateforme ne sert pas uniquement à l’exécution de l’application, mais également au développement avec Java, vous aurez au minimum besoin de la version 8 (ou 1.8) du Java Development Kit (JDK). Celui-ci contient par ailleurs des outils pratiques venant compléter l’environnement d’exécution afin de programmer et de tester les applications Java. Il est disponible aussi bien sur Linux que sur Windows et macOS. Vous avez donc carte blanche en ce qui concerne le système d’exploitation.

Naturellement, l’extension requiert également que la version actuelle de l’infrastructure Spring soit installée sur le système.

Maven (à partir de la version 3.3) ou Gradle (à partir de la version 4.4) peuvent être utilisés comme outils de production.

Si vous souhaitez profiter de la possibilité d’intégrer un serveur Web exécutant votre application Java sur la base d’un Servlet, vous pouvez choisir parmi les trois solutions suivantes : Apache Tomcat (à partir de 9.0), Jetty (à partir de 9.4) et Undertow (à partir de 2.0).

Créez votre premier projet Spring Boot

L’utilisation de Spring Boot est similaire à celle de toute bibliothèque Java standard : elle s’effectue en intégrant les fichiers JAR (Java Archive) ou WAR (Web Application Archive) correspondants dans le chemin de classes (Classpath). Java utilise ce chemin dans le système de fichier pour rechercher les fichiers exécutables. Dans ce cadre, les fichiers archives pour Spring Boot peuvent être créés de deux façons :

  • Vous pouvez installer et utiliser Maven ou Gradle afin de créer personnellement la trame du projet incluant les contraintes nécessaires.
  • Vous pouvez utiliser le service Web Spring Initializr pour établir votre configuration Spring Boot puis la télécharger sous la forme d’un modèle de projet fini.

La particularité de cette seconde solution réside dans le fait que vous pourrez créer les fichiers JAR via une interface Web conviviale qui simplifie considérablement le processus. Comme le service Initializr a également recours à Maven ou Gradle afin de générer les fichiers, le résultat ne sera pas différent de celui d’une procédure manuelle. Dans le cadre de ce tutoriel Java ou Spring Boot, nous avons donc opté pour l’assistant Web disponible à l’adresse start.spring.io.

Note

Si vous optez pour l’utilisation de Spring Initializr, Java et Maven ou Gradle doivent également être installés pour pouvoir travailler sur votre application Spring Boot.

Si vous avez ouvert Spring Initializr, vous pouvez définir dans l’ordre les propriétés souhaitées pour votre première application Spring Boot : Tout d’abord, déterminez le système de production en sélectionnant « Maven Project » ou « Gradle Project ». La deuxième ligne vous donne la possibilité d’opter pour le langage classique Java ou pour un autre langage de la famille Java tel que Kotlin ou Groovy. D’autre part, définissez la version de Spring Boot sous-jacente, les métadonnées du projet (incluant la version de Java) ainsi que toutes les autres contraintes pertinentes (bases de données, fonctionnalités de sécurité, interfaces Web, services Cloud, etc.). En cliquant sur « Generate Project », vous générez finalement les fichiers du projet.

Spring Initializr : création d’un projet Spring Boot basé sur Maven
Le format WAR vient compléter JAR avec différents composants Web tels que le fichier de configuration XML web.xml qui décrit le processus de mise à disposition.
Conseil

Si vous souhaitez créer votre projet Spring Boot vous-même avec Maven et Gradle, vous pouvez suivre les instructions d’installation figurant dans les manuels en ligne officiels.

Exécuter le projet Spring Boot créé

Spring Initializr vous propose de télécharger les fichiers du projet créés sous la forme d’une archive ZIP que vous devrez décompresser après téléchargement. Dans le dossier décompressé, vous trouverez notamment le fichier de configuration correspondant : si vous avez sélectionné Gradle pour la gestion de la production, il s’agit dans ce cas du fichier build.gradle ; dans le cas des projets Maven, vous devriez y trouver le fichier pom.xml. Dans ce dernier cas, qui s’applique également à l’exemple de notre tutoriel Spring Boot, le contenu du fichier de configuration ressemble à peu près à ce qui suit :

Extrait du fichier de configuration pom.xml généré pour Maven
Le fichier de configuration Maven se distingue par sa structure XML typique et comporte des métadonnées essentielles.

À l’aide du logiciel de production correspondant, créez une application Spring Boot exécutable à partir des fichiers archives obtenus. Pour ce faire, ouvrez le terminal ou l’invite de commandes et exécutez la commande suivante dans le dossier cible (c’est-à-dire dans le dossier de vos fichiers Spring Boot) si vous utilisez Maven :

mvn clean install
Invite de commandes Windows : génération du fichier JAR avec Maven
Maven fonctionne selon le modèle « convention plutôt que configuration », raison pour laquelle les paramètres de base tels que le format d’édition JAR sont automatiquement utilisés pour le processus de production dans la mesure où vous n’avez pas donné de consignes spécifiques.

Pour les projets Gradle, la commande se présente comme suit :

gradle clean build

Une fois le traitement de la commande réussi, vous obtenez dans les deux cas le message « BUILD SUCCESS » dès que les fichiers archives ont été créés avec succès. Dans ce cadre, le fichier exécutable est enregistré dans le dossier « target » (Maven) ou « build/libs » (Gradle). Dans notre cas, le nom de ce fichier JAR est « demo-0.0.1-SNAPSHOT.jar » :

Fichier JAR généré dans le dossier Maven cible sous Windows 10
La création des fichiers archives peut prendre quelques minutes en fonction du nombre de contraintes ajoutées au préalable avec Spring Initializr.

Vous pouvez procéder à l’exécution à l’aide de Java en saisissant la commande suivante :

java -jar demo-0.0.1-SNAPSHOT.jar
Initialisation de l’application Spring Boot
Pour que le démarrage de l’application Spring Boot fonctionne, vous devez exécuter le code indiqué dans le dossier du fichier JAR (target).

Le nom du fichier JAR écrit en italique dans l’exemple de code doit être remplacé s’il ne correspond pas. Vous pouvez à présent vérifier, à l’aide de l’output affiché dans l’invite de commande, si l’application Spring Boot a pu être démarrée avec succès. Si vous avez intégré l’un des serveurs Web indiqués plus haut, comme Tomcat, celui-ci est également lancé. Vous pouvez l’atteindre avec le navigateur de votre choix en consultant l’adresse suivante :

http://localhost:8080

Connecter Spring Boot à la base de données et à la source de données

Spring Boot propose une assistance de premier ordre pour la création et l’intégration des sources de données dans les bases de données SQL ou NoSQL de votre choix. Vous n’aurez pas à écrire de code supplémentaire pour créer une source de données, mais uniquement à ajouter les contraintes nécessaires et les détails de la configuration. Cet avantage provient de l’interface de base de données homogène JDBC (Java Database Connectivity) pour laquelle il convient tout d’abord de créer une entrée Starter dans le fichier de configuration si vous n’avez pas déjà ajouté la contrainte lors de la création du projet avec Spring Initializr (il en va de même pour l’ajout des autres contraintes mentionnées).

Pour ce faire, les utilisateurs Maven doivent saisir les lignes suivantes dans le fichier pom.xml :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Les utilisateurs Gradle réalisent cette étape en insérant l’entrée suivante dans le fichier build.gradle :

compile('org.springframework.boot:spring-boot-starter-jdbc')
Note

Vous pouvez ouvrir le fichier de configuration en question avec n’importe quel éditeur de code usuel. Il est essentiel que le fichier soit à nouveau enregistré au format XML ou Gradle après les modifications.

Lors de la deuxième étape, vous allez compléter le fichier de configuration de la production concerné en y ajoutant la contrainte pour le système de gestion de base de données souhaité. Dans ce tutoriel Spring Boot, nous connectons notre application à une base de données MySQL que nous souhaitons utiliser pour notre application et que nous avons installée au préalable.

Pour cela, le pom.xml des projets Maven doit recevoir la nouvelle entrée suivante :

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

Dans la configuration Gradle, la ligne suivante doit être saisie pour établir la connexion avec la base de données MySQL :

compile('mysql:mysql-connector-java')

Certaines propriétés doivent ensuite être ajoutées dans le fichier de PROPRIÉTÉS « application ». Ce fichier peut être trouvé en entrant \src\main\resources dans le répertoire du projet Spring Boot. Ouvrez ce fichier texte et insérez les lignes de configuration suivantes :

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.tomcat.testOnBorrow = true
spring.datasource.tomcat.testWhileIdle = true
spring.datasource.tomcat.timeBetweenEvictionRunsMillis = 60000
spring.datasource.tomcat.minEvictableIdleTimeMillis = 30000
spring.datasource.tomcat.validationQuery = SELECT 1
spring.datasource.tomcat.max-active = 15
spring.datasource.tomcat.max-idle = 10
spring.datasource.tomcat.max-wait = 8000

Si vous ne l’avez pas déjà fait, vous pouvez à présent utiliser MySQL de la manière habituelle afin de créer une base de données comportant les données souhaitées. Les débutants trouveront des informations détaillées sur l’utilisation du système de gestion de base de données relationnelles dans notre tutoriel MySQL complet.

Générer un certificat SSL/TLS et activer HTTPS

Par défaut, une application Spring Boot créée utilise le protocole non sécurisé HTTP et le port TCP 8080 pour la connexion au serveur Web en question. Pour utiliser le protocole sécurisé HTTPS et configurer le port TCP 443 prévu à cet effet comme choix par défaut, utilisez un certificat SSL/TLS ainsi que les propriétés adaptées dans le fichier PROPRIÉTÉS « application ».

Vous pouvez obtenir ce certificat auprès d’un organisme de certification ou en créant un certificat autosigné à l’aide de l’environnement d’exécution Java. Grâce à cet utilitaire de gestion, cet environnement dispose d’un outil de ligne de commande permettant de créer en toute simplicité des fichiers PKCS12 (contenant un certificat X.509 et une clé privée) pour les serveurs comme Tomcat, Exchange, IIS etc. Si vous utilisez par exemple un serveur Tomcat, saisissez dans l’invite de commandes ou dans le terminal la commande suivante afin de générer le fichier d’enregistrement de clé pour votre application Spring Boot :

keytool -genkeypair -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650

Afin de personnaliser votre certificat, définissez ensuite un mot de passe personnel et indiquez quelques informations sur vous-même, votre entreprise et votre localisation.

Le fichier d’enregistrement de clé est ensuite automatiquement sauvegardé dans le répertoire où vous avez exécuté la commande (dans ce tutoriel Spring Boot, il s’agit du répertoire d’utilisateur). Copiez le fichier « keystore » dans le répertoire de votre application Spring Boot et complétez le fichier PROPERTIES « application » déjà utilisé pour l’intégration de la base de données avec les lignes suivantes :

server.port = 443
server.ssl.key-store = C:/demo/keystore.p12
server.ssl.key-store-password = springboot
server.ssl.key-store-type = PKCS12
server.ssl.key-alias = tomcat

Pour finir, créez à l’aide de la commande suivante un nouveau fichier JAR exécutable qui sera connecté à Tomcat de la manière configurée via HTTPS :

mvn -Dmaven.test.skip=true -DskipTests=true clean install

Faciliter le débogage de l’application Spring Boot avec Spring Cloud Sleuth et Zipkin

Les tests continus font partie des tâches les plus importantes en matière de développement logiciel, puisque cette phase permet de détecter et de corriger toutes les erreurs survenues lors de la programmation. En règle générale, l’analyse des fichiers journaux est toutefois très complexe, ce qui rend souvent le processus de débogage particulièrement laborieux, notamment pour les microservices. Pour conclure ce tutoriel Spring Boot, nous souhaitons par conséquent mettre en place les solutions de traçage Spring Cloud Sleuth et Zipkin afin d’assurer une surveillance de l’application Spring Boot de tous les côtés.

Grâce à ces deux applications de traçage, vous pourrez suivre sans difficulté toutes les requêtes concernant un contrôleur REST mis en place au préalable et afficher la chronologie à tout moment.

Étape 1 : ajouter Spring Cloud Sleuth au projet

Intégrez tout d’abord le module Sleuth à votre application Spring Boot en définissant la contrainte dans le fichier de configuration de la production. Pour ce faire, insérez le contenu suivant dans le pom.xml si vous utilisez Maven :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
    <version>${spring-cloud-sleuth.version}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

Dans le fichier de configuration des projets Gradle, il vous faudra ajouter les lignes suivantes :

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Étape 2 : intégrer les journaux Sleuth dans le fichier de classes du contrôleur REST

Le contrôleur REST de votre application Spring Boot doit à présent être configuré de façon à traiter les fichiers journaux de Sleuth de la manière souhaitée. À cette fin, ajoutez au fichier .class du contrôleur le texte de configuration suivant – le nom de paquet (ici spring-boot-tutorial) correspond dans ce cadre au domaine du <groupId> dans le pom.xml:

package spring-boot-tutorial.sleuth;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class SleuthappApplication {
    private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
    public static void main(String[] args) {
        SpringApplication.run(SleuthappApplication.class, args);
    }
    @RequestMapping("/")
    public String index() {
        LOG.log(Level.INFO, "Index API is calling");
        return "Sleuth: Spring-Boot-Tutorial-Test!";
    }
}

Étape 3 : indiquer le nom de l’application Spring dans les propriétés

Afin de garantir que le nom de l’application Spring Boot soit correctement affiché dans Zipkin, vous devriez indiquer le nom dans le fichier PROPERTIES « application ». Si vous enregistrez la configuration sur un serveur de configuration Spring Cloud, il vous faudra réaliser la même opération dans le fichier de PROPERTIES « bootstrap » :

spring.application.name = Spring-Boot-Tutorial-App

Étape 4 : ajouter Zipkin au projet

Zipkin vous aide à surveiller et gérer les journaux Sleuth. Ce logiciel open source se compose d’une interface d’utilisateur et d’une composante de serveur. Les contraintes des deux composantes sont ajoutées dans le fichier de configuration correspondant. Les utilisateurs de Maven saisiront pour cela le contenu suivant dans le pom.xml :

<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-autoconfigure-ui</artifactId>
<scope>runtime</scope>
</dependency>

Dans le cas d’une configuration Gradle, les nouvelles lignes seront les suivantes :

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Étape 5 : autoriser l’application à agir en tant que serveur Zipkin

L’étape suivante consiste à veiller à ce que votre projet Spring Boot puisse agir en tant que serveur Zipkin. Pour ce faire, vous allez créer un fichier intitulé zipkin.properties et y insérer les lignes suivantes :

spring.application.name=zipkin
server.port=9411
logging.level.org.springframework.web=debug

Activez ensuite la composante de serveur dans le fichier Java du projet :

package spring-boot-tutorial.zipkin;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;
@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZipkinappApplication.class, args);
    }
}

Si vous générez le fichier JAR exécutable de la façon habituelle et si vous exécutez l’application, le serveur Zipkin est accessible à l’adresse 'http://localhost:9411/zipkin'.

Étape 6 : ajouter la contrainte Zipkin Spring Cloud

Ajoutez une dernière contrainte dans le fichier de configuration de la production afin d’associer Sleuth et Zipkin.

Maven :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradle :

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Étape 7 : configurer l’exportation du journal Sleuth sur le serveur Zipkin

Complétez le fichier Java de votre application Spring Boot avec l’objet AlwaysSampler (Bean) afin d’activer l’exportation automatique du journal Sleuth sur le serveur Zipkin :

@Bean
public AlwaysSampler defaultSampler() {
    return new AlwaysSampler();
}

Étape 8 : indiquer l’URL de base du serveur Zipkin dans le fichier PROPERTIES « application »

Pour cette dernière étape, vous devrez indiquer l’URL de base du serveur Zipkin dans les propriétés de l’application en ouvrant une nouvelle fois le fichier PROPERTIES de votre projet Spring Boot et en ajoutant la ligne suivante :

spring.zipkin.baseUrl = http://localhost:9411/zipkin/
Cet article vous a-t-il été utile ?