Microservices en Java : feuille de route pour débutant

Microservices en Java : n'ayez pas peur, c'est plus simple qu'il n'y paraît

Avez-vous déjà regardé une application monolithique en pensant : « Si seulement je pouvais diviser cela en parties, pour ne pas craindre qu'une seule modification casse tout » ? Félicitations — vous êtes prêt pour les microservices. Dans le monde Java, ce sujet est entouré de mythes sur une complexité incroyable et une multitude de technologies. En réalité, on peut démarrer avec deux classes et un fichier application.yml.

Dans cet article, nous n'allons pas construire un vaisseau spatial. Nous allons écrire deux microservices simples qui communiqueront entre eux via HTTP, et nous comprendrons par où vraiment commencer. Pas de magie — seulement Java, Spring Boot et du bon sens.

Qu'est-ce qu'un microservice (en termes simples)

Imaginez un restaurant. Le monolithe, c'est quand un seul cuisinier fait tout : il prépare la soupe, cuit le steak et lave la vaisselle. Les microservices, c'est une équipe : un cuisinier est responsable uniquement des soupes, un deuxième de la viande, un troisième des desserts. Chacun travaille indépendamment, mais ensemble ils créent un menu commun.

En Java, un microservice est une application autonome qui gère une fonction métier spécifique (par exemple, « Gestion des utilisateurs » ou « Traitement des commandes »). Il possède sa propre base de données, son propre code, et communique avec d'autres services via le réseau (généralement par HTTP/REST ou via des courtiers de messages).

Par où commencer : la boîte à outils du gentleman

Pour votre premier projet, vous n'aurez besoin que de trois choses :

\n
• Java 17+ — une version moderne avec des fonctionnalités utiles (records, sealed classes).
\n
• Spring Boot 3.x — le framework le plus populaire pour les microservices en Java. Il prend en charge 80% des tâches répétitives.
\n
• Maven ou Gradle — pour la construction. Maven est plus simple pour démarrer, Gradle est plus rapide.
\n

En complément, quand vous voudrez complexifier :

\n
• Docker — pour empaqueter le service dans un conteneur.
\n
• Spring Cloud — pour la découverte de services (Service Discovery) et l'équilibrage de charge.
\n
• PostgreSQL/H2 — une base de données au choix.
\n

Conseil : n'essayez pas d'apprendre Kubernetes et Kafka tout de suite. Commencez par une simple communication REST.

Écrivons notre premier microservice : Service Utilisateurs

Créons un microservice simple capable de fournir des informations sur les utilisateurs. Utilisons Spring Initializr (start.spring.io) ou créons le projet manuellement.

Ajoutez les dépendances dans pom.xml :

<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-web</artifactId>\n</dependency>\n\n<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-data-jpa</artifactId>\n</dependency>\n\n<dependency>\n    <groupId>com.h2database</groupId>\n    <artifactId>h2</artifactId>\n    <scope>runtime</scope>\n</dependency>

Écrivons maintenant le modèle utilisateur :

import jakarta.persistence.*;\n\n@Entity\n@Table(name = "users")\npublic class User {\n    @Id\n    @GeneratedValue(strategy = GenerationType.IDENTITY)\n    private Long id;\n    private String name;\n    private String email;\n\n    // constructeurs, getters, setters (vous pouvez utiliser Lombok)\n    public User() {}\n\n    public User(String name, String email) {\n        this.name = name;\n        this.email = email;\n    }\n\n    // getters et setters\n}

Le repository (accès simplifié aux données) :

import org.springframework.data.jpa.repository.JpaRepository;\n\npublic interface UserRepository extends JpaRepository<User, Long> {\n}

Et le contrôleur — point d'accès REST :

import org.springframework.web.bind.annotation.*;\n\nimport java.util.List;\n\n@RestController\n@RequestMapping("/api/users")\npublic class UserController {\n\n    private