• 20 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 31/07/2019

Découvrez le framework Spring Boot

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Si vous êtes amenés à 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 framework 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 !

Ce que propose Spring Boot

Spring et Spring MVC sont de formidables outils quand on essaye 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.

Comment Spring Boot permet-il de créer une application sans écrire une seule ligne de configuration, ou presque ?

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

  1. l'auto-configuration,

  2. les starters.

L'auto-configuration

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 

  • persitence.xml

Comme vous ne connaissez pas nécessairement la syntaxe de ces fichiers par coeur, 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 re-testez 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 ! :magicien: 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 aucun 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. 

Les Starters

Les starters viennent compléter l'auto-configuration 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>

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starters</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <artifactId>spring-boot-starter-web</artifactId>
    <name>Spring Boot Web Starter</name>
    <description>Starter for building web, including RESTful, applications using Spring
        MVC. Uses Tomcat as the default embedded container</description>
    <url>http://projects.spring.io/spring-boot/</url>
    <organization>
        <name>Pivotal Software, Inc.</name>
        <url>http://www.spring.io</url>
    </organization>
    <properties>
        <main.basedir>${basedir}/../..</main.basedir>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
    </dependencies>
</project>

Comme vous pouvez le voir, ce starter Spring Boot pour application web met en place la configuration des éléments suivants : tomcat, hibernate-validator, jackson, spring MVC.

D'accord, mais cela ne m'explique pas comment il devine les versions ?

Voici la réponse :

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</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 ici (qui lui-même hérite d'un autre pom : spring-boot-dependencies). Il permet de définir principalement :

  • La version de Java à utiliser. Dans ce cas, c'est la 1.6, nous verrons dans le prochain chapitre comment la surcharger pour utiliser Java 1.8.

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

Vous trouverez ici une liste de tous les starters existants.

Résumons

  • 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 auto-configurant celles-ci.

  • Pour activer l'auto-configuration, 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.

Exemple de certificat de réussite
Exemple de certificat de réussite