Scribd
Importer
68 vues13 pages

Atelier8 Microservices

Transféré par

eya.amri
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd
68 vues13 pages

Atelier8 Microservices

Transféré par

eya.amri
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Atelier 8 : Les micro services 2025

Partie 1

1. Objectif
Cet atelier présente la création d’un simple micro service en utilisant le framework Spring
Boot. Spring Boot permet de faciliter le développement d'applications fondées sur Spring en
créant des applications packagées en jar, totalement autonomes. L’objectif de cet atelier est de:
- Créer un micro service
- Explorer Spring Boot
- Découvrir le module Spring Data de JPA
- Créer une base de données volatile avec H2 database
- Créer un Rest Controller
- Tester notre API grâce à Swagger-ui

2. Prérequis
Cet atelier nécessite la mise en place du plugin Spring Boot.
Ouvrir Eclipse IDA -> aller vers Help -> cliquer Eclipse Marketplace
Chercher “spring boot”, installer le puis redémarrer votre Eclipse IDE.

3. Base de données H2
H2 est une base de données JAVA SQL volatile, rapide, légère et qui peut être persistée (dans
un fichier) ➔ lien officiel : https://www.h2database.com/html/main.html
Nous l’utilisons souvent dans les tests d’intégration d’une application.
Les principales caractéristiques de H2 sont :
• API JDBC très rapide et open source
• Modes embarqué et serveur ; bases de données en mémoire
• Application console basée sur un navigateur
• Faible encombrement : taille de fichier jar d'environ 2,5 Mo

1
Atelier 8 : Les micro services 2025
Partie 1

4. Création d’un micro-service


Cette section a pour objectif de créer le micro service « compte-service ». Ce service permet :
- Créer un compte
- Récupérer tous les comptes
- Récupérer les informations d’un compte via son id
- Supprimer un compte
- Mettre à jour un compte
Pour mettre en place ce micro-service, veuillez suivre les étapes suivantes :
a. Création d’un projet Spring Boot
Allez sur File->new->Project, Sélectionnez Spring Starter Projet sous le dossier Spring Boot :

Cliquez sur Next. Remplissez ensuite les informations comme suit :

2
Atelier 8 : Les micro services 2025
Partie 1

Sélectionnez les 5 dépendances dans la figure. Pour chercher la dépendance, tapez le nom
dans le champ Available :

Cliquez sur finish.

b. Création d’un projet Spring Boot


Crééz 4 packages sous le package org.sid.compteservice :
- Org.sid.compteservice.entities : contiendra les classes POJO
- Org.sid.compteservice.repositories : représente la couche DAO
- Org.sid.compteservice.service : représente la couche métier
- Org.sid.compteservice.web : contiendra le Rest Contrôleur

3
Atelier 8 : Les micro services 2025
Partie 1

i. Package org.sid.compteservice.entities
Nous allons créer la classe POJO compte qui est une entité persistante :
package org.sid.compteservice.entities;

import java.util.Date;

import org.sid.compteservice.enums.TypeCompte;

import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data @NoArgsConstructor @AllArgsConstructor


@Entity
public class Compte {

@Id @GeneratedValue(strategy = GenerationType.IDENTITY)


private Long code;
private double solde;
private Date dateCreation;
@Enumerated(EnumType.STRING)
private TypeCompte type;
}

Nous avons rajouté les annotations lombok pour générer les méthodes getters/setters et les
constructeurs.
Nous avons créé l’énumération TypeCompte.java sous le package org.sid.compteservice.enums
comme suit :
package org.sid.compteservice.enums;

public enum TypeCompte {


COURANT,
EPARGNE

ii. Package org.sid.compteservice.repositories


Nous utilisons Spring Data pour créer l’interface JpaRepository. Nous allons créer l’interface
CompteRepository qui hérite de l’interface JpaRepository et après nous spécifions la classe et

4
Atelier 8 : Les micro services 2025
Partie 1

le type de la clé primaire. L’interface JpaRepository représente la partie DAO càd elle offre
l’implémentation de toutes les méthodes CRUD.

package org.sid.compteservice.repositories;

import org.sid.compteservice.entities.Compte;
import
org.springframework.data.jpa.repository.JpaRepository;

public interface CompteRepository extends


JpaRepository<Compte,Long>{

c. Configurer la base de données H2


Nous allons modifier le fichier application.properties pour spécifier les informations à propos
de notre base de données en mémoire « compte_db » :
spring.application.name=compte-service
spring.datasource.url=jdbc:h2:mem:compte_db
spring.h2.console.enabled=true

Comme serveur, spring boot utilise tomcat. Le port utilisé est 8080.
Si ce port est pris par une autre application, vous pouvez changer le numéro de port en rajoutant
la ligne suivante dans le fichier application.properties :
Server.port=8082
d. Tester l’application compte-service
Dans cette section, nous allons tester si les données sont bien insérées dans la base de données
H2.
Pour ce faire, nous allons modifier la classe CompteServiceApplication contenant la méthode
main comme suit :

5
Atelier 8 : Les micro services 2025
Partie 1

package org.sid.compteservice;

import org.sid.compteservice.enums.TypeCompte;

import java.util.Date;

import org.sid.compteservice.entities.Compte;
import org.sid.compteservice.repositories.CompteRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class CompteServiceApplication {

public static void main(String[] args) {


SpringApplication.run(CompteServiceApplication.class, args);
}

@Bean
CommandLineRunner start(CompteRepository compteRepository) {
return args -> {

compteRepository.save(new Compte(null, 98000, new Date(), TypeCompte.COURANT));


compteRepository.save(new Compte(null, 12000, new Date(), TypeCompte.EPARGNE));
compteRepository.save(new Compte(null, 2100, new Date(), TypeCompte.COURANT));

compteRepository.findAll().forEach(cp->{
System.out.println(cp.getType());
System.out.println(cp.getSolde());
});
};
}
}

Exécuter l’application en tant que Spring Boot App. Vous devez avoir la sortie suivante :
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
[32m :: Spring Boot :: [39m [2m (v3.2.4)[0;39m

[2m2024-04-18T16:10:15.130+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-


service] [ main][0;39m [2m[0;39m[36mo.s.c.CompteServiceApplication [0;39m
[2m:[0;39m Starting CompteServiceApplication using Java 17.0.7 with PID 1264
(C:\Users\jarra\eclipse-workspace\compte-service\target\classes started by jarra in
C:\Users\jarra\eclipse-workspace\compte-service)

6
Atelier 8 : Les micro services 2025
Partie 1

[2m2024-04-18T16:10:15.135+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-


service] [ main][0;39m [2m[0;39m[36mo.s.c.CompteServiceApplication [0;39m
[2m:[0;39m No active profile set, falling back to 1 default profile: "default"
[2m2024-04-18T16:10:16.204+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36m.s.d.r.c.RepositoryConfigurationDelegate[0;39m
[2m:[0;39m Bootstrapping Spring Data JPA repositories in DEFAULT mode.
[2m2024-04-18T16:10:16.281+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36m.s.d.r.c.RepositoryConfigurationDelegate[0;39m
[2m:[0;39m Finished Spring Data repository scanning in 67 ms. Found 1 JPA repository interface.
[2m2024-04-18T16:10:17.420+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.s.b.w.embedded.tomcat.TomcatWebServer [0;39m
[2m:[0;39m Tomcat initialized with port 8080 (http)
[2m2024-04-18T16:10:17.491+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.apache.catalina.core.StandardService [0;39m
[2m:[0;39m Starting service [Tomcat]
[2m2024-04-18T16:10:17.491+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.apache.catalina.core.StandardEngine [0;39m
[2m:[0;39m Starting Servlet engine: [Apache Tomcat/10.1.19]
[2m2024-04-18T16:10:17.606+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.a.c.c.C.[Tomcat].[localhost].[/] [0;39m
[2m:[0;39m Initializing Spring embedded WebApplicationContext
[2m2024-04-18T16:10:17.606+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mw.s.c.ServletWebServerApplicationContext[0;39m
[2m:[0;39m Root WebApplicationContext: initialization completed in 2420 ms
[2m2024-04-18T16:10:17.686+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mcom.zaxxer.hikari.HikariDataSource [0;39m
[2m:[0;39m HikariPool-1 - Starting...
[2m2024-04-18T16:10:18.133+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mcom.zaxxer.hikari.pool.HikariPool [0;39m
[2m:[0;39m HikariPool-1 - Added connection conn0: url=jdbc:h2:mem:compte_db user=SA
[2m2024-04-18T16:10:18.135+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mcom.zaxxer.hikari.HikariDataSource [0;39m
[2m:[0;39m HikariPool-1 - Start completed.
[2m2024-04-18T16:10:18.148+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.s.b.a.h2.H2ConsoleAutoConfiguration [0;39m
[2m:[0;39m H2 console available at '/h2-console'. Database available at 'jdbc:h2:mem:compte_db'
[2m2024-04-18T16:10:18.535+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.hibernate.jpa.internal.util.LogHelper [0;39m
[2m:[0;39m HHH000204: Processing PersistenceUnitInfo [name: default]
[2m2024-04-18T16:10:18.653+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36morg.hibernate.Version [0;39m
[2m:[0;39m HHH000412: Hibernate ORM core version 6.4.4.Final
[2m2024-04-18T16:10:18.731+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.h.c.internal.RegionFactoryInitiator [0;39m
[2m:[0;39m HHH000026: Second-level cache disabled
[2m2024-04-18T16:10:19.498+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.s.o.j.p.SpringPersistenceUnitInfo [0;39m
[2m:[0;39m No LoadTimeWeaver setup: ignoring JPA class transformer
[2m2024-04-18T16:10:23.645+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.h.e.t.j.p.i.JtaPlatformInitiator [0;39m
[2m:[0;39m HHH000489: No JTA platform available (set 'hibernate.transaction.jta.platform' to enable
JTA platform integration)
[2m2024-04-18T16:10:23.780+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mj.LocalContainerEntityManagerFactoryBean[0;39m
[2m:[0;39m Initialized JPA EntityManagerFactory for persistence unit 'default'
[2m2024-04-18T16:10:24.751+02:00[0;39m [33m WARN[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mJpaBaseConfiguration$JpaWebConfiguration[0;39m
[2m:[0;39m spring.jpa.open-in-view is enabled by default. Therefore, database queries may be
performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this
warning
[2m2024-04-18T16:10:25.844+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-
service] [ main][0;39m [2m[0;39m[36mo.s.b.w.embedded.tomcat.TomcatWebServer [0;39m
[2m:[0;39m Tomcat started on port 8080 (http) with context path ''

7
Atelier 8 : Les micro services 2025
Partie 1

[2m2024-04-18T16:10:25.860+02:00[0;39m [32m INFO[0;39m [35m1264[0;39m [2m---[0;39m [2m[compte-


service] [ main][0;39m [2m[0;39m[36mo.s.c.CompteServiceApplication [0;39m
[2m:[0;39m Started CompteServiceApplication in 11.116 seconds (process running for 17.24)
COURANT
98000.0
EPARGNE
12000.0
COURANT
2100.0

Nous vérifions maintenant la génération automatique de la base de données « compte_db ». Il


suffit d’aller sur la console H2 : http://localhost:8080/h2-console

Cliquez sur Connect.

8
Atelier 8 : Les micro services 2025
Partie 1

 La base de données « compte_db » est bien créée. Nous voyons bien l’insertion des
trois comptes.

e. Mise en place du Rest Controler


Pourque l’application soit un micro-service, il faut que les méthodes CRUD soient sollicitées
via des requêtes HTTP. Pour cela, nous allons compléter l’application en rajoutant un Rest
Controller.java sous le package org.sid.compteservice.web :

package org.sid.compteservice.web;

import org.sid.compteservice.repositories.CompteRepository;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;

9
Atelier 8 : Les micro services 2025
Partie 1

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

import org.sid.compteservice.entities.Compte;

@RestController
public class CompteRestController {

private CompteRepository compteRepository;

public CompteRestController(CompteRepository compteRepository) {


this.compteRepository = compteRepository;
}

@GetMapping(path="/comptes")
public List<Compte> listComptes(){
return compteRepository.findAll();
}

@GetMapping(path="/comptes/{id}")
public Compte getCompte(@PathVariable Long id){
return compteRepository.findById(id).get();
}

@PostMapping(path="/comptes")
public Compte save(@RequestBody Compte compte) {
return compteRepository.save(compte);
}

@PutMapping(path="/comptes/{code}")
public Compte update(@PathVariable Long code, @RequestBody Compte compte) {
compte.setCode(code);
return compteRepository.save(compte);
}

@DeleteMapping(path="/comptes/{code}")
public void delete(@PathVariable Long code) {
compteRepository.deleteById(code);
}

Commentez la dépendance spring-data-rest dans le fichier pom.xml :


<!-- <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>-->

Remarque :
Généralement, nous utilisons l’annotation @RestController pour créer un contrôleur REST.
Lorsqu’il s’agit d’un simple contrôleur qui concerne seulement les méthodes CRUD (tel est
notre cas), vous pouvez :
- Activer la dépendance en utilisant spring-data-rest

10
Atelier 8 : Les micro services 2025
Partie 1

- Supprimer l’annotation @RestController du fichier Rest Controller.java.


- Rajouter l’annotation @RepositoryRestResource dans le fichier CompteRepository.java
comme suit :

package org.sid.compteservice.repositories;

import org.sid.compteservice.entities.Compte;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource
public interface CompteRepository extends JpaRepository<Compte,Long>{

f. Tester le micro-service compte-service


Pour tester la récupération de la liste des comptes à travers le navigateur, allez sur
http://localhost:8080/comptes

Pour avoir cet affichage en format JSON, il suffit d’installer l’extension JSON Formatter
sous Google Chrome :

11
Atelier 8 : Les micro services 2025
Partie 1

Maintenant, testez la récupération d’un compte selon son id : http://localhost:8080/comptes/2

Nous avons testé précédemment les méthodes qui permettent de consulter via les requêtes
GetMapping.
Maintenant, pour tester les méthodes qui permettent de mettre à jour un compte
(PutMapping), de supprimer un compte (DeleteMapping) et d’ajouter un compte
(PostMapping), nous allons utiliser l’api swagger-ui.

Pour cela, rajoutez la dépendance suivante dans le fichier pom.xml puis sauvegardez :
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<version>2.5.0</version>
</dependency>

Allez maintenant sur le navigateur en tapant http://localhost:8080/swagger-ui/index.html

12
Atelier 8 : Les micro services 2025
Partie 1

Comme exemple, nous allons tester l’ajout d’un nouveau compte. Pour cela, allez sur le
POST et cliquez sur le try it now. Modifiez les données en remplaçant par les nouvelles
valeurs puis cliquez sur Exécuter :

Pour vérifier le rajout du compte, allez sur GET :

La création du compte ayant l’id 4 s’est bien effectuée.

13

Vous aimerez peut-être aussi