Quarkus — overlyde subatomær Java. Kort oversigt over rammeværket

Introduktion

Den 7. marts annoncerede RedHat (snart IBM) præsenterede den nye rammeværk — Quarkus. Ifølge udviklerne er dette rammeværk bygget på GraalVM og OpenJDK HotSpot og er beregnet til Kubernetes. Quarkus-stack inkluderer: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus og andre.

Målet med oprettelsen er at gøre Java til den førende platform for implementering i Kubernetes og udvikling af serverless-applikationer, ved at give udviklerne en ensartet tilgang til udvikling både i reaktiv og imperativ stil.

Hvis man ser på denne klassifikationen af rammeværk, så ligger Quarkus et sted mellem "Aggregators/Code Generators" og "High-level fullstack frameworks". Det er mere end en aggregator, men når ikke op til full-stack, da det er tilpasset til backend-udvikling.

En meget høj opstartshastighed og lavt hukommelsesforbrug er lovet. Her er data fra udviklerens hjemmeside:

Tid fra start til første svar (s):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditionel Cloud Native Stack*
4.3
9.5

Hukommelsesforbrug (Mb):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditionel Cloud Native Stack*
140
218

Imponerende, ikke?

*Jeg fandt ikke informationer om denne teknologistack, man kan formode, at det er en slags Spring Boot med ekstra funktioner..

Hello World!

Det simpleste program skrevet i Quarkus vil se sådan ud:

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

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

Det er bogstaveligt talt én klasse, og det er nok! Man kan starte applikationen med Maven i udviklingstilstand:

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

Forskellen fra den sædvanlige applikation er, at der ikke er en Application-klasse! Quarkus understøtter hot reload, så man kan ændre applikationen uden at genstarte den, hvilket gør udviklingen hurtigere.

Hvad nu? Man kan tilføje en service til controlleren ved hjælp af annotationen Injection. Servicens kode:

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

Bemærk, at der i Quarkus anvendes standardannotationer fra velkendte rammeværk — CDI og JAX-RS. Man skal ikke lære noget nyt, hvis man har arbejdet med CDI og JAX-RS før, selvfølgelig.

Arbejder med databasen

Hibernate og standard JPA-annoteringer bruges til entiteter. Ligesom med REST-controllere er det nødvendigt at skrive minimum kode. Det er tilstrækkeligt at angive afhængigheder i build-filen og placere annoteringerne. @Entity og konfigurere datasource i application.properties.

Det er alt. Ingen sessionFactory, persistence.xml eller andre servicefiler. Vi skriver kun den nødvendige kode. Hvis nødvendigt, kan man dog oprette en persistence.xml-fil og konfigurere ORM-laget mere detaljeret.

Quarkus understøtter caching af entiteter, kollektioner til en-til-mange-forhold samt forespørgsler. Det ser godt ud ved første øjekast, men dette er lokalt cache, for en enkelt Kubernetes-node. Det vil sige, at caches fra forskellige noder ikke er synkroniseret med hinanden. Jeg håber, det er midlertidigt.

Asynkron udførelse af kode

Som nævnt ovenfor understøtter Quarkus også reaktiv programmeringsstil. Koden fra den forrige applikation kan skrives på en anden måde.

@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 kode kan også flyttes til en service, resultatet vil være det samme.

Testning

Tests for Quarkus-applikationer kan skrives med JUnit4 eller JUnit5. Nedenfor er et eksempel på en test for endpointet, det er skrevet med RestAssured, men man kan også bruge en anden ramme:

@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 kræver, at applikationen startes, før testene køres. Ellers er koden bekendt for alle udviklere.

Platformafhængig applikation

Da Quarkus er tæt integreret med GraalVM, kan man naturligvis generere platformafhængig kode. For at gøre dette skal man installere GraalVM og angive miljøvariablen GRAALVM_HOME. Derefter definerer man en profil for build og angiver den under bygningen af applikationen:

mvn package -Pnative

Interessant nok kan den genererede applikation testes. Dette er vigtigt, da udførelsen af den "native" kode kan afvige fra udførelsen på JVM. Annotationen @SubstrateTest kører platformafhængig kode i applikationen. Genbrug af eksisterende testkode kan gøres ved hjælp af arv, så koden til testning af den platformafhængige applikation vil se sådan ud:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Den genererede billede kan pakkes i Docker og køres i Kubernetes eller OpenShift, som beskrevet i vejledningen.

Værktøjer

Quarkus-rammen kan anvendes med Maven og Gradle. Maven understøttes fuldt, i modsætning til Gradle. Desværre understøtter Gradle på nuværende tidspunkt ikke generering af et tomt projekt, der er detaljeret beskrevet på hjemmesiden. håndbogen.

Udvidelser

Quarkus er en udvidelig ramme. På nuværende tidspunkt findes der cirka 40 udvidelser, som tilføjer forskellig funktionalitet - fra understøttelse af Spring DI-containeren og Apache Camel til logføring og publicering af metric for de kørende tjenester. Og der findes allerede en udvidelse til støtte for at skrive applikationer i Kotlin, ud over Java.

Konklusion

Efter min mening er Quarkus absolut i tråd med tidens tendenser. Udviklingen af backend-koden bliver enklere og enklere, og denne ramme gør det endnu lettere og hurtigere at udvikle tjenester, idet den tilføjer "native" understøttelse af Docker og Kubernetes. En stor fordel er den indbyggede støtte til GraalVM og generation af platformafhængige billeder, hvilket gør det muligt at skabe tjenester, der virkelig starter hurtigt op og fylder lidt i hukommelsen. Dette er meget vigtigt i vores tid med massivt fokus på mikrotjenester og serverless-arkitektur.

Den officielle hjemmeside - quarkus.io. Eksempler på projekter til hurtig start findes allerede på GitHub.

Kilde: habr.com