Construisez des microservices

Si vous êtes amené à travailler sur une application développée autour de l'architecture Microservices en Java, vous aurez tôt ou tard affaire à Spring Boot. Dans ce chapitre, nous allons donc prendre le temps de comprendre ce que fait ce framework, et surtout lever l'ambiguïté sur la différence avec les autres frameworks Spring, qui à première vue font la même chose.

Spring Boot est un framework qui facilite le développement d'applications fondées sur Spring en offrant des outils permettant d'obtenir une application packagée en JAR, totalement autonome. Ce qui nous intéresse particulièrement, puisque nous essayons de développer des  microservices !

Découvrez ce que propose Spring Boot

Spring et Spring MVC sont de formidables outils quand on essaie de développer une application web. Néanmoins, un de leurs plus gros problèmes est la configuration. Si vous avez déjà développé une application avec ces outils, vous avez dû remarquer que votre application est bardée de fichiers XML qui indiquent les configurations des servlets, des vues, des contenus statiques, etc. Ces fichiers de configuration deviennent un vrai challenge lorsque vous avez une application complexe.

Pour simplifier cette configuration, Spring Boot propose 2 fonctionnalités principales que nous allons voir dans la suite de ce chapitre :

1. L'autoconfiguration.

2. Les starters.

Utilisez la fonctionnalité d'autoconfiguration

Cette fonctionnalité est la plus importante de Spring Boot. Elle permet de configurer automatiquement votre application à partir des JAR trouvés dans votre classpath. En d'autres termes, si vous avez importé des dépendances, Spring Boot ira consulter cette liste, puis produira la configuration nécessaire pour que tout fonctionne correctement.

Prenons l'exemple d'une application web dans laquelle vous avez les dépendances : Hibernate et Spring MVC. Normalement, vous devez créer les fichiers de configuration suivants :

• appconfig-mvc.xml  ;

• web.xml  ; 

• persistence.xml  .

Comme vous ne connaissez pas nécessairement la syntaxe de ces fichiers par cœur, il vous faut consulter la documentation, ou vous inspirer d'un ancien projet. Vous devez ensuite écrire le code Java qui permet de lier ces fichiers XML à ApplicationContext de Spring.

Ensuite, vous adaptez et testez, puis réadaptez et retestez encore pendant un bon moment avant que tout fonctionne... Bien sûr, dès que vous faites un changement dans votre application, il ne faut pas oublier de mettre à jour tous les fichiers de configuration, puis débugger de nouveau. Cela devient très vite très fastidieux !

Voici l'équivalent de l'ensemble de ces étapes avec Spring MVC :

@EnableAutoConfiguration

C'est tout ! Avec cette annotation, Spring Boot ira scanner la liste de vos dépendances, trouvant par exemple Hibernate. Ayant constaté que vous n'avez défini aucune autre datasource, il créera la configuration nécessaire et l'ajoutera à ApplicationContext.

Bien entendu, vous pouvez très facilement personnaliser ces configurations, en créant vos Beans ou vos propres fichiers de configuration. Spring Boot utilisera alors en priorité vos paramètres.

Utilisez les starters

Les starters viennent compléter l'autoconfiguration et font gagner énormément de temps, notamment lorsqu'on commence le développement d'un microservice. Un starter va apporter à votre projet un ensemble de dépendances, communément utilisées pour un type de projet donné. Ceci va vous permettre de créer un "squelette" prêt à l'emploi très rapidement.

L'autre énorme avantage est la gestion des versions. Plus besoin de chercher quelles versions sont compatibles, puis de les ajouter une à une dans le pom.xml ! Il vous suffit d'ajouter une simple dépendance au starter de votre choix. Cette dépendance va alors ajouter, à son tour, les éléments dont elle dépend, avec les bonnes versions.

Prenons l'exemple où vous souhaitez créer un microservice. En temps normal, vous aurez besoin des dépendances suivantes :

• Spring ;

• Spring MVC ;

• Jackson (pour JSON) ;

• Tomcat...

Avec Spring Boot, vous allez tout simplement avoir une seule dépendance dans votre pom.xml :

<dependency>

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

Tous les starters de Spring Boot sont au format spring-boot-starter-NOM_DU_STARTER

Ce starter va charger les dépendances présentes dans le pom 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 https://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.6.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </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>

Voici la réponse :

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.0</version> <!-- permet de sélectionner la version -->
        <relativePath/>

</parent>

Ce tag, ajouté en haut du pom.xml, permet à votre pom d'hériter des propriétés d'un autre pom que vous trouverez dans ce projet Github (qui lui-même hérite d'un autre pom : spring-boot-dependencies). Il permet de définir principalement :

• Une liste complète des versions des dépendances prises en charge, ce qui permet d'ajouter des dépendances sans indiquer leur version, comme dans le pom.xml du starter spring-boot-starter-web vu plus haut. Vous allez donc pouvoir ajouter les dépendances de votre choix, sans vous soucier des versions.

Bien entendu, spring-boot-starter-web n'est pas le seul starter disponible. Selon ce que vous comptez développer, vous trouverez pratiquement toujours un starter adéquat. Voici quelques exemples : 

• spring-boot-starter-mail : pour les applications et services d'envoi de mails.

• spring-boot-starter-thymeleaf : si vous souhaitez créer une application qui offre une interface utilisateur en utilisant le moteur de template Thymeleaf.

• spring-boot-starter-web-services : pour les services plus classiques utilisant SOAP.

En résumé

• Spring Boot est un framework qui permet de démarrer rapidement le développement d'applications ou services, en fournissant les dépendances nécessaires et en autoconfigurant celles-ci.

• Pour activer l'autoconfiguration, on utilise l'annotation  @EnableAutoConfiguration . Si vous écrivez vos propres configurations, celles-ci priment sur celles de Spring Boot.

• Les starters permettent d'importer un ensemble de dépendances selon la nature de l'application à développer, afin de démarrer rapidement.

Nous allons maintenant utiliser Spring Initializer pour initialiser notre projet. C'est parti !