Quarkus – supersonisk subatomär Java. En kort översikt av ramverket

Introduktion

Den 7 mars meddelade företaget RedHat (snart IBM) har presenterat ett nytt ramverk — Quarkus. Enligt utvecklarna bygger detta ramverk på GraalVM och OpenJDK HotSpot och är avsett för Kubernetes. Quarkus-stack inkluderar: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus och andra.

Syftet med skapandet är att göra Java till en ledande plattform för distribution i Kubernetes och utveckling av serverlösa applikationer, genom att ge utvecklare en enhetlig metod för utveckling både i reaktiv och imperativ stil.

Om vi ser på denna klassificeringen av ramverk, är Quarkus någonstans mellan "Aggregators/Code Generators" och "High-level fullstack frameworks". Det är redan mer än en aggregator, men når fortfarande inte upp till fullstack, eftersom det är inriktat på backend-utveckling.

Mycket hög starttid för applikationen och låg minnesförbrukning utlovas. Här är data från utvecklarens webbplats:

Tiden från start till första svar (s):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditionell Cloud Native Stack*
4.3
9.5

Minnesförbrukning (Mb):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditionell Cloud Native Stack*
140
218

Imponerande, eller hur?

*Jag har inte hittat information om denna teknikstack, man kan anta att det är något slags Spring Boot med extra tillägg..

Hello World!

Det enklaste applikationen skriven i Quarkus skulle se ut så här:

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

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

Det är bokstavligen en klass och det räcker! Applikationen kan startas med hjälp av Maven i utvecklingsläge:

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

Skillnaden från vanliga applikationer är – ingen Application-klass! Quarkus stödjer hot reload, så att man kan ändra applikationen utan att starta om den, vilket gör utvecklingen ännu snabbare.

Vad händer härnäst? Man kan lägga till en tjänst i kontrollern med hjälp av annoteringen Inject. Koden för tjänsten:

@ApplicationScoped
public class GreetingService {

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

Kontrollern:

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

Observera att Quarkus använder standardannoteringar från välkända ramverk — CDI och JAX-RS. Det finns inget nytt att lära sig, om du har arbetat med CDI och JAX-RS tidigare, förstås.

Arbete med databas

Hibernate och standard JPA-annoteringar används för entiteter. Precis som med REST-kontroller krävs det minimalt med kod. Det räcker att ange beroenden i byggfilen och lägga till annoteringar. @Entity och konfigurera datakälla i application.properties.

Det är allt. Inga sessionFactory, persistence.xml och andra tjänstefiler. Skriv bara den kod som behövs. Men om det behövs kan du skapa en persistence.xml-fil och konfigurera ORM-lagret mer detaljerat.

Quarkus stödjer caching av entiteter, kollektioner för en-till-många-relationer och även förfrågningar. På ytan ser det bra ut, men det är lokalt caching för en enda Kubernetes-nod. D.v.s. cachar mellan olika noder är inte synkroniserade. Jag hoppas att detta är tillfälligt.

Asynkron kod exekvering

Som redan nämnts stödjer Quarkus också reaktiv programmering. Koden för den tidigare applikationen kan skrivas på ett annat sätt.

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

Asynkron kod kan också flyttas till en tjänst, resultatet blir detsamma.

Testning

Tester för Quarkus-applikationer kan skrivas med JUnit4 eller JUnit5. Här är ett exempel på ett test för endpointen, skrivet med RestAssured, men ett annat ramverk kan användas:

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

Annoteringen @QuarkusTest föreskriver att applikationen ska startas innan testerna körs. I övrigt — bekant kod för alla utvecklare.

Plattformsberoende applikation

Eftersom Quarkus är tätt integrerat med GraalVM kan plattformsberoende kod genereras. För detta krävs att GraalVM installeras och miljövariabeln GRAALVM_HOME anges. Sedan definiera en byggprofil och ange den vid byggandet av applikationen:

mvn package -Pnative

Det som är intressant är att den genererade applikationen kan testas. Detta är viktigt eftersom körningen av "inbyggd" kod kan skilja sig från körningen på JVM. Annotationen @SubstrateTest kör plattformsberoende kod för applikationen. Återanvändning av existerande testkod kan göras med hjälp av arv, vilket gör att koden för att testa plattformsberoende applikationer ser ut så här:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Den genererade bilden kan packas i Docker och köras i Kubernetes eller OpenShift, detaljerat beskrivet i instruktionerna.

Verktygslåda

Ramverket Quarkus kan användas med Maven och Gradle. Maven stöds fullt ut, till skillnad från Gradle. Tyvärr stöder Gradle i nuläget inte skapandet av tomma projekt, det finns detaljerad information på webbplatsen. en handledning.

Tillägg

Quarkus är ett utbyggbart ramverk. För närvarande finns det omkring 40 tillägg, som lägger till olika funktioner - från stöd för Spring DI-container och Apache Camel till loggning och publicering av metrik för aktiva tjänster. Det finns redan ett tillägg för att stödja skapandet av applikationer på språket Kotlin, utöver Java.

Slutsats

Enligt min mening är Quarkus helt i linje med tidens trender. Utvecklingen av backendkod blir allt enklare, och detta ramverk förenklar och påskyndar utvecklingen av tjänster ytterligare, med "inbyggt" stöd för Docker och Kubernetes. En stor fördel är det inbyggda stödet för GraalVM och skapandet av plattformsberoende bilder, vilket gör att tjänster kan starta verkligen snabbt och ta upp lite minne. Detta är mycket viktigt i vår tid av massintresse för mikrotjänster och serverlös arkitektur.

Den officiella webbplatsen - quarkus.io. Exempel på projekt för snabb start finns redan på GitHub.

Källa: habr.com