• 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 17/08/2018

Créez un Microservice grâce à Spring Boot

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

Spring Initializr

Avez-vous déjà commandé une salade à composer au restaurant ? Et bien, Spring Initializr fait plus ou moins la même chose : il vous permet de composer votre application selon vos besoins.

Pour débuter, rendez-vous sur https://start.spring.io. Cliquez sur "Switch to the full version" :

Figure 3

Vous verrez apparaitre, en bas, tous les starters et ensembles de dépendances pour les cas d'usage les plus courants. Cela va du starter web, que nous avons vu dans le chapitre précédent, aux bases de données, en passant par les moteurs de template, la sécurité, le messaging, ainsi que d'autres outils très importants dans une architecture Microservices, que nous verrons plus tard.

Nous allons, dans les prochains chapitres, développer un mini-système d'e-commerce fondé sur l'architecture Microservices avec Spring Boot. Nous allons commencer par un premier Microservice qui gère les produits que nous allons proposer à la vente. Il doit pouvoir ajouter, supprimer, mettre à jour et afficher les produits.

Dans une première étape, nous allons créer une version très simplifiée de ce Microservice. Nous enrichirons ce Microservice au fur et à mesure de notre découverte des différents concepts à assimiler.

Création et importation à partir de Spring Initializr

Retournez sur Spring Initializr et renseignez les Metadata du projet comme suit :

  • Group :  com.ecommerce  

  • Artifact :  microcommerce  

  • Name :  microcommerce  

  • Packaging :  jar  

  • Java Version :  8  

La figure suivante vous présente le formulaire renseigné avec ces informations :

Figure 4
Interface de Spring Initilizr, full version

Ensuite, suivez les étapes suivantes :

  1. Sélectionnez en bas le starter Web, comme illustré dans la figure qui suit :

    Figure 5
    Sélection du starter "Web"
  2. Cliquez sur "Generate Project" et téléchargez l'application générée.

  3. Dans ce cours, nous allons utiliser comme IDE : IntelliJ. Son installation est très simple, mais si vous rencontrez des difficultés, je vous invite à suivre le tutoriel dans ce cours.

  4. Procédez à l'extraction de l'application téléchargée. Si vous avez utilisé les mêmes noms que moi, elle devrait s'appeler microcommerce.zip .

  5. Une fois sur la page d'accueil d'IntelliJ, cliquez sur "Import Project" :

     

    Figure 6

  6. Sélectionnez le dossier de l'application microcommerce puis sélectionnez le pom.xml :

    Figure 7

  7. Laissez les options d'import de projet Maven par défaut :

    Figure 8

  8. Cliquez sur "Next" à la prochaine fenêtre :

    Figure 9

  9. Si vous venez d'installer IntelliJ, il vous demandera de choisir le JDK : cliquez sur "+" puis JDK :

    Figure 10

  10. Sélectionnez le répertoire "Home" de votre JDK :

    Figure 13

  11. Cliquez sur "Next" :

    Figure 14

  12. Entrez "microcommerce" pour le nom du projet et cliquez sur "Finish" :

    Figure 15

Analyse du code obtenu

Si tout s'est déroulé correctement, vous devriez avoir cette arborescence :

Figure 16

Étudions maintenant en détail les différents éléments de cette arborescence :

pom.xml

Comme nous l'avons vu dans le chapitre précédent, ce pom.xml hérite du parent spring-boot-starter-parent qui nous permet de ne plus nous soucier des versions des dépendances et de leur compatibilité :

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

Comme je l'ai indiqué dans le chapitre précédent, vous avez la possibilité de choisir la version de Java à utiliser. Comme nous avons sélectionné Java 8 dans l'interface de Spring Initializr, une balise XML <java.version> a été ajoutée dans la partie properties du fichier pom.xml, comme nous pouvons le voir dans le code qui suit :

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

Le pom.xml définit ensuite une dépendance vers le starter qui va ajouter à notre Microservice toutes les dépendances de base nécessaires pour démarrer rapidement :

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

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

Pour voir la liste des dépendances importées, rendez-vous à gauche dans "External Libraries" :Figure 17

Vous avez dans cette liste principalement :

  • Jackson : permet de parser JSON et faire le lien entre les classes Java et le contenu JSON.

  • Tomcat : intégré, va nous permettre de lancer notre application en exécutant tout simplement le jar sans avoir à le déployer dans un serveur d'application.

  • Hibernate : facilite la gestion des données.

  • Logging grâce à logback et autres.

MicrocommerceApplication.java

Cette classe, générée automatiquement par Spring Boot, est le point de démarrage de l'application :

@SpringBootApplication
public class MicrocommerceApplication {

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

Elle lance, entre autres, la classe SpringApplication, responsable du démarrage de l'application Spring. Cette classe va créer le fameux ApplicationContext dans lequel iront toutes les configurations générées automatiquement ou ajoutées par vos soins.

Mais le plus important ici, c'est bien sûr l'annotation @SpringBootApplication, qui est une simple encapsulation de trois annotations :

  1. @Configuration : donne à la classe actuelle la possibilité de définir des configurations qui iront remplacer les traditionnels fichiers XML. Ces configurations se font via des Beans.

  2. @EnableAutoConfiguration : l'annotation vue précédemment qui permet, au démarrage de Spring, de générer automatiquement les configurations nécessaires en fonction des dépendances situées dans notre classpath.

  3. @ComponentScan : Indique qu'il faut scanner les classes de ce package afin de trouver des Beans de configuration.

Nous reviendrons sur la configuration dans une prochaine section. Si vous souhaitez personnaliser finement le comportement de Spring Boot, il vous suffit de remplacer @SpringBootApplication par ces 3 annotations  :

...
...
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class MicrocommerceApplication {
...
...
}

Cette modification permet notamment de paramétrer l'annotation @ComponentScan, par exemple pour cibler des fichiers à scanner.

application.properties

Ce fichier est votre ami (oui, comme Google :)). Ce fichier va vous permettre de modifier très simplement un nombre impressionnant de configurations liées à Spring Boot et ses dépendances. Par exemple : changer le port d'écoute de Tomcat, l'emplacement des fichiers de log, les paramètres d'envoi d'emails, etc... Je vous invite à jeter un oeil sur la liste complète ici. Nous reviendrons sur ce fichier dans une prochaine section.

MicrocommerceApplicationTests.java

Ce fichier vous permet d'écrire vos tests.

Exécuter l'application

Nous n'avons rien ajouté dans notre application pour l'instant, mais nous pouvons déjà l'exécuter. Si vous n'avez pas le panneau Maven à droite, rendez-vous en bas à gauche d'IntelliJ pour l'activer :

Figure 18 

Double-cliquez ensuite sur "Install" sous "LilfeCycle" de Maven dans le panneau de droite :

Figure 19

L'application sera compilée et vous retrouverez le jar sous le nouveau dossier "Target" créé pour l'occasion par Maven :

Figure 20

Exécutez enfin l'application depuis un terminal comme n'importe quel jar grâce à la commande :

java -jar Chemin/vers/microcommerce/target/microcommerce-0.0.1-SNAPSHOT.jar

Vous devriez alors avoir un retour de ce type :

Figure 21

Dans les dernières lignes vous remarquerez cette phrase : " Tomcat started on port(s): 8080 (http)" Ce qui vous indique que votre application tourne et qu'elle est en écoute grâce à tomcat sur le port 8080.

Et bien, rendez-vous dans votre navigateur à l'adresse http://localhost:8080. Vous obtenez alors cette magnifique erreur, car nous n'avons encore pas fourni d'éléments  à afficher !  

Figure 22
Message d'erreur au lancement de l'application

Figure 23

L'application se lance et vous pouvez avoir le retour dans la console intégrée en bas. Cette opération est à faire uniquement la première fois. Pour les fois suivantes, il suffira d'appuyer sur le bouton Play en haut à droite pour la démarrer et l'arrêter avec le bouton rouge :

Figure 24

Vous pouvez en profiter pour essayer la personnalisation de l'auto-configuration de Spring Boot via application.properties. Vous pouvez ainsi changer un nombre impressionnant de paramètres grâce à une simple ligne dans le fichier application.properties.

Changeons par exemple le port du serveur. Ajoutez tout simplement cette ligne :

server.port 9090

Exécutez maintenant l'application. Spring vous indique alors que l'application tourne désormais sur le port 9090 :

Figure 25

Vous pouvez le vérifier en vous rendant également à l'url http://localhost:9090.

Créez l'API REST

Nous arrivons maintenant au coeur du Microservice que nous voulons développer. Ce Microservice va devoir être RESTful et donc pouvoir communiquer de cette manière.

Quels sont les besoins ?

Nous avons besoin d'un Microservice capable de gérer les produits. Pour cela, il doit pouvoir exposer une API REST qui propose toutes les opérations CRUD (Create, Read, Update, Delete).

Nous allons donc avoir :

  • Une classe Produit qui représente les caractéristiques d'un produit (nom, prix, etc.) ;

  • Un contrôleur qui s'occupera de répondre aux requêtes CRUD et de faire les opérations nécessaires.

Nous voulons donc pouvoir appeler notre Microservice sur les URLs suivantes :

  • Requête GET à /Produits : affiche la liste de tous les produits ;

  • Requête GET à /Produits/{id} : affiche un produit par son Id ;

  • Requête PUT à /Produits/{id} : met à jour un produit par son Id ;

  • Requête POST à /Produits : ajoute un produit ;

  • Requête DELETE à /Produits/{id} : supprime un produit par son Id.

Passons au code !

Créez le controleur REST

Nous allons créer un contrôleur et le placer dans un Package "controller", lui-même situé dans un package "web". Pour ce faire, faites un clic droit sur le package principal puis New -> Java Class :Figure 26

Pour créer les packages nécessaires et placer la classe directement à l'intérieur, nous allons utiliser une notation raccourcie fournie par IntelliJ . Dans la boite de dialogue, écrivez web.controller.ProductController, comme illustré dans la figure suivante : 

Figure 27

Lorsque vous cliquez sur OK, IntelliJ crée un package web, puis crée à l'intérieur de celui-ci un package controller. Enfin, la classe ProductController est créée à l'intérieur de ce dernier Package. Vous obtenez l'arborescence illustrée ci-après :

Figure 28 

Figure 29

Nous allons commencer par indiquer à Spring que ce contrôleur est un contrôleur REST. Saisissez le code suivant dans la classe ProductController :

package com.ecommerce.microcommerce.web.controller;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

}

Vous connaissez sans doute l'annotation @Controller de Spring qui permet de désigner une classe comme contrôleur, lui conférant la capacité de traiter les requêtes de type GET, POST, etc. Vous ajoutez ensuite @ResponseBody aux méthodes qui devront répondre directement sans passer par une vue.

@RestController est simplement la combinaison des deux annotations précédentes. Une fois ajouté, il indique que cette classe va pouvoir traiter les requêtes que nous allons définir. Il indique aussi que chaque méthode va renvoyer directement la réponse JSON à l'utilisateur, donc pas de vue dans le circuit.

Méthode pour GET /Produits

Commençons par créer une méthode listeProduits, très simple, qui retourne un String. Comme nous n'avons pas encore de produits, on retourne une simple phrase pour tester.

@RestController
public class ProductController {
    @RequestMapping(value="/Produits", method=RequestMethod.GET)
    public String listeProduits() {
        return "Un exemple de produit";
    }
}

Dans ce code,  c'est l'annotation @RequestMapping  qui permet de faire le lien entre l'URI "/Produits", invoquée via GET, et la méthode listeProduits .

Cette annotation accepte plusieurs paramètres , dont voici les principaux :

  • value : C'est ici que vous indiquez l'URI à laquelle cette méthode doit répondre. Vous pouvez également indiquer des paramètres, nous y reviendrons.

  • method : Vous indiquez ici à quel type de requêtes cette méthode doit répondre. Dans notre cas, notre méthode listeProduits ne sera déclenchée que si l'URI est exactement "/Produits" et que la requête est de type GET. Si vous appelez "/Produits" avec un POST, notre méthode ne sera tout simplement pas évoquée. method accepte toutes les requêtes CRUD et plus encore.

  • produces : Dans certains cas d'utilisations avancées, vous aurez besoin de préciser, par exemple, que votre méthode est capable de répondre en XML et en JSON. Cela entre aussi dans le choix de la méthode qui correspond le mieux à la requête. Si la requête contient du XML et que vous avez 2 méthodes identiques, dont une capable de produire du XML, c'est celle-ci qui sera appelée. Il en va de même pour consumes qui précise les formats acceptés. Dans la plupart des cas, vous n'avez pas besoin de renseigner ces paramètres.

Très bien :) ! Il ne reste plus qu'à lancer l'application et se rendre à http://localhost:9090/Produits.

Figure 30

 Méthode pour GET /Produits/{id}

Créons maintenant une autre méthode capable d'accepter un Id de produit en paramètre :

@RequestMapping(value = "/Produits/{id}", method = RequestMethod.GET)
  public String afficherUnProduit(@PathVariable int id) {
  return "Vous avez demandé un produit avec l'id  " + id;
}

La première différence dans cette méthode est l'ajout de {id} à l'URI. Cette notation permet d'indiquer que cette méthode doit répondre uniquement aux requêtes avec une URI de type /Produits/25 par exemple. Comme nous avons indiqué que id doit être un int (dans @PathVariable int id), vous pouvez vous amuser à passer une chaine de caractères à la place, vous verrez que Spring vous renverra une erreur.

Il existe des raccourcis pour éviter d'écrire l'annotation à rallonge @RequestMapping. Par exemple, pour une @RequestMapping qui accepte des requêtes de type GET, vous pouvez la remplacer par @GetMapping. Vous obtenez un code comme ceci :

  @GetMapping(value = "/Produits/{id}")
  public String afficherUnProduit(@PathVariable int id) {
      return "Vous avez demandé un produit avec l'id  " + id;
  }

Le code devient plus élégant et lisible quand vous avez une dizaine de méthodes par exemple. Vous avez aussi, les mêmes équivalents pour les autres types : PostMapping, DeleteMapping, etc.

Tout cela est très bien, mais nous aimerions bien renvoyer une liste de vrais produits au format JSON et plus seulement des phrases inutiles. C'est ce que nous allons voir dans la prochaine section.

Renvoyez une réponse JSON

Nous allons commencer par créer une classe qui représente un produit. Cette classe est souvent appelée Bean ou JavaBean. Un Bean est une classe classique qui doit être "sérialisable" et avoir au minimum :

  • un constructeur public sans argument,

  • des getters et setters pour toutes les propriétés de la classe.

Commencez par créer une nouvelle classe Product que vous allez placer dans un package "model" sous le package microcommerce :

Figure 31
classe Product

Créez ensuite les propriétés de base de la classe :

package com.ecommerce.microcommerce.model;

public class Product {
    private int id;
    private String nom;
    private String nom;
}

Vous allez maintenant générer le constructeur et les getters et setters. Faites Cmd + N sous Mac ou Ctrl +N sous Windows afin d'afficher la fenêtre de génération de code :

Figure 32
Fenêtre de génération du code

Générez le constructeur sans argument puis les getters et setters pour toutes les propriétés ainsi que la méthode toString . Pour nos tests, nous allons ajouter un constructeur afin d'obtenir des instances de produits pré-remplies avec des informations de tests. Vous obtenez ceci :

package com.ecommerce.microcommerce.model;
public class Product {
    private int id;
    private String nom;
    private int prix;

    //constructeur par défaut
    public Product() {
    }

    //constructeur pour nos tests

    public Product(int id, String nom, int prix) {
        this.id=id;
        this.nom=nom;
        this.prix=prix;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id=id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom=nom;
    }

    public int getPrix() {
        return prix;
    }

    public void setPrix(int prix) {
        this.prix=prix;
    }
    
    @Override
    public String toString(){  
        return "Product{"+
        "id=" + id + 
        ", nom='"+ nom + '\'' + 
        ", prix=" + prix+ '}';
    }
}

Très bien :) ! Maintenant à chaque fois que quelqu'un appelle notre URI "/Produits/{id}", nous voudrions renvoyer un produit au format JSON qui correspond à notre classe Product.

Retournez sur le code précédent et remplacer la méthode afficherUnProduit par celle-ci :

//Récupérer un produit par son Id
@GetMapping(value="/Produits/{id}")
public Product afficherUnProduit(@PathVariableintid) {
    Product product=newProduct(id, new String("Aspirateur"), 100 );
    return product;
}

Explications

Tout d'abord, nous avons indiqué que notre méthode va retourner un Product au lieu de String .

Normalement, nous sommes censés aller chercher le produit par l'id que nous avons reçu dans la base de données et le retourner à l'utilisateur. Comme nous n'avons pas encore de base de données, nous avons tout simplement instancié un objet Product grâce au constructeur que nous avons défini plus tôt. Nous simulons donc la récupération d'un produit dans la base de données.

Une fois notre instance de Product prête, nous la retournons.

Voici le contrôleur complet :

package com.ecommerce.microcommerce.web.controller;
import com.ecommerce.microcommerce.model.Product;
import org.springframework.web.bind.annotation.*;

@RestController
public class ProductController {

    //Récupérer la liste des produits
    @RequestMapping(value="/Produits", method=RequestMethod.GET)
    public String listeProduits() {
        return"Un exemple de produit";
    }

    //Récupérer un produit par son Id
    @GetMapping(value="/Produits/{id}")
    public Product afficherUnProduit(@PathVariableintid) {
        Product product=new Product(id, new String("Aspirateur"), 100 );
        return product;
    }
}

Lancez de nouveau le Microservice puis rendez-vous par exemple sur http://localhost:9090/Produits/27 pour regarder ce qui se passe.

Figure 33
Retour de l'API REST

Vous obtenez une belle réponse formatée en JSON comme par magie :magicien:.

Comment est-ce possible ?

Vous avez indiqué au début que cette classe est un contrôleur REST grâce à l'annotation @RestController. Spring sait alors que les réponses aux requêtes qu'il vous passe devront être très probablement en format JSON.

L'auto-configurateur va alors chercher si vous avez dans votre classpath une dépendance capable de transformer un object Java en JSON, et inversement. Bingo ! Il y a justement Jackson qui a été importé avec le starter que nous avons utilisé. Le Bean Product que nous renvoyons est donc transformé en JSON puis servi en réponse.

Vous venez donc de créer un premier Microservice REST sans avoir à manipuler JSON ni à parser les requêtes HTTP.

Créez le DAO

Nous allons nous rapprocher un peu plus d'un cas d'utilisation réel en créant la DAO nécessaire pour communiquer avec une base de données. Nous allons simuler celle-ci grâce à des données statiques.

Créez un package et nommez-le dao puis créez dedans une interface nommée ProductDao, dans laquelle vous allez déclarer les opérations que nous allons implémenter. 

package com.ecommerce.microcommerce.dao;
import com.ecommerce.microcommerce.model.Product;
import java.util.List;

public interface ProductDao {
    public List<Product>findAll();
    public ProductfindById(int id);
    public Productsave(Product product);
}

Nous indiquons dans cette interface que les opérations suivantes sont possibles :

  • findAll : renvoie la liste complète de tous les produits ;

  • findById : renvoie un produit par son Id ;

  • save : ajoute un produit.

Les noms des méthodes ne sont pas choisis au hasard. En effet, il faut suivre les conventions citées ici par exemple afin de bénéficier plus tard de certaines fonctionnalités qui vous feront gagner beaucoup de temps.

Maintenant que notre interface est prête, nous allons pouvoir créer son implémentation. Créez une classe ProductDaoImpl qui implémente l'interface que nous venons de créer. Générez ensuite automatiquement cette implémentation en appuyant sur Cmd +N sur Mac ou Ctrl +N sur Windows, puis Implement Methods . Vous obtenez alors ceci  : 

package com.ecommerce.microcommerce.dao;
import com.ecommerce.microcommerce.model.Product;
import java.util.List;

public class ProductDaoImpl implements ProductDao {

    @Override
    publicList<Product>findAll() {
        return null;
    }

    @Override
    publicProductfindById(int id) {
        return null;
    }

    @Override
    publicProductsave(Product product) {
        return null;
    }
}

Normalement , cette classe est censée communiquer avec la base de données pour récupérer les produits ou en ajouter. Nous allons simuler ce comportement en créant des Produits en dur dans le code.

Nous obtenons donc ceci :

package com.ecommerce.microcommerce.dao;
import com.ecommerce.microcommerce.model.Product;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

@Repository
public class ProductDaoImplimplementsProductDao {
    public static List<Product>products=newArrayList<>();
    static {
        products.add(newProduct(1, newString("Ordinateur portable"), 350));
        products.add(newProduct(2, newString("Aspirateur Robot"), 500)); 
        products.add(newProduct(3, newString("Table de Ping Pong"), 750));
    }

    @Override
    public List<Product>findAll() {
        return products;
    }
    
    @Override
    public ProductfindById(int id) {
        for (Product product : products) {  
            if(product.getId() ==id){
                return product;
            }
        }
        return null;
    }

    @Override
    public Product save(Product product) {
        products.add(product);
        return product;
    }
}

Explication du code

@Repository : cette annotation est appliquée à la classe afin d'indiquer à Spring qu'il s'agit d'une classe qui gère les données, ce qui nous permettra de profiter de certaines fonctionnalités comme les translations des erreurs. Nous y reviendrons.

Pour tester avec des données statiques , vu que nous n'en sommes pas encore à la base de données, nous définissons ici un tableau de Product  dans lequel nous ajoutons 3 produits statiques. Les méthodes suivantes sont ensuite redéfinies afin de renvoyer les données adéquates :

  1. findAll  : renvoie tous les produits que nous avons créés ;

  2. findById : vérifie s'il y a un produit avec l'id donnée dans notre liste de produits et le renvoie en cas de correspondance ;

  3. save : ajoute le produit reçu à notre liste.

Très bien, votre couche DAO est prête ! Vous allez pouvoir l'utiliser pour simuler la récupération et l'ajout de produits depuis une base de données.

Interagir avec les données

Nous allons maintenant modifier notre contrôleur afin qu'elle utilise notre couche DAO pour manipuler les produits.

Voici la classe modifiée :

package com.ecommerce.microcommerce.web.controller;
import com.ecommerce.microcommerce.dao.ProductDao;
import com.ecommerce.microcommerce.model.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
public class ProductController {

    @Autowired
    private Product DaoproductDao;

    //Récupérer la liste des produits
    @RequestMapping(value="/Produits", method=RequestMethod.GET)
    publicList<Product>listeProduits() {
        return productDao.findAll();
    }

    //Récupérer un produit par son Id
    @GetMapping(value="/Produits/{id}")
    public Product afficherUnProduit(@PathVariable int id) {
        return productDao.findById(id);
    }
}

Explication du code

Tout d'abord, nous avons créé une variable de type ProductDao, que nous avons annotée avec @Autowired afin que Spring se charge d'en fabriquer une instance. ProductDao a désormais accès à toutes les méthodes que nous avons définies.

Nous avons changé listeProduits afin qu'elle nous retourne une liste de produits List . Ensuite, il a suffi d'invoquer la méthode findAll créée précédemment pour qu'elle nous retourne tous les produits.

De même, pour afficherUnProduit qui fait appel à findById

Testez ! 

Lancez le Microservice et rendez-vous à http://localhost:9090/Produits/, vous obtiendrez ceci :

Figure 34
Résultat de l'appel de l'API REST

Bingo :D ! Vous avez la liste des produits que vous avez définis au format JSON prête à être consommée par n'importe quel Microservice REST.

Rendez-vous ensuite à http://localhost:9090/Produits/1 pour afficher produit par produit.

Le processus pour obtenir le résultat est le suivant :

  1. L'utilisateur envoie une requête GET vers /Produits/2.

  2. Le dispatcheur cherche dans votre contrôleur la méthode qui répond au pattern "/Produits/{id}" et l'exécute.

  3. La méthode (dans ce cas listeProduits ) fait appel au DAO pour qu'il communique avec la base de données. Il récupère les informations sur le produit puis il crée une instance de Product qu'il renvoie ensuite à votre méthode.

Votre méthode retourne l'instance reçue, qui est transformée à la volée en JSON grâce à Jackson.

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