Guide : Architecture Microservices avec Spring Boot

Comprendre et créer une architecture microservices

Hey salut la team Warrior !

Vous avez sans doute déjà entendu parler du termes « Microservices » ce buzzword qui promet agilité, scalabilité et résilience. Mais qu’est-ce que cela signifie concrètement, et comment passer de la théorie à la pratique ?

Jai utilisé ce Api d’échange pour le projet : https://app.exchangerate-api.com

1. Introduction aux Microservices

Qu’est-ce qu’un microservice ?

Définition simple : Un microservice est une petite application indépendante qui fait une seule chose et la fait bien.

Comparaison : Monolithe vs Microservices

Application Monolithe

Problèmes :

❌ Si une partie plante, TOUT plante
❌ Difficile à maintenir quand ça grandit
❌ Impossible de scaler une seule partie

Avantages :

Indépendance : chaque service peut être développé séparément
Scalabilité : on peut multiplier un seul service si nécessaire
Résilience : si msProduct plante, msAchat continue de fonctionner
Technologies différentes : chaque service peut utiliser son langage/BDD

2. Architecture du Projet (exemple)

Vue d’ensemble

Notre projet simule un système d’achat e-commerce avec 3 microservices :

Scénario d’utilisation

Exemple concret :

Client : « Je veux acheter les produits 1 et 2, avec le prix en USD »
msAchat : « OK, laissez-moi vérifier… »
- Appelle msProduct : « Donne-moi les infos des produits 1 et 2 »
- msProduct : « Voici : Produit 1 = 100€, Produit 2 = 200€ »
- msAchat calcule : Total = 300€
- Appelle msExchange : « Convertis 300€ en USD »
- msExchange appelle l’API externe et répond : « 300€ = 347.52 USD »
- msAchat sauvegarde l’achat et répond au client : « Achat créé, total = 347.52 USD »

3. Outils et Technologies

Technologies utilisées

Outil	Rôle	Pourquoi ?
Java 17	Langage de programmation	Standard pour Spring Boot
Spring Boot	Framework	Simplifie la création de microservices
Spring Web	API REST	Créer des endpoints HTTP
Spring Data JPA	Accès BDD	Mapper objets Java ↔ tables MySQL
MySQL	Base de données	Stocker les données persistantes
Lombok	Simplification code	Génère getters/setters automatiquement
MapStruct	Mapping	Convertir Entity ↔ DTO automatiquement
WebFlux	Client HTTP	Appeler d’autres APIs
Maven	Gestionnaire dépendances	Télécharge les bibliothèques

Architecture en couches (Pattern classique)

Chaque microservice suit la même structure :

En plus :

Entity : Représente une table en BDD (@Entity)
DTO : Objet pour transférer des données (pas de @Entity)
Mapper : Convertit Entity ↔ DTO (MapStruct)
Config : Configuration (WebClient, etc.)

4. Microservice 1 : msProduct

Rôle

msProduct gère le catalogue de produits

Créer un produit
Récupérer un produit par son ID
Lister tous les produits

📁 Structure du projet

msProduct/
├── pom.xml                           (Dépendances Maven)
└── src/main/
    ├── java/com/commerce/msproduct/
    │   ├── MsProductApplication.java (Classe principale)
    │   ├── entities/
    │   │   ├── Product.java          (Table en BDD)
    │   │   └── Category.java         (Enum)
    │   ├── dto/
    │   │   ├── ProductReqDto.java    (Requête entrante)
    │   │   └── ProductResDto.java    (Réponse sortante)
    │   ├── mappers/
    │   │   └── ProductMapper.java    (Conversion Entity↔DTO)
    │   ├── repositories/
    │   │   └── ProductRepo.java      (Accès BDD)
    │   ├── services/
    │   │   ├── ProductService.java   (Interface)
    │   │   └── ProductServiceImp.java(Implémentation)
    │   └── web/
    │       └── ProductController.java(API REST)
    └── resources/
        └── application.properties    (Configuration)


msProduct/
├── pom.xml                           (Dépendances Maven)
└── src/main/
    ├── java/com/commerce/msproduct/
    │   ├── MsProductApplication.java (Classe principale)
    │   ├── entities/
    │   │   ├── Product.java          (Table en BDD)
    │   │   └── Category.java         (Enum)
    │   ├── dto/
    │   │   ├── ProductReqDto.java    (Requête entrante)
    │   │   └── ProductResDto.java    (Réponse sortante)
    │   ├── mappers/
    │   │   └── ProductMapper.java    (Conversion Entity↔DTO)
    │   ├── repositories/
    │   │   └── ProductRepo.java      (Accès BDD)
    │   ├── services/
    │   │   ├── ProductService.java   (Interface)
    │   │   └── ProductServiceImp.java(Implémentation)
    │   └── web/
    │       └── ProductController.java(API REST)
    └── resources/
        └── application.properties    (Configuration)

Étape par étape : Création de msProduct

ÉTAPE 1 : Créer le projet avec Spring Initializr

Ouvrir IntelliJ IDEA
File → New → Project → Spring Initializr
Configurer :
- Group : com.commerce
- Artifact : msProduct
- Java : 17
- Dependencies :
  - Spring Web
  - Spring Data JPA
  - MySQL Driver
  - Lombok

ÉTAPE 2 : Configuration (application.properties)

spring.application.name=msProduct
server.port=8080

# Configuration MySQL
spring.datasource.url=jdbc:mysql://localhost:3306/productdb
spring.datasource.username=root
spring.datasource.password=

# JPA/Hibernate
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true


spring.application.name=msProduct
server.port=8080

# Configuration MySQL
spring.datasource.url=jdbc:mysql://localhost:3306/productdb
spring.datasource.username=root
spring.datasource.password=

# JPA/Hibernate
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Explications :

server.port=8080 : Le service écoute sur le port 8080
spring.datasource.url : URL de connexion à MySQL
ddl-auto=update : Hibernate crée/met à jour les tables automatiquement
show-sql=true : Affiche les requêtes SQL dans la console (utile pour déboguer)

ÉTAPE 3 : Créer l’Entity Product

@Entity  // ← Indique que c'est une table en BDD
@Data    // ← Lombok : génère getters/setters automatiquement
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Product {
    @Id  // ← Clé primaire
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // ← Auto-increment
    private Long id;

    private String productName;
    private Category category;
    private double price;
}


@Entity  // ← Indique que c'est une table en BDD
@Data    // ← Lombok : génère getters/setters automatiquement
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Product {
    @Id  // ← Clé primaire
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // ← Auto-increment
    private Long id;

    private String productName;
    private Category category;
    private double price;
}

Pourquoi @Entity ?

Spring Data JPA va créer une table product avec les colonnes : id, product_name, category, price

ÉTAPE 4 : Créer les DTOs

ProductReqDto (pour créer un produit) :

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ProductReqDto {
    // Pas d'ID : il sera généré automatiquement
    private String productName;
    private Category category;
    private double price;
}


@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ProductReqDto {
    // Pas d'ID : il sera généré automatiquement
    private String productName;
    private Category category;
    private double price;
}

ProductResDto (pour renvoyer un produit) :

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ProductResDto {
    private Long id;  // ← Avec l'ID cette fois
    private String productName;
    private Category category;
    private double price;
}


@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ProductResDto {
    private Long id;  // ← Avec l'ID cette fois
    private String productName;
    private Category category;
    private double price;
}

Pourquoi 2 DTOs différents ?

ReqDto : Le client envoie les données (sans ID car pas encore créé)
ResDto : Le serveur renvoie les données (avec ID généré)

ÉTAPE 5 : Créer le Mapper (MapStruct)

@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ProductMapper {
    ProductResDto todto(Product product);     // Entity → DTO
    Product toEntity(ProductReqDto dto);      // DTO → Entity
}


@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ProductMapper {
    ProductResDto todto(Product product);     // Entity → DTO
    Product toEntity(ProductReqDto dto);      // DTO → Entity
}

Comment ça marche ?

MapStruct génère automatiquement le code de conversion
Spring va l’injecter comme un Bean

ÉTAPE 6 : Créer le Repository

public interface ProductRepo extends JpaRepository<Product, Long> {
    // JpaRepository fournit déjà findById, save, findAll, etc.
    // Pas besoin d'écrire de code !
}


public interface ProductRepo extends JpaRepository<Product, Long> {
    // JpaRepository fournit déjà findById, save, findAll, etc.
    // Pas besoin d'écrire de code !
}

Magie de JPA :

extends JpaRepository<Product, Long> donne accès à toutes les méthodes CRUD
Product : type de l’entity
Long : type de l’ID

ÉTAPE 7 : Créer le Service

Interface :

public interface ProductService {
  ProductResDto getProductById(Long id);
  ProductResDto addProduct(ProductReqDto product);
}

public interface ProductService {
  ProductResDto getProductById(Long id);
  ProductResDto addProduct(ProductReqDto product);
}

Implémentation :

package com.example.demo.service.impl;

import com.example.demo.dto.ProductReqDto;
import com.example.demo.dto.ProductResDto;
import com.example.demo.entity.Product;
import com.example.demo.exception.EntityNotFoundException;
import com.example.demo.mapper.ProductMapper;
import com.example.demo.repository.ProductRepo;
import com.example.demo.service.ProductService;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class ProductServiceImp implements ProductService {

    private final ProductRepo productRepo;
    private final ProductMapper mapper;

    //Injection de dépendances par constructeur (Spring Boot la gère automatiquement)
    public ProductServiceImp(ProductRepo productRepo, ProductMapper mapper) {
        this.productRepo = productRepo;
        this.mapper = mapper;
    }

    @Override
    public ProductResDto getProductById(Long id) {
        //Recherche du produit dans la base de données
        Optional<Product> productOptional = productRepo.findById(id);

        //Vérification si trouvé
        Product product = productOptional.orElseThrow(
                () -> new EntityNotFoundException("Product not found")
        );

        //Conversion Entity → DTO et retour
        return mapper.toDto(product);
    }

    @Override
    public ProductResDto addProduct(ProductReqDto productReqDto) {
        // 1️⃣ Conversion DTO → Entity
        Product product = mapper.toEntity(productReqDto);

        // 2️⃣ Sauvegarde en base de données
        Product savedProduct = productRepo.save(product);

        // 3️⃣ Conversion Entity → DTO et retour
        return mapper.toDto(savedProduct);
    }
}

package com.example.demo.service.impl;

import com.example.demo.dto.ProductReqDto;
import com.example.demo.dto.ProductResDto;
import com.example.demo.entity.Product;
import com.example.demo.exception.EntityNotFoundException;
import com.example.demo.mapper.ProductMapper;
import com.example.demo.repository.ProductRepo;
import com.example.demo.service.ProductService;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class ProductServiceImp implements ProductService {

    private final ProductRepo productRepo;
    private final ProductMapper mapper;

    //Injection de dépendances par constructeur (Spring Boot la gère automatiquement)
    public ProductServiceImp(ProductRepo productRepo, ProductMapper mapper) {
        this.productRepo = productRepo;
        this.mapper = mapper;
    }

    @Override
    public ProductResDto getProductById(Long id) {
        //Recherche du produit dans la base de données
        Optional<Product> productOptional = productRepo.findById(id);

        //Vérification si trouvé
        Product product = productOptional.orElseThrow(
                () -> new EntityNotFoundException("Product not found")
        );

        //Conversion Entity → DTO et retour
        return mapper.toDto(product);
    }

    @Override
    public ProductResDto addProduct(ProductReqDto productReqDto) {
        // 1️⃣ Conversion DTO → Entity
        Product product = mapper.toEntity(productReqDto);

        // 2️⃣ Sauvegarde en base de données
        Product savedProduct = productRepo.save(product);

        // 3️⃣ Conversion Entity → DTO et retour
        return mapper.toDto(savedProduct);
    }
}

ÉTAPE 8 : Créer le Controller

@RestController
@RequestMapping("/api/product")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    // GET /api/product/1
    @GetMapping("/{id}")
    public ProductResDto getProduct(@PathVariable Long id) {
        return productService.getProductById(id);
    }

    // POST /api/product/add
    @PostMapping("/add")
    public ProductResDto addProduct(@RequestBody ProductReqDto productReqDto) {
        return productService.addProduct(productReqDto);
    }
}


@RestController
@RequestMapping("/api/product")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    // GET /api/product/1
    @GetMapping("/{id}")
    public ProductResDto getProduct(@PathVariable Long id) {
        return productService.getProductById(id);
    }

    // POST /api/product/add
    @PostMapping("/add")
    public ProductResDto addProduct(@RequestBody ProductReqDto productReqDto) {
        return productService.addProduct(productReqDto);
    }
}

Annotations importantes :

@RestController : Classe qui gère les requêtes HTTP
@RequestMapping("/api/product") : Préfixe de tous les endpoints
@GetMapping("/{id}") : Route GET avec paramètre dynamique
@PostMapping("/add") : Route POST
@PutMapping("/update/{id}") : Route PUT pour mettre à jour une ressource
@DeleteMapping("/delete/{id}") : Route DELETE pour supprimer une ressource
@PathVariable : Récupère {id} de l’URL
@RequestBody : Récupère le JSON du body
@Autowired : Injecte automatiquement les dépendances (services, repos, etc.)
@CrossOrigin : Gère les autorisations CORS entre frontend et backend
@Service : Marque une classe comme contenant la logique métier
@Repository : Gère l’accès aux données (interactions BDD)
@Component : Annotation générique pour qu’une classe soit gérée par Spring

ÉTAPE 9 : Créer la base de données

CREATE DATABASE productdb;


CREATE DATABASE productdb;

ÉTAPE 10 : Lancer et tester

Test avec Postman :

1. Créer un produit :

POST http://localhost:8080/api/product/add
Content-Type: application/json

{
  "productName": "Laptop Dell",
  "category": "ELECTRONICS",
  "price": 999.99
}


POST http://localhost:8080/api/product/add
Content-Type: application/json

{
  "productName": "Laptop Dell",
  "category": "ELECTRONICS",
  "price": 999.99
}

2. Récupérer un produit :

GET http://localhost:8080/api/product/1


GET http://localhost:8080/api/product/1

5. Microservice 2 : msAchat

Lien GitHub pour la suite et le code Open