Quarkus — Java subatomica supersonica. Breve panoramica del framework

Introduzione

Il sette marzo l'azienda RedHat (presto sarà IBM) ha presentato nuovo framework — Quarkus. Secondo gli sviluppatori, questo framework è basato su GraalVM e OpenJDK HotSpot ed è progettato per Kubernetes. Lo stack Quarkus include: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus e altri.

L'obiettivo della creazione è rendere Java la piattaforma leader per il deploy su Kubernetes e lo sviluppo di applicazioni serverless, fornendo agli sviluppatori un approccio unificato allo sviluppo sia in stile reattivo che imperativo.

Se guardiamo a questa la classificazione dei framework, Quarkus si colloca tra "Aggregatori/Generatori di Codice" e "Framework fullstack di alto livello". È già più di un aggregatore, ma non raggiunge il full-stack, poiché è orientato allo sviluppo backend.

È promessa un'alta velocità di avvio dell'applicazione e un basso consumo di memoria. Ecco i dati del sito dello sviluppatore:

Tempo dall'avvio alla prima risposta (s):

Configurazione
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditional Cloud Native Stack*
4.3
9.5

Consumo di memoria (Mb):

Configurazione
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditional Cloud Native Stack*
140
218

Impressionante, vero?

*Non ho trovato informazioni su questo stack tecnologico; si può ipotizzare che sia un qualche Spring Boot con un'aggiunta..

Hello World!

La più semplice delle applicazioni scritte in Quarkus apparirà così:

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

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

Questo è letteralmente un solo classe ed è sufficiente! È possibile avviare l'applicazione usando Maven in modalità di sviluppo:

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

La differenza rispetto all'applicazione consueta è che non c'è la classe Application! Quarkus supporta il hot reload, così si possono apportare modifiche all'applicazione senza riavviarla, rendendo così lo sviluppo ancora più veloce.

Cosa c'è dopo? Si può aggiungere un servizio al controller utilizzando l'annotazione Inject. Codice del servizio:

@ApplicationScoped
public class GreetingService {

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

Controller:

@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!

Si noti che in Quarkus si utilizzano annotazioni standard da framework familiari — CDI e JAX-RS. Non c'è nulla di nuovo da imparare, se si è già lavorato con CDI e JAX-RS prima, ovviamente.

Lavorare con il database

Si utilizza Hibernate e annotazioni JPA standard per le entità. Come nel caso dei controller REST, è necessario scrivere il minimo codice. È sufficiente specificare le dipendenze nel file di build, posizionare le annotazioni @Entity e configurare il datasource in application.properties.

Tutto. Niente sessionFactory, persistence.xml e altri file di servizio. Scriviamo solo il codice necessario. Tuttavia, se necessario, è possibile creare un file persistence.xml e configurare più nel dettaglio il livello ORM.

Quarkus supporta la cache delle entità, delle raccolte per relazioni uno-a-molti, così come delle query. A prima vista, sembra fantastico, ma è cache locale per un singolo nodo Kubernetes. Cioè, le cache dei diversi nodi non sono sincronizzate tra loro. Spero che sia temporaneamente.

Esecuzione asincrona del codice

Come detto sopra, Quarkus supporta anche lo stile di programmazione reattivo. Il codice dell'applicazione precedente può essere scritto in un modo diverso.

@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 + "!";
       });
   }
}

Il codice asincrono può anche essere spostato in un servizio, il risultato sarà lo stesso.

Test

I test per le applicazioni Quarkus possono essere scritti con JUnit4 o JUnit5. Di seguito è riportato un esempio di test per l'endpoint, scritto utilizzando RestAssured, ma si può utilizzare anche un altro framework:

@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'annotazione @QuarkusTest richiede di avviare l'applicazione prima di eseguire i test. Per il resto, è un codice familiare a tutti i programmatori.

Applicazione dipendente dalla piattaforma

Poiché Quarkus è strettamente integrato con GraalVM, è possibile generare codice dipendente dalla piattaforma. Per fare questo, è necessario installare GraalVM e specificare la variabile d'ambiente GRAALVM_HOME. Poi scrivere un profilo per la build e specificarlo durante la build dell'applicazione:

mvn package -Pnative

È interessante notare che l'applicazione generata può essere testata. Ed è importante, poiché l'esecuzione del codice "nativo" può differire dall'esecuzione sulla JVM. L'annotazione @SubstrateTest esegue il codice specifico della piattaforma dell'applicazione. Il riutilizzo del codice test esistente può essere effettuato tramite l'ereditarietà, quindi il codice per il test dell'applicazione specifica della piattaforma apparirà così:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

L'immagine generata può essere impacchettata in Docker e avviata in Kubernetes o OpenShift, descritto in dettaglio in guida.

Strumenti

Il framework Quarkus può essere utilizzato con Maven e Gradle. Maven è supportato pienamente, a differenza di Gradle. Sfortunatamente, al momento attuale Gradle non supporta la generazione di un progetto vuoto; sul sito ci sono dettagliati un tutorial.

Estensioni

Quarkus è un framework estensibile. Attualmente ci sono circa 40 estensioni, che aggiungono diverse funzionalità - dal supporto per il contenitore DI di Spring e Apache Camel fino alla registrazione e pubblicazione di metriche per servizi in esecuzione. Esiste già un'estensione per supportare la scrittura di applicazioni nel linguaggio Kotlin, oltre che in Java.

Conclusione

A mio avviso, Quarkus è decisamente in linea con le tendenze attuali. Lo sviluppo del codice backend sta diventando sempre più semplice, e questo framework semplifica e accelera ulteriormente lo sviluppo dei servizi, aggiungendo il supporto "nativo" per Docker e Kubernetes. Un grande vantaggio è il supporto integrato per GraalVM e la generazione di immagini specifiche della piattaforma, il che consente di creare servizi rapidamente avviabili e che occupano poco spazio in memoria. Questo è molto importante al giorno d'oggi, in un'epoca di forte interesse per i microservizi e l'architettura serverless.

Sito ufficiale - quarkus.io. Esempi di progetti per un avvio veloce sono già disponibili su GitHub.

Fonte: habr.com