🥇Quarkus — Java subsonique et subatomique. Bref aperçu du framework

Introduction

Le 7 mars, la société RedHat (bientôt IBM) présentée un nouveau framework — Quarkus. Selon les développeurs, ce framework est basé sur GraalVM et OpenJDK HotSpot et est conçu pour Kubernetes. La stack Quarkus comprend : JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus et d'autres.

L'objectif de sa création est de faire de Java la plateforme leader pour le déploiement sur Kubernetes et le développement d'applications sans serveur, en fournissant aux développeurs une approche unifiée pour le développement à la fois réactif et impératif.

Si l'on regarde la cet classification des frameworks, Quarkus se situe quelque part entre « Agrégateurs/Générateurs de code » et « Frameworks full-stack de haut niveau ». C'est déjà plus qu'un agrégateur, mais cela ne frôle pas encore le full-stack, car il est taillé pour le développement backend.

Une très haute vitesse de démarrage de l'application et une faible consommation de mémoire sont promises. Voici les données du site des développeurs :

Temps entre le démarrage et la première réponse (s) :

Configuration
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Stack Cloud Native Traditionnel*
4.3
9.5

Consommation mémoire (Mo) :

Configuration
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Stack Cloud Native Traditionnel*
140
218

Impressionnant, n'est-ce pas ?

*Je n'ai pas trouvé d'informations sur ce stack technologique, on peut supposer qu'il s'agit de Spring Boot avec un peu plus de compléments..

Hello World!

La plus simple des applications écrites en Quarkus ressemblera à cela :

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   public String hello() {
       return "hello";
   }
}

C'est littéralement une seule classe et c'est suffisant ! Vous pouvez lancer l'application avec Maven en mode développement :

mvn compile quarkus:dev
…
$ curl http://localhost:8080/hello
hello

La différence avec une application habituelle — il n'y a pas de classe Application ! Quarkus prend en charge le hot reload, ce qui permet de modifier l'application sans la redémarrer, rendant ainsi le développement encore plus rapide.

Et ensuite ? Vous pouvez ajouter un service au contrôleur avec l'annotation Inject. Le code du service :

@ApplicationScoped
public class GreetingService {

   public String greeting(String name) {
       return "Hello " + name + "!";
   }
}

Contrôleur :

@Path("/hello")
public class GreetingResource {

   @Inject
   GreetingService service;

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public String greeting(@PathParam("name") String name) {
       return service.greeting(name);
   }
}

$ curl http://localhost:8080/hello/developer
Hello developer!

Notez que dans Quarkus, les annotations standards des frameworks familiers — CDI et JAX-RS — sont utilisées. Rien de nouveau à apprendre si vous avez déjà travaillé avec CDI et JAX-RS, bien sûr.

Travailler avec une base de données

Hibernate et les annotations JPA standard sont utilisés pour les entités. Comme pour les contrôleurs REST, il est nécessaire d'écrire un minimum de code. Il suffit de spécifier les dépendances dans le fichier de build et de disposer les annotations. @Entity et de configurer le datasource dans application.properties.

C'est tout. Aucun sessionFactory, persistence.xml ou autre fichier de service. Nous écrivons uniquement le code nécessaire. Cependant, si nécessaire, il est possible de créer un fichier persistence.xml et de configurer plus finement la couche ORM.

Quarkus prend en charge la mise en cache des entités, des collections pour les relations un-à-plusieurs, ainsi que des requêtes. À première vue, cela semble formidable, mais c'est le cache local, pour un seul nœud Kubernetes. C'est-à-dire que les caches entre différents nœuds ne sont pas synchronisés. J'espère que c'est temporaire.

Exécution asynchrone du code

Comme mentionné précédemment, Quarkus prend également en charge le style de programmation réactif. Le code de l'application précédente peut être écrit d'une autre manière.

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public CompletionStage greeting(@PathParam("name") String name) {
       return CompletableFuture.supplyAsync(() -> {
           return "Hello " + name + "!";
       });
   }
}

Le code asynchrone peut également être transféré dans un service, le résultat sera le même.

Test

Les tests pour les applications Quarkus peuvent être écrits avec JUnit4 ou JUnit5. Ci-dessous un exemple de test pour un endpoint, écrit à l'aide de RestAssured, mais il est également possible d'utiliser un autre cadre :

@QuarkusTest
public class GreetingResourceTest {

   @Test
   public void testGreetingEndpoint() {
       String uuid = UUID.randomUUID().toString();
       given()
         .pathParam("name", uuid)
         .when().get("/hello/{name}")
         .then()
           .statusCode(200)
           .body(is("Hello " + uuid + "!"));
   }
}

L'annotation @QuarkusTest exige que l'application soit lancée avant d'exécuter les tests. Pour le reste, c'est du code familier à tous les développeurs.

Application dépendante de la plateforme

Comme Quarkus est étroitement intégré à GraalVM, il est bien sûr possible de générer du code dépendant de la plateforme. Pour cela, il faut installer GraalVM et indiquer la variable d'environnement GRAALVM_HOME. Ensuite, définir un profil pour la construction et le spécifier lors de la construction de l'application :

mvn package -Pnative

Ce qui est intéressant, c'est que l'application générée peut être testée. Et c'est important, car l'exécution du code « natif » peut différer de l'exécution sur la JVM. L'annotation @SubstrateTest exécute le code de l'application dépendant de la plateforme. La réutilisation du code de test existant peut se faire par héritage, et le code pour tester une application dépendante de la plateforme ressemblera à ceci :

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

L'image générée peut être empaquetée dans Docker et exécutée dans Kubernetes ou OpenShift, comme décrit en détail dans des instructions.

Outils

Le framework Quarkus peut être utilisé avec Maven et Gradle. Maven est entièrement pris en charge, contrairement à Gradle. Malheureusement, à l'heure actuelle, Gradle ne prend pas en charge la génération de projet vide, des détails sont disponibles sur le site. tutoriel.

Extensions

Quarkus est un framework extensible. Actuellement, il existe environ 40 extensions, qui ajoutent diverses fonctionnalités — du support de Spring DI container et Apache Camel à la journalisation et à la publication de métriques pour les services en cours d'exécution. Une extension existe déjà pour le support du développement d'applications en Kotlin, en plus de Java.

Conclusion

À mon avis, Quarkus est tout à fait dans l'air du temps. Le développement du code backend devient de plus en plus simple, et ce framework facilite encore plus et accélère le développement des services, ajoutant un support « natif » pour Docker et Kubernetes. Un grand avantage — le support intégré de GraalVM et la génération d'images dépendantes de la plateforme, ce qui permet de créer des services à réellement démarrage rapide et occupant peu d'espace en mémoire. Cela est très important à notre époque où les microservices et l'architecture serverless sont en plein essor.

Site officiel — quarkus.io. Des exemples de projets pour un démarrage rapide sont déjà disponibles sur GitHub.

Source : habr.com

Quarkus est un Java subsonique. Un aperçu rapide du framework