Quarkus — Java subatomica ipersonica. Panoramica del framework

Introduzione

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

L'obiettivo è rendere Java la piattaforma leader per il deployment su Kubernetes e lo sviluppo di applicazioni serverless, offrendo agli sviluppatori un approccio unificato sia nello sviluppo reattivo che imperativo.

Se consideriamo questo la classificazione dei framework, Quarkus si colloca tra 'Aggregatori / Generatori di codice' e 'Framework fullstack di alto livello'. È più di un aggregatore, ma non raggiunge un full-stack, poiché è orientato allo sviluppo backend.

È promessa un'alta velocità di avvio dell'applicazione e un basso consumo di memoria. Ecco i dati dal 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ò supporre che si tratti di qualche Spring Boot con accessori aggiuntivi.

Hello World!

La più semplice applicazione scritta in Quarkus avrà questo aspetto:

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

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

Questo è letteralmente una sola classe e basta! Puoi avviare l'applicazione usando Maven in modalità sviluppo:

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

La differenza rispetto a un'applicazione abituale è che non esiste la classe Application! Quarkus supporta il hot reload, quindi puoi modificare l'applicazione senza riavviarla, rendendo lo sviluppo ancora più veloce.

Cosa fare dopo? Puoi aggiungere un servizio al controller usando l'annotazione Inject. Il 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!

Nota che in Quarkus vengono utilizzate le annotazioni standard dei framework familiari — CDI e JAX-RS. Non è necessario imparare nulla di nuovo, se hai già lavorato con CDI e JAX-RS, ovviamente.

Lavorare con un database

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

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

Quarkus supporta la memorizzazione nella cache delle entità, delle collezioni per le relazioni uno-a-molti e delle query. A prima vista, sembra fantastico, ma questo è caching locale per un singolo nodo Kubernetes. Cioè, le cache dei nodi diversi non sono sincronizzate tra loro. Spero che sia temporaneo.

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'altra forma.

@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ò essere trasferito nel 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 un endpoint, scritto utilizzando RestAssured, ma è possibile 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, è codice familiare a tutti i programmatori.

Applicazione dipendente dalla piattaforma

Poiché Quarkus è strettamente integrato con GraalVM, è possibile generare codice dipendente dalla piattaforma. Per fare ciò, è necessario installare GraalVM e impostare la variabile di ambiente GRAALVM_HOME. Poi definire un profilo per la compilazione e specificarlo durante la compilazione dell'applicazione:

mvn package -Pnative

È interessante notare che l'applicazione generata può essere testata. Questo è importante poiché l'esecuzione del codice "nativo" può differire dall'esecuzione su JVM. L'annotazione @SubstrateTest avvia il codice dell'applicazione dipendente dalla piattaforma. Il riutilizzo del codice di test esistente può essere effettuato tramite ereditarietà, quindi il codice per testare un'applicazione dipendente dalla piattaforma apparirà in questo modo:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

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

Strumenti

Il framework Quarkus può essere utilizzato con Maven e Gradle. Maven è completamente supportato, a differenza di Gradle. Sfortunatamente, attualmente Gradle non supporta la generazione di un progetto vuoto, ma sul sito è disponibile un dettagliato tutorial.

Estensioni

Quarkus è un framework estensibile. Attualmente ci sono circa 40 estensioni, che aggiungono varie funzionalità — dal supporto per il contenitore DI di Spring e Apache Camel fino al logging e alla pubblicazione delle metriche per i servizi in esecuzione. Esiste già un'estensione per il supporto alla scrittura di applicazioni in linguaggio Kotlin, oltre a Java.

Conclusione

A mio avviso, Quarkus è assolutamente in linea con le tendenze attuali. La sviluppo del codice backend sta diventando sempre più semplice, e questo framework lo semplifica e accelera ulteriormente, offrendo supporto “nativo” per Docker e Kubernetes. Un grande vantaggio è il supporto integrato per GraalVM e la generazione di immagini dipendenti dalla piattaforma, il che consente di creare servizi davvero rapidi nel caricamento e che occupano poco spazio in memoria. Questo è molto importante in un'epoca di crescente interesse per i microservizi e l'architettura serverless.

Sito ufficiale — quarkus.io. Ci sono già esempi di progetti per un avvio rapido su GitHub.

Fonte: habr.com