🔥 FREE PRO OFFER Linkage.page Pro Version is 100% Free of Cost till 31 December, 2026! Claim Free Pro

Microservices

Injection de dépendances dans Quarkus avec CDI : ArC, scopes, qualificateurs et injection au moment de la construction

Injection de dépendances dans Quarkus avec CDI : ArC, scopes, qualificateurs et injection au moment de la construction

L’injection de dépendances (DI) est le fondement du développement d’applications Java d’entreprise moderne. Pendant des années, les développeurs Java se sont appuyés sur des conteneurs Spring IoC (Inversion of Control) ou Jakarta EE CDI (Contexts and Dependency Injection) standard comme Hibernate Weld ou OpenWebBeans pour découpler les cycles de vie des composants, gérer les dépendances de service et injecter des propriétés de configuration.
Java Quarkus CDI ArC Dependency Injection Microservices Cloud Native Software Architecture GraalVM
Création d'API REST avec Java Quarkus : Guide haute performance, réactif et Cloud-Native

Création d'API REST avec Java Quarkus : Guide haute performance, réactif et Cloud-Native

Dans l’ingénierie logicielle d’entreprise moderne, la création d’API RESTful constitue la pierre angulaire du développement des systèmes backend. Pendant des décennies, les développeurs Java se sont appuyés sur des frameworks traditionnels tels que Spring Boot ou Jakarta EE. Voici Quarkus—le framework Supersonic Subatomic Java conçu sur mesure pour OpenJDK HotSpot et GraalVM. 1. Pourquoi choisir Quarkus pour vos API REST Java ? A. Le paradigme réactif RESTEasy B. Dev Services & Live Coding sans configuration 2. Architecture d’une API REST Quarkus 3. Initialisation du projet et dépendances mvn io.quarkus.platform:quarkus-maven-plugin:3.15.0:create \ -DprojectGroupId=com.ghaznix.api \ -DprojectArtifactId=quarkus-product-api \ -DclassName="com.ghaznix.api.ProductResource" \ -Dpath="/api/products" \ -Dextensions="resteasy-reactive-jackson,hibernate-orm-panache,jdbc-postgresql,hibernate-validator,smallrye-openapi" 4. Configuration des propriétés de l’application # Application Configuration quarkus.application.name=quarkus-product-api quarkus.http.port=8080 # Database Configuration (Dev Services will override in dev mode automatically) quarkus.datasource.db-kind=postgresql quarkus.datasource.username=postgres quarkus.datasource.password=secret quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/product_db # Hibernate ORM Configuration quarkus.hibernate-orm.database.generation=drop-and-create quarkus.hibernate-orm.log.sql=true # Swagger UI & OpenAPI Path quarkus.swagger-ui.always-include=true quarkus.swagger-ui.path=/swagger-ui 5. Modèle de domaine et Active Record avec Panache package com.ghaznix.api; import io.quarkus.hibernate.orm.panache.PanacheEntity; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.Table; import jakarta.validation.constraints.Min; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; import java.math.BigDecimal; import java.util.List; @Entity @Table(name = "products") public class Product extends PanacheEntity { @NotBlank(message = "Product name cannot be blank") @Column(nullable = false) public String name; @Column(length = 1000) public String description; @NotNull(message = "Price is required") @Min(value = 0, message = "Price must be non-negative") @Column(nullable = false) public BigDecimal price; @Column(nullable = false) public Integer stockQuantity; public String category; // Static Finder Utility Methods powered by Panache public static List<Product> findByCategory(String category) { return list("category", category); } public static List<Product> findAvailableProducts() { return list("stockQuantity > 0"); } } 6. Création de contrôleurs REST pour la production package com.ghaznix.api; import io.quarkus.panache.common.Page; import io.quarkus.panache.common.Sort; import jakarta.transaction.Transactional; import jakarta.validation.Valid; import jakarta.ws.rs.*; import jakarta.ws.rs.core.MediaType; import jakarta.ws.rs.core.Response; import org.eclipse.microprofile.openapi.annotations.Operation; import org.eclipse.microprofile.openapi.annotations.responses.APIResponse; import org.eclipse.microprofile.openapi.annotations.tags.Tag; import java.net.URI; import java.util.List; @Path("/api/products") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) @Tag(name = "Product REST API", description = "Operations for managing catalog products") public class ProductResource { @GET @Operation(summary = "Get all products with pagination") @APIResponse(responseCode = "200", description = "List of products retrieved successfully") public List<Product> getAllProducts( @QueryParam("page") @DefaultValue("0") int pageIndex, @QueryParam("size") @DefaultValue("10") int pageSize, @QueryParam("sort") @DefaultValue("name") String sortBy) { return Product.findAll(Sort.by(sortBy)) .page(Page.of(pageIndex, pageSize)) .list(); } @GET @Path("/{id}") @Operation(summary = "Get product by ID") @APIResponse(responseCode = "200", description = "Product details found") @APIResponse(responseCode = "404", description = "Product not found") public Product getProductById(@PathParam("id") Long id) { Product product = Product.findById(id); if (product == null) { throw new NotFoundException("Product with ID " + id + " does not exist."); } return product; } @POST @Transactional @Operation(summary = "Create a new product") @APIResponse(responseCode = "201", description = "Product created successfully") @APIResponse(responseCode = "400", description = "Invalid request payload") public Response createProduct(@Valid Product product) { product.persist(); return Response.created(URI.create("/api/products/" + product.id)) .entity(product) .build(); } @PUT @Path("/{id}") @Transactional @Operation(summary = "Update an existing product") @APIResponse(responseCode = "200", description = "Product updated") @APIResponse(responseCode = "404", description = "Product ID not found") public Product updateProduct(@PathParam("id") Long id, @Valid Product updatedProduct) { Product entity = Product.findById(id); if (entity == null) { throw new NotFoundException("Product with ID " + id + " not found."); } entity.name = updatedProduct.name; entity.description = updatedProduct.description; entity.price = updatedProduct.price; entity.stockQuantity = updatedProduct.stockQuantity; entity.category = updatedProduct.category; return entity; } @DELETE @Path("/{id}") @Transactional @Operation(summary = "Delete a product by ID") @APIResponse(responseCode = "204", description = "Product deleted successfully") @APIResponse(responseCode = "404", description = "Product ID not found") public Response deleteProduct(@PathParam("id") Long id) { boolean deleted = Product.deleteById(id); if (!deleted) { throw new NotFoundException("Product with ID " + id + " not found."); } return Response.noContent().build(); } } 7. Points de terminaison réactifs vs Exécution bloquante import io.smallrye.mutiny.Uni; import io.smallrye.mutiny.Multi; @GET @Path("/reactive/{id}") public Uni<Product> getProductReactive(@PathParam("id") Long id) { return Product.<Product>findByIdAsync(id) .onItem().ifNull().failWith(new NotFoundException("Product not found")); } @GET @Path("/stream") @Produces(MediaType.SERVER_SENT_EVENTS) public Multi<Product> streamProducts() { return Product.streamAll(); } 8. Gestion globale des exceptions package com.ghaznix.api.exception; import jakarta.ws.rs.NotFoundException; import jakarta.ws.rs.core.MediaType; import jakarta.ws.rs.core.Response; import jakarta.ws.rs.ext.ExceptionMapper; import jakarta.ws.rs.ext.Provider; import java.time.Instant; import java.util.HashMap; import java.util.Map; @Provider public class GlobalExceptionMapper implements ExceptionMapper<Exception> { @Override public Response toResponse(Exception exception) { Map<String, Object> errorPayload = new HashMap<>(); errorPayload.put("timestamp", Instant.now().toString()); if (exception instanceof NotFoundException) { errorPayload.put("status", 404); errorPayload.put("error", "Not Found"); errorPayload.put("message", exception.getMessage()); return Response.status(Response.Status.NOT_FOUND) .entity(errorPayload) .type(MediaType.APPLICATION_JSON) .build(); } errorPayload.put("status", 500); errorPayload.put("error", "Internal Server Error"); errorPayload.put("message", exception.getMessage()); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(errorPayload) .type(MediaType.APPLICATION_JSON) .build(); } } 9. Tests automatisés avec @QuarkusTest & REST Assured package com.ghaznix.api; import io.quarkus.test.junit.QuarkusTest; import io.restassured.http.ContentType; import org.junit.jupiter.api.Test; import static io.restassured.RestAssured.given; import static org.hamcrest.CoreMatchers.*; @QuarkusTest public class ProductResourceTest { @Test public void testGetAllProductsEndpoint() { given() .when().get("/api/products") .then() .statusCode(200) .contentType(ContentType.JSON); } @Test public void testCreateAndGetProduct() { Product product = new Product(); product.name = "Gaming Laptop"; product.description = "High-performance GPU laptop"; product.price = new java.math.BigDecimal("1499.99"); product.stockQuantity = 15; product.category = "Electronics"; // Test POST Endpoint Integer createdId = given() .contentType(ContentType.JSON) .body(product) .when().post("/api/products") .then() .statusCode(201) .body("name", equalTo("Gaming Laptop")) .extract().path("id"); // Test GET Endpoint by ID given() .pathParam("id", createdId) .when().get("/api/products/{id}") .then() .statusCode(200) .body("category", equalTo("Electronics")); } } ./mvnw test 10. Emballage et compilation native GraalVM ./mvnw quarkus:dev ./mvnw package java -jar target/quarkus-app/quarkus-run.jar ./mvnw package -Dnative -Dquarkus.native.container-build=true ./target/quarkus-product-api-1.0.0-runner 2026-09-21 22:30:00,014 INFO [io.quarkus] (main) quarkus-product-api 1.0.0-runner native (powered by Quarkus 3.15.0) started in 0.018s. Listening on: http://0.0.0.0:8080 11. Benchmarks de performance : Quarkus vs Spring Boot Métrique de benchmark Spring Boot (JVM) Quarkus (OpenJDK JVM) Quarkus (GraalVM Native) Amélioration Temps de démarrage (à froid) 3,82 secondes 1,18 seconde 0,015 seconde 254x plus rapide Empreinte mémoire (RSS) 184 Mo 108 Mo 28 Mo 84% d’économie mémoire 12. Conclusion & Bonnes Pratiques Ghaznix Blog.
Java Quarkus REST API Microservices GraalVM Programmation Réactive Hibernate Panache Cloud Native Architecture Logicielle
Quarkus vs Spring Boot : quel framework Java devriez-vous choisir ?

Quarkus vs Spring Boot : quel framework Java devriez-vous choisir ?

Depuis plus d’une décennie, Spring Boot règne en maître en tant que standard de facto pour la création d’applications Java d’entreprise. Son écosystème riche, son paradigme de convention plutôt que de configuration, son moteur d’injection de dépendances robuste et son vaste support communautaire ont fait de Java le fondement des systèmes backend dans le monde entier.
Java Quarkus Spring Boot GraalVM Microservices Cloud Native Kubernetes JVM Software Architecture
Introduction à Quarkus : pourquoi les développeurs Java migrent vers Supersonic Java

Introduction à Quarkus : pourquoi les développeurs Java migrent vers Supersonic Java

Depuis près de trois décennies, Java constitue la force dominante du développement de logiciels d’entreprise. Son écosystème riche, sa base robuste orientée objet, son indépendance de plate-forme via la machine virtuelle Java (JVM) et ses frameworks éprouvés comme Spring Boot en ont fait le roi incontesté de l’infrastructure backend.
Java Quarkus GraalVM Microservices Cloud Native Spring Boot JVM Software Architecture Serverless
Chorégraphie vs orchestration : conception de flux de travail distribués dans des microservices

Chorégraphie vs orchestration : conception de flux de travail distribués dans des microservices

Dans une architecture monolithique, l’exécution d’une transaction commerciale complexe, telle que l’exécution d’une commande de commerce électronique, est simple. Toutes les données résident dans une seule base de données relationnelle, ce qui permet aux développeurs d’encapsuler plusieurs écritures de base de données concernant l’inventaire, les paiements et l’expédition dans une seule transaction ACID. Si une erreur se produit à un moment donné, un ROLLBACK SQL restaure instantanément la cohérence du système.
Microservices Chorégraphie Orchestration Conception du système Systèmes distribués Modèle de saga Architecture pilotée par les événements Architecture logicielle
Le modèle Saga : transactions distribuées dans une architecture de microservices

Le modèle Saga : transactions distribuées dans une architecture de microservices

Dans les applications monolithiques traditionnelles, maintenir la cohérence des données entre plusieurs entités est simple. Les moteurs de bases de données relationnelles fournissent des garanties ACID (Atomicité, Cohérence, Isolation, Durabilité) enveloppées dans des transactions SQL locales. Si une commande, une déduction de paiement ou une réserve de stock échoue à mi-parcours, l’appel de ROLLBACK annule instantanément chaque modification de la base de données.
Microservices Saga Pattern Distributed Transactions Event-Driven Architecture Kafka Orchestration Choreography System Design
Le patron Transactional Outbox : publier des événements de manière fiable dans les microservices

Le patron Transactional Outbox : publier des événements de manière fiable dans les microservices

Dans l’architecture moderne axée sur les événements (Event-Driven Architecture), les microservices émettent en permanence des événements métier (OrderCreated, PaymentProcessed) pour communiquer de manière découplée. Cependant, publier un événement de façon 100% fiable pose un problème critique : Comment garantir que la mise à jour de la base de données et la publication de l’événement réussissent ou échouent ensemble ?
Microservices Outbox Pattern Distributed Systems Kafka Debezium Event-Driven Architecture System Design
Le modèle de repli : concevoir une dégradation gracieuse dans les microservices

Le modèle de repli : concevoir une dégradation gracieuse dans les microservices

Dans une architecture de microservices, les services forment un réseau d’appels réseau distribués. Bien que cela permette aux équipes de créer et de faire évoluer les services de manière indépendante, cela signifie également que la fiabilité globale de votre système est aussi forte que son maillon le plus faible. Si un service critique tombe en panne ou ne répond plus, cela peut déclencher une panne en cascade qui perturbe l’ensemble de l’application.
Microservices Fallback Pattern Software Architecture System Design Fault Tolerance Resilience
Le modèle de nouvelle tentative : créer des microservices résilients

Le modèle de nouvelle tentative : créer des microservices résilients

Dans une architecture de microservices, les services communiquent via un réseau plutôt que via des appels en mémoire. Bien que ce découplage permette une mise à l’échelle horizontale massive et des déploiements indépendants, il introduit également une vulnérabilité majeure : le réseau n’est pas fiable. À tout moment, un service en aval peut rencontrer un bref problème de réseau, un pic temporaire du processeur, un conflit de verrouillage rapide de la base de données ou un redémarrage de mise à jour continue. Ces échecs temporaires sont appelés défauts transitoires.
Microservices Retry Pattern Software Architecture System Design Fault Tolerance Resilience
Le modèle de cloisonnement : conception de microservices tolérants aux pannes

Le modèle de cloisonnement : conception de microservices tolérants aux pannes

Dans une architecture de microservices, une seule application est décomposée en dizaines ou centaines de services indépendants et collaboratifs. Bien que cette conception améliore la modularité et l’évolutivité, elle introduit également un risque majeur : une défaillance d’un service peut se répercuter et faire tomber l’ensemble du système. Si un service en aval devient lent ou ne répond plus, les demandes entrantes adressées à vos services en amont commenceront à s’accumuler. S’ils partagent tous la même mémoire, le même processeur ou le même pool de threads, une dépendance lente peut rapidement épuiser toutes les ressources disponibles, provoquant le blocage de l’ensemble de votre application.
Microservices Bulkhead Pattern Software Architecture System Design Fault Tolerance Resilience
Le modèle side-car : extension des microservices sans modification du code

Le modèle side-car : extension des microservices sans modification du code

Dans les systèmes cloud natifs modernes, les microservices devraient faire bien plus que simplement exécuter une logique métier. Ils doivent gérer la journalisation, gérer les certificats SSL/TLS, collecter des métriques, mettre en œuvre des mécanismes de nouvelle tentative et coordonner les communications sécurisées avec d’autres services. Si nous intégrons toutes ces fonctionnalités transversales directement dans la base de code de chaque application, nous nous retrouvons avec une surcharge de code, un couplage étroit et un verrouillage linguistique.
Microservices Sidecar Pattern Software Architecture System Design Kubernetes DevOps
Le modèle Strangler Fig : un moyen sûr de migrer des applications monolithiques

Le modèle Strangler Fig : un moyen sûr de migrer des applications monolithiques

Dans le génie logiciel moderne, les applications monolithiques existantes constituent un défi courant. Au fil du temps, une base de code réussie devient si volumineuse et interconnectée que la réalisation de simples modifications devient risquée, les déploiements prennent des heures et la mise à l’échelle de fonctionnalités individuelles est pratiquement impossible.
Software Architecture Microservices Monolith Migration System Design Strangler Fig API Routing Refactoring
Comprendre le modèle Backend for Frontend (BFF) : un guide simple

Comprendre le modèle Backend for Frontend (BFF) : un guide simple

Dans une architecture de microservices, nos systèmes sont décomposés en dizaines de petits services ciblés, comme un service utilisateur, un service de commande et un service produit. Mais lorsqu’il s’agit d’afficher ces informations à vos utilisateurs, les différents appareils ont des besoins très différents. Un navigateur Web sur un ordinateur de bureau à grande vitesse nécessite un tableau de bord riche rempli de tableaux, de barres latérales et de graphiques. Une application mobile sur un réseau cellulaire lent nécessite une mise en page simple et légère pour économiser la bande passante et la batterie. Une application de montre intelligente peut n’avoir besoin que d’une seule ligne de texte.
Microservices BFF Pattern Backend for Frontend Software Architecture System Design Node.js
Comprendre le modèle API Gateway dans les microservices : un guide simple

Comprendre le modèle API Gateway dans les microservices : un guide simple

La transition d’une application unique et monolithique vers une architecture de microservices résout de nombreux problèmes. Il permet aux équipes de travailler de manière indépendante, de déployer des services séparément et de faire évoluer certaines parties du système selon les besoins. Cependant, cela introduit également un nouveau défi : comment les clients interagissent-ils avec tous ces services indépendants ?
Microservices API Gateway Software Architecture System Design Routing Security
Pourquoi les microservices modernes préfèrent gRPC à REST

Pourquoi les microservices modernes préfèrent gRPC à REST

Dans une architecture monolithique, les composants communiquent via des appels de méthodes en mémoire, instantanés et hautement fiables. Toutefois, lors du passage à une architecture de microservices, ces composants sont séparés par les limites du réseau. La communication devient un appel réseau hors processus (Inter-Process Communication ou IPC). Depuis des années, REST (Representational State Transfer) sur HTTP/1.1 avec charges utiles JSON est la norme par défaut pour la création d’API Web. Bien que REST soit excellent pour les services Web publics et l’interaction client-serveur, il introduit des goulots d’étranglement importants lorsqu’il est utilisé pour une communication interne de service à service à haute fréquence et à faible latence.
gRPC REST Microservices Java Protocol Buffers HTTP/2 Software Architecture API Design
Conception pilotée par domaine (DDD) dans les microservices

Conception pilotée par domaine (DDD) dans les microservices

Lorsque les organisations passent d’une architecture monolithique aux microservices, elles sont confrontées à une question critique aux enjeux élevés : Comment tracer les limites de nos services ? En théorie, les microservices devraient être des unités lâches et découplées qui peuvent être développées, déployées et mises à l’échelle indépendamment. Dans la pratique, cependant, de nombreuses équipes finissent par créer un monolithe distribué : un système dans lequel les services sont si étroitement couplés qu’un seul changement commercial nécessite de modifier et de déployer plusieurs services simultanément, ce qui aggrave la latence du réseau et les blocages de déploiement.
Microservices Domain-Driven Design DDD Software Architecture Bounded Context System Design
Avantages et défis des microservices dans les applications modernes

Avantages et défis des microservices dans les applications modernes

Au début du développement Web, la création d’une application logicielle était simple : vous écriviez du code, le regroupiez dans une seule archive exécutable ou déployable et l’exécutiez sur un serveur. Cette approche, connue sous le nom d’architecture monolithique, a bien servi l’industrie pendant des décennies. Cependant, à mesure que les applications se transformaient en plates-formes d’entreprise massives comptant des centaines de développeurs et des millions d’utilisateurs simultanés, les monolithes ont commencé à montrer leurs limites. Les déploiements sont devenus lents et risqués, les bases de données sont devenues des goulots d’étranglement et les bases de code sont devenues trop complexes pour être comprises par un seul développeur.
Microservices Software Architecture Distributed Systems API Gateway Saga Pattern DevOps