Quarkus è un Java subatomico supersonico. Breve panoramica del quadro

Introduzione

Il XNUMX marzo RedHat (presto IBM) presentato nuovo quadro - Quarkù. Secondo gli sviluppatori, questo framework si basa 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 è rendere Java la piattaforma leader per la distribuzione Kubernetes e lo sviluppo di applicazioni serverless, fornendo agli sviluppatori un approccio unificato allo sviluppo sia in stile reattivo che imperativo.

Se guardi questo classificazione dei framework, allora Quarkus si trova a metà strada tra “Aggregatori/Generatori di codice” e “Framework fullstack di alto livello”. Questo è già più di un aggregatore, ma non raggiunge nemmeno il full-stack, perché... su misura per lo sviluppo backend.

Si promette una velocità molto elevata di avvio delle applicazioni e un basso consumo di memoria. Ecco i dati dal sito web dello sviluppatore:

Tempo dall'inizio alla prima risposta (s):

Configurazione
REST
RESTO+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Stack nativo del cloud tradizionale*
4.3
9.5

Consumo di memoria (Mb):

Configurazione
REST
RESTO+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Stack nativo del cloud tradizionale*
140
218

Impressionante, non è vero?

*Non ho trovato alcuna informazione su questo stack tecnologico, possiamo supporre che si tratti di una sorta di Spring Boot con un body kit aggiuntivo.

Ciao mondo!

L'applicazione più semplice scritta in Quarkus sarebbe simile a questa:

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

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

È letteralmente una lezione e basta! È possibile eseguire l'applicazione utilizzando Maven in modalità sviluppo:

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

La differenza rispetto ad un'applicazione normale è che non esiste una classe Applicazione! Quarkus supporta il ricaricamento a caldo, quindi puoi modificare la tua applicazione senza riavviarla, rendendo lo sviluppo ancora più veloce.

Qual è il prossimo? È possibile aggiungere un servizio a un controller utilizzando un'annotazione iniettare. Codice servizio:

@ApplicationScoped
public class GreetingService {

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

Controllore:

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

Tieni presente che Quarkus utilizza annotazioni standard da framework familiari: CDI e JAX-RS. Naturalmente non è necessario imparare nulla di nuovo se hai già lavorato con CDI e JAX-RS.

Lavorare con il database

Vengono utilizzate le annotazioni JPA ibernate e standard per le entità. Come con i controller REST, è necessario scrivere un minimo di codice. È sufficiente indicare le dipendenze nel file di assembly, aggiungere annotazioni @Entity e configurare l'origine dati in application.properties.

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

Quarkus supporta la memorizzazione nella cache di entità, raccolte per relazioni uno-a-molti e query. A prima vista sembra fantastico, ma lo è locale memorizzazione nella cache, per un nodo Kubernetes. Quelli. Le cache dei diversi nodi non sono sincronizzate tra loro. Spero che questo sia temporaneo.

Esecuzione di codice asincrono

Come accennato in precedenza, Quarkus supporta anche lo stile di programmazione reattivo. Il codice dell'applicazione precedente può essere scritto in una forma diversa.

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

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

È anche possibile trasferire al servizio il codice asincrono, il risultato sarà lo stesso.

Test

I test per le applicazioni Quarkus possono essere scritti in JUnit4 o JUnit5. Di seguito è riportato un esempio di test per un endpoint, scritto utilizzando RestAssured, ma è possibile utilizzare 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 indica di eseguire l'applicazione prima di eseguire i test. Il resto è codice familiare a tutti gli sviluppatori.

Applicazione specifica della piattaforma

Poiché Quarkus è strettamente integrato con GraalVM, è ovviamente possibile generare codice specifico per la piattaforma. Per fare ciò, è necessario installare GraalVM e specificare la variabile d'ambiente GRAALVM_HOME. Ulteriore registrare un profilo per l'assemblaggio e specificarlo durante la creazione dell'applicazione:

mvn package -Pnative

È interessante notare che l'applicazione generata può essere testata. E questo è importante perché l'esecuzione del codice nativo potrebbe differire dall'esecuzione sulla JVM. L'annotazione @SubstrateTest esegue il codice dell'applicazione specifico della piattaforma. È possibile riutilizzare il codice di test esistente utilizzando l'ereditarietà; di conseguenza, il codice per testare un'applicazione dipendente dalla piattaforma sarà simile al seguente:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

L'immagine generata può essere impacchettata in Docker ed eseguita in Kubernetes o OpenShift, descritto in dettaglio in istruzione.

strumenti

Il framework Quarkus può essere utilizzato con Maven e Gradle. Maven è completamente supportato, a differenza di Gradle. Sfortunatamente, al momento Gradle non supporta la generazione di un progetto vuoto; ci sono informazioni dettagliate sul sito web manuale.

espansione

Quarkus è un framework estensibile. Attualmente c'è un ordine 40 estensioni, che aggiungono varie funzionalità, dal supporto Contenitore DI a molla и Cammello Apache prima di registrare e pubblicare parametri per l'esecuzione dei servizi. Ed esiste già un'estensione per supportare la scrittura di applicazioni in Kotlin, oltre a Java.

conclusione

Secondo me Quarkus è abbastanza in linea con le tendenze del momento. 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 enorme vantaggio è il supporto integrato per GraalVM e la generazione di immagini dipendenti dalla piattaforma, che consente ai servizi di avviarsi molto rapidamente e di occupare poco spazio di memoria. E questo è molto importante nel nostro tempo di passione di massa per i microservizi e l’architettura serverless.

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

Fonte: habr.com