Pr S.

Sekkate
Architecture microservices 2023-2024
TP 1 : Développer un microservice en Java

Objectif du TP :
L’objectif de ce travail est de montrer comment créer un microservice en utilisant les fa-
cilités offertes par Spring Boot. Spring Boot permet de construire des applications Spring
aussi rapidement que possible, en minimisant au maximum le temps de configuration,
d’habitude pénible, des applications Spring.
Dans le but de développer un mini-application d’e-commerce fondée sur l’architecture
Microservices avec Spring Boot, nous allons commencer par la mise en place d’un premier
Microservice qui gère les produits proposés à la vente. Il doit pouvoir ajouter, supprimer,
mettre à jour et afficher les produits.

1 Starting with Spring Initializr

Pour créer rapidement et facilement un projet Spring avec toutes les dépendances nécessaires,
Spring Boot fournit Spring Initializr.
1. Pour débuter, aller au site https://start.spring.io:, et créer un projet en ren-
seignant les Metadata du projet:
• Group : com.ecommerce
• Artifact : microcommerce
• Name : microcommerce
• Packaging : jar
• Java Version : 8
2. Ajouter les dépendances nécessaires en cliquant sur Dependencies. Sélectionner
Spring Web.
3. Cliquer sur ”Generate” et télécharger l’application générée.
• Procéder à l’extraction de l’application téléchargée microcommerce.zip et l’ouvrir
dans l’IDE Intellij.

1.1 Exécuter l’application

À ce stade, il est possible d’exécuter l’application même si rien n’a été ajouté. Pour cela :
• Sous ”Execute Maven Goal” de Maven dans le panneau de droite, exécuter ”mvn
install”.
• L’application sera compilée et vous retrouverez le jar sous le nouveau dossier ”Tar-
get” créé pour l’occasion par Maven.
• Exécuter 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
 • Pour faciliter l’exécution de notre service, nous pouvons faire un clic droit sur le
nom de la classe contenant la méthode main (MicrocommerceApplication.java) puis
cliquer sur ”Run” dans le menu contextuel qui s’affiche.
• L’application se lance et nous pouvons 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.
• A l’adresse http://localhost:8080, nous obtenons alors une erreur car aucun élément
à afficher n’a été fourni.

1.2 Personnaliser l’auto-configuration

La personnalisation de l’auto-configuration de Spring Boot peut se faire via
application.properties.
• Exemple pour le changement du port du serveur : server.port 9090
• À vérifier par la suite en se rendant à l’url http://localhost:9090.
• Liste des paramètres modifiables sur https://docs.spring.io/spring-boot/docs/
current/reference/html/application-properties.html

2 Créer 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.
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).

Pour ce faire 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.

2.1 Créer le contrôleur REST

1. Nous allons créer un contrôleur ProductController et le placer dans un Package ”con-
troller”, lui-même situé dans un package ”web”. Pour ce faire, faire un clic droit sur
le package principal puis New − > Java Class − > web.controller.ProductController
2. Nous allons commencer par indiquer à Spring que ce contrôleur est un contrôleur
REST. Pour ce faire, Saisir le code suivant dans la classe ProductController :
 package com.ecommerce.microcommerce.web.controller;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
}

2.1.1 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 "Ceci est un exemple de produit";
}
}

• Il ne reste plus qu’à lancer l’application et se rendre à http://localhost:9090/Produits.

• 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 "Ceci est le produit avec l’id " + id;
}

2.1.2 Renvoyer une réponse JSON

Nous allons commencer par créer une classe qui représente un produit.
1. Créer une nouvelle classe Produit que nous allons placer dans un package ”model”
sous le package microcommerce.
2. Créer ensuite les propriétés de base de la classe :
package com.ecommerce.microcommerce.model;

public class Produit {

private int id;
private String nom;
private int prix;
}
 3. Générer ensuite le constructeur puis les getters et setters pour toutes les propriétés
ainsi que la méthode toString (Clic droit − > Generate)
4. Retourner sur le code précédent et remplacer la méthode afficherUnProduit par
celle-ci:
//Recuperer un produit par son Id
@GetMapping(value="/Produits/{id}")
public Produit afficherUnProduit(@PathVariable int id) {
Produit produit=newProduit(id, new String("Aspirateur"), 100 );
return produit;
}

5. Lancer de nouveau le Microservice puis rendez-vous par exemple sur

http://localhost:9090/Produits/27

2.2 Créer un DAO

• Créer un package et le nommer dao puis créez dedans une interface nommée Product-
Dao, dans laquelle vous allez déclarer les opérations que nous allons implémenter.
package com.ecommerce.microcommerce.dao;
import com.ecommerce.microcommerce.model.Produit;
import java.util.List;

public interface ProductDao {

public List<Produit>findAll();
public Produit findById(int id);
public Produit save(Produit product);
}

• Maintenant que notre interface est prête, nous allons pouvoir créer son implémentation.
Créer une classe ProductDaoI qui implémente l’interface que nous venons de créer.
• Clic droit puis Generate− >Implement methods.
• 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.
 package com.ecommerce.microcommerce.dao;
import com.ecommerce.microcommerce.model.Produit;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

@Repository
public class ProductDaoI implements ProductDao {
public static List<Produit>produits=newArrayList<>();
static {
produits.add(new Produit(1, newString("PC"), 8500));
produits.add(new Produit(2, newString("Aspirateur"), 500));
produits.add(new Produit(3, newString("Table"), 750));
}

@Override
public List<Produit>findAll() {
return produits;
}

@Override
public Produit findById(int id) {
for (Produit produit : produits) {
if(produit.getId() ==id){
return produit;
}
}
return null;
}

@Override
public Produit save(Produit produit) {
produits.add(produit);
return produit;
}
}

• Nous allons maintenant modifier notre contrôleur afin qu’il utilise notre couche DAO
pour manipuler les produits.
 package com.ecommerce.microcommerce.web.controller;
import com.ecommerce.microcommerce.dao.ProductDaoI;
import com.ecommerce.microcommerce.model.Produit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
public class ProductController {

@Autowired
private ProductDaoI productDao;

//Recuperer la liste des produits

@RequestMapping(value="/Produits", method=RequestMethod.GET)
publicList<Produit>listeProduits() {
return productDao.findAll();
}

//Recuperer un produit par son Id

@GetMapping(value="/Produits/{id}")
public Produit afficherUnProduit(@PathVariable int id) {
return productDao.findById(id);
}
}

• Lancer le Microservice et rendez-vous à http://localhost:9090/Produits/

3 Travail à faire
Compléter l’implémentation du microservice avec toutes les opérations CRUD.