🥇Quarkus — Java subatomică hipersonică. O scurtă prezentare a framework-ului

Introducere

Pe 7 martie, compania RedHat (în curând — IBM) a prezentat un nou cadru — Quarkus. Potrivit dezvoltatorilor, acest cadru se bazează pe GraalVM și OpenJDK HotSpot și este destinat Kubernetes. Stiva Quarkus include: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus și altele.

Scopul creării este de a face Java o platformă de frunte pentru desfășurarea în Kubernetes și dezvoltarea aplicațiilor serverless, oferind dezvoltatorilor o abordare unificată atât pentru dezvoltarea reactivă, cât și pentru cea imperativă.

Dacă ne uităm la această clasificarea cadrelor, Quarkus se află undeva între „Aggregatorii/Generatorii de cod” și „Cadrele fullstack de nivel înalt”. Este deja mai mult decât un agregator, dar nici nu ajunge până la full-stack, deoarece este optimizat pentru dezvoltarea backend.

Se promite o viteză de pornire foarte mare a aplicației și un consum scăzut de memorie. Iată datele de pe site-ul dezvoltatorului:

Timp de la pornire până la primul răspuns (s):

Configurație
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Stiva Cloud Native tradițională*
4.3
9.5

Consumul de memorie (Mb):

Configurație
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Stiva Cloud Native tradițională*
140
218

Impresionant, nu-i așa?

*Informații despre această stivă de tehnologii nu am găsit, se poate presupune că este un fel de Spring Boot cu accesorii suplimentare..

Hello World!

Cel mai simplu aplicație scrisă pe Quarkus va arăta astfel:

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

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

Este practic o singură clasă și este suficient! Poți porni aplicația folosind Maven în modul de dezvoltare:

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

Diferența față de aplicația obișnuită — nu există clasa Application! Quarkus suportă reîncărcarea rapidă, așa că poți schimba aplicația fără a o reporni, ceea ce face dezvoltarea și mai rapidă.

Ce urmează? Poți adăuga un serviciu în controller folosind notația Inject. Codul serviciului:

@ApplicationScoped
public class GreetingService {

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

Controlerul:

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

Observați că în Quarkus sunt folosite notații standard din cadrele cunoscute — CDI și JAX-RS. Nu este nevoie să înveți nimic nou, dacă ai lucrat cu CDI și JAX-RS înainte, desigur.

Lucrul cu baza de date

Se utilizează Hibernate și standardele JPA pentru entități. Ca și în cazul controlerelor REST, este necesar să scrieți un minim de cod. Este suficient să specificați dependențele în fișierul de construcție și să adăugați adnotările. @Entity și să configurați datasource în application.properties.

Asta e tot. Niciun sessionFactory, persistence.xml și alte fișiere de servicii. Scriem doar codul de care avem nevoie. Totuși, dacă este necesar, se poate crea un fișier persistence.xml și se poate configura DAO-ul mai detaliat.

Quarkus suportă caching pentru entități, colecții pentru relații de tip unul-la-mulți, precum și pentru interogări. La prima vedere, pare grozav, dar este un cache local, pentru un singur nod Kubernetes. Adică, cache-urile diferitelor noduri nu sunt sincronizate între ele. Sper că este temporar.

Executarea asincronă a codului

Așa cum am menționat anterior, Quarkus suportă și stilul de programare reactiv. Codul aplicației anterioare poate fi scris într-o altă formă.

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

Codul asincron poate fi de asemenea mutat într-un serviciu, rezultatul va fi același.

Testare

Testele pentru aplicațiile Quarkus pot fi scrise utilizând JUnit4 sau JUnit5. Mai jos este un exemplu de test pentru endpoint, scris cu ajutorul RestAssured, dar se poate folosi și un alt 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 + "!"));
   }
}

Adnotarea @QuarkusTest indică faptul că aplicația trebuie să fie pornită înainte de a rula testele. În rest, codul este familiar pentru orice dezvoltator.

Aplicație dependentă de platformă

Deoarece Quarkus este strâns integrat cu GraalVM, este posibil să generați cod dependent de platformă. Pentru aceasta, trebuie să instalați GraalVM și să specificați variabila de mediu GRAALVM_HOME. Apoi, trebuie să scrieți un profil pentru construcție și să-l specificați la construirea aplicației:

mvn package -Pnative

Ce este interesant, aplicația generată poate fi testată. Și aceasta este importantă, deoarece executarea codului „nativ” poate diferi de execuția pe JVM. Annotația @SubstrateTest pornește codul dependent de platformă al aplicației. Reutilizarea codului existent pentru teste se poate face prin moștenire, astfel încât codul pentru testarea aplicației dependent de platformă va arăta astfel:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Imaginea generată poate fi împachetată în Docker și rulată în Kubernetes sau OpenShift, detaliile sunt descrise în instrucțiuni.

Instrumentar

Framework-ul Quarkus poate fi folosit cu Maven și Gradle. Maven este complet suportat, spre deosebire de Gradle. Din păcate, în prezent, Gradle nu suportă generarea unui proiect gol, pe site există detalii tutorial.

Extensii

Quarkus este un framework extensibil. În prezent există aproximativ 40 de extensii, care adaugă funcționalități diverse — de la suport pentru containerul Spring DI și Apache Camel până la jurnalizare și publicarea de metrice pentru serviciile active. De asemenea, există deja o extensie pentru suportul dezvoltării aplicațiilor în limbajul Kotlin, pe lângă Java.

Concluzie

În opinia mea, Quarkus se aliniază bine tendințelor actuale. Dezvoltarea codului backend devine din ce în ce mai simplă, iar acest framework simplifică și mai mult și accelerează dezvoltarea serviciilor, adăugând suport „nativ” pentru Docker și Kubernetes. Un mare avantaj — suportul încorporat pentru GraalVM și generarea de imagini dependente de platformă, ceea ce permite crearea de servicii care pornesc cu adevărat rapid și ocupă puțin spațiu în memorie. Și acest lucru este foarte important în vremurile noastre de popularitate a microserviciilor și arhitecturii serverless.

Site-ul oficial — quarkus.io. Exemple de proiecte pentru un start rapid sunt deja disponibile pe GitHub.

Sursa: habr.com