Comment Quarkus intègre MicroProfile et Spring

Bonjour à tous et avec vous le troisième post de la série Quarkus! (Soit dit en passant, inscrivez-vous et accédez à notre webinaire « This is Quarkus - Kubernetes native Java framework », qui se tiendra le 27 mai. Nous montrerons comment recommencer à zéro ou transférer des solutions prêtes à l'emploi)



Lors du développement de microservices Java, on pense souvent que Eclipse MicroProfile et Spring Le démarrage est une API distincte et indépendante. Par défaut, les programmeurs utilisent généralement les API auxquelles ils sont habitués, car l'apprentissage de nouveaux frameworks et composants d'exécution prend beaucoup de temps. Aujourd'hui, nous allons essayer de simplifier le développement de certaines API MicroProfile populaires pour les développeurs Spring.et montrer comment utiliser l'API Spring et les nouvelles fonctionnalités utiles de Quarkus en même temps .

Si c'est un peu plus détaillé, nous allons d'abord examiner la portée et les détails de la façon dont Quarkus prend en charge les API Spring pour montrer aux développeurs Spring comment utiliser l'API MicroProfile dans leur travail quotidien. Ensuite, nous parlerons de l'API MicroProfile, qui sera utile aux développeurs Spring lors de la création de microservices.

Pourquoi Quarkus? Tout d'abord, il s'agit du codage en direct, c'est-à-dire du rechargement automatique de toutes les modifications apportées à l'API MicroProfile, à l'API Spring et à d'autres API Java, qui est effectué avec une seule commande: mvn quarkus: dev. Deuxièmement, considéré dans notre exemplele service Personne (il est compilé à partir des API Spring, MicroProfile et JPA dans un fichier binaire utilisant l'image GraalVM native) démarre en seulement 0,055 seconde et prend environ 90 Mo de RAM (RSS) au point de terminaison de l'application RESTful. De plus, sa compilation elle-même est effectuée avec une seule commande: mvn package -Pnative.

Nous n'entrerons pas dans les détails de MicroProfile, mais essaierons seulement d'aider les développeurs Spring à comprendre comment dans Quarkus vous pouvez utiliser les API Spring avec les API MicroProfile.

Conteneurs et Kubernetes


Afin de ne pas surcharger cet article, nous ne verrons ici que les aspects de haut niveau du support Kubernetes , car il est important de le comprendre. Quarkus est positionné comme une pile Java pour Kubernetes, il est conçu pour minimiser la consommation de mémoire et le temps de démarrage des applications et services Java, et, par conséquent, augmenter la densité de leur placement sur l'hôte et réduire les coûts globaux.

Quarkus prend également en charge la génération automatique de ressources Kubernetes et propose des guides de déploiement sur les plates-formes Kubernetes et Red Hat OpenShift. De plus, Quarkus génère automatiquement les fichiers Dockerfile.jvm (emballage JVM) et Dockerfile.native (emballage binaire natif) nécessaires pour créer des conteneurs.

Enfin, en se concentrant sur Kubernetes en tant qu'environnement de déploiement cible, Quarkus n'utilise pas de frameworks Java dans les cas où des fonctionnalités similaires sont implémentées au niveau de la plateforme Kubernetes elle-même. Le tableau 1 présente une carte de la correspondance fonctionnelle de Kubernetes et des cadres Java typiques utilisés par les développeurs Spring.

Tableau 1. Carte de mappage fonctionnel pour les frameworks Java et Kubernetes.
FonctionnelBotte de printemps traditionnelleKubernetes
Découverte de serviceEurekaDNS
ConfigurationConfiguration de nuage de printempsCartes de configuration / secrets
L'équilibrage de chargeRuban (côté client)Service, Replication Controller (côté serveur)

Compiler et exécuter le code de l'exemple


Dans cet article, nous nous référons à un exemple de projet où les API Spring et MicroProfile et même la même classe Java sont partagées. Le code de cet exemple peut être compilé et exécuté à partir de la ligne de commande, consultez le fichier README.md pour plus de détails.

API Spring Framework


Injection de dépendance


Quarkus prend en charge une variété d' API de contextes et d'injection de dépendances (CDI) et d'API de Spring Dependency Injection (Spring DI). Si vous travaillez avec MicroProfile, Java EE et Jakarta EE , vous connaissez déjà CDI. D'un autre côté, les développeurs Spring peuvent utiliser l'extension Quarkus pour Spring DI API pour assurer la compatibilité avec Spring DI. Des exemples d'utilisation des API Spring DI prises en charge sont donnés dans le tableau 2.

Le projet de notre exemple utilise à la fois CDI et Spring Dependency Injection. Pour plus d'informations et d'exemples sur ce sujet, consultez le Guide Quarkus, appelé Spring DI Guide .

Tableau 2. Exemples d'utilisation des API Spring DI prises en charge.
Fonctions Spring DI prises en charge
Constructor Injection
public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}
Field Injection
Autowired
Value
@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;
Bean
@Configuration
@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}
Component
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}
Service
@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

-


Les utilisateurs de MicroProfile apprécieront Quarkus prenant en charge JAX-RS, MicroProfile Rest Client, JSON-P et JSON-B comme modèle de programmation Web principal. Les développeurs de Spring seront satisfaits de la prise en charge récente de l'API Web Spring dans Quarkus, en particulier des interfaces REST. Comme pour Spring DI, l'objectif principal de la prise en charge de l'API Web Spring est que les développeurs Spring utilisent les API Web Spring avec les API MicroProfile. Des exemples d'utilisation des API Web Spring prises en charge sont donnés dans le Tableau 3, et plus d'informations et d'exemples sur ce sujet peuvent être trouvés dans le Guide Quarkus, appelé Guide Web Spring .

Tableau 3. Exemples d'utilisation des API Web Spring prises en charge.
Fonctionnalités Web Spring prises en chargeExemples
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (partial)
@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

Spring Data JPA


Les utilisateurs de MicroProfile aimeront également que Quarkus prenne en charge JPA à l'aide de Hibernate ORM. Il y a aussi de bonnes nouvelles pour les développeurs Spring: Quarkus prend en charge les annotations courantes et les types JPA Spring Data. Des exemples d'utilisation des API Spring Data JPA prises en charge sont donnés dans le tableau 4.
Dans le projet de notre exemple , les API Spring Data JPA sont utilisées et des informations supplémentaires sont disponibles dans le guide Quarkus appelé Spring Data JPA Guide .

Tableau 4. Exemples d'utilisation des API Spring Data JPA prises en charge.
Fonctionnalités Spring Data JPA prises en chargeExemples
Crudrepository
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Repository
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}
Fragments de référentiel
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Méthodes de requête dérivées
public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}
Requêtes définies par l'utilisateur
public interface MovieRepository
         extends CrudRepository {

    Movie findFirstByOrderByDurationDesc();

    @Query("select m from Movie m where m.rating = ?1")
    Iterator findByRating(String rating);

    @Query("from Movie where title = ?1")
    Movie findByTitle(String title);
}

API- MicroProfile


(Fault tolerance)


Les conceptions de tolérance aux pannes sont essentielles pour éviter les défaillances en cascade et créer des architectures de microservices robustes. Les développeurs de printemps utilisent des disjoncteurs Hystrix pour la tolérance aux pannes depuis des années . Cependant, Hystrix n'a pas été mis à jour depuis longtemps, mais la tolérance aux pannes de MicroProfile se développe activement et a déjà été utilisée pendant plusieurs années en production. Par conséquent, pour augmenter la fiabilité des services dans Quarkus, il est recommandé d'utiliser les API MicroProfile Fault Tolerance, dont des exemples sont donnés dans le tableau 5. Pour plus d'informations à ce sujet, consultez le Guide Quarkus Fault Tolerance .

Tableau 5. Exemples d'utilisation des API de tolérance de panne MicroProfile prises en charge.
Fonctions de tolérance de panne MicroProfileLa descriptionExemples
@Asynchronous

@Asynchronous
@Retry
public Future<String> getSalutation() {
   ...
   return future;
}
@Bulkhead

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}
@CircuitBreaker

@CircuitBreaker(delay=500   // milliseconds
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}
@Fallback

@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}
Retry

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}
Timeout

@Timeout(value = 500 )   // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

(Service Health)


Les plateformes Kubernetes surveillent la santé des conteneurs à l'aide de services spéciaux. Pour que la plate-forme sous-jacente puisse surveiller les services, les développeurs Spring utilisent généralement le HealthIndicator et le Spring Boot Actuator personnalisés. Dans Quarkus, cela peut être fait à l'aide de MicroProfile Health, qui effectue par défaut une vérification de la vivacité, mais peut être configuré pour vérifier simultanément la vivacité et la préparation. Des exemples d'utilisation des API de santé MicroProfile prises en charge sont présentés dans le tableau 6, et plus d'informations sont fournies dans le Guide de santé Quarkus .

Tableau 6. Exemples d'utilisation des API de santé MicroProfile prises en charge.
Fonctionnalités de santé de MicroProfileLa descriptionExemples
@Liveness

Endpoint:
host:8080/health/live
@Liveness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(ready ? true:false)
     .withData("mydata", data)
     .build();  
}
@Readiness

Endpoint:
host:8080/health/ready
@Readiness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(live ? true:false)
     .withData("mydata", data)
     .build();  
}


Les applications fournissent des mesures à des fins opérationnelles (pour contrôler les indicateurs de performance SLA) ou non opérationnelles (indicateurs SLA d'entreprise). Les développeurs Spring fournissent des mesures à l'aide de l'actionneur et du micromètre Spring Boot. À son tour, Quarkus utilise les métriques MicroProfile pour fournir des métriques de base (JVM et système d'exploitation), des métriques de fournisseur (Quarkus) et des métriques d'application. MicroProfile Metrics nécessite que l'implémentation prenne en charge les formats de sortie JSON et OpenMetrics (Prometheus). Des exemples d'utilisation de l'API de métriques MicroProfile sont donnés dans le tableau 7.

Dans le projet de notre exemple, les métriques MicroProfile sont utilisées pour fournir des métriques d'application. Pour plus d'informations, consultez le Guide des métriques Quarkus .

7. API- MicroProfile Metrics.
MicroProfile Metrics
@Counted
counter-,
@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}
@ConcurrentGauge
gauge-,
@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}
@Gauge
gauge-,
@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
@Metered
meter-,
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Metric
, ,
@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Timed
,
@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

Métriques de points de terminaison (métriques points de terminaison)

Métriques hôte local d' application : 8080 / métriques / application Métriques de
base localhost : 8080 / métriques / base Métriques du
fournisseur localhost : 8080 / métriques / fournisseur
Toutes les métriques localhost : 8080 / métriques

Client de repos MicroProfile


Les microservices fournissent souvent des points de terminaison RESTful qui nécessitent des API client appropriées. Pour utiliser les points de terminaison RESTful, les développeurs Spring utilisent généralement un RestTemplate. Quarkus propose également des API MicroProfile Rest Client pour résoudre ce problème, des exemples de leur utilisation sont donnés dans le tableau 8.

Dans le projet de notre exemple, l' utilisation des points de terminaison RESTful est effectuée à l'aide de MicroProfile Rest Client. Pour plus d'informations et d'exemples sur ce sujet, consultez le Guide du client Quarkus Rest .

Tableau 8. Exemples d'utilisation des API client MicroProfile Rest.
Fonctions du client MicroProfile RestLa descriptionExemples
@RegisterRestClient
Enregistre une interface Java typée en tant que client REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}
@RestClient
Marque l'implémentation d'une instance d'une interface client REST typée
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocation
Appelle un point de terminaison REST
System.out.println(
   restClient.getSalutation());
mp-rest / url
Spécifie un point de terminaison REST
application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Sommaire


Dans ce blog, qui est principalement utile aux développeurs Spring, nous avons brièvement examiné comment utiliser les API Spring dans Quarkus avec les API MicroProfile pour développer des microservices Java, puis les compiler en code binaire natif, ce qui économise des centaines de mégaoctets de RAM et démarre en quelques millisecondes.

Comme vous l'avez déjà compris, des informations supplémentaires sur la prise en charge des API Spring et MicroProfile, ainsi qu'une multitude d'autres informations utiles, peuvent être trouvées dans les manuels Quarkus .

All Articles