Quarkus er en supersonisk subatomisk Java. Kort oversigt over rammerne

Indledning

Den XNUMX. marts, RedHat (snart IBM) fremlagde nye rammer - kvarkus. Ifølge udviklerne er denne ramme baseret på GraalVM og OpenJDK HotSpot og er designet til Kubernetes. Quarkus-stakken inkluderer: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus og andre.

Målet er at gøre Java til den førende platform for Kubernetes-implementering og serverløs applikationsudvikling, hvilket giver udviklere en samlet tilgang til udvikling i både reaktive og imperative stilarter.

Hvis man ser på dette klassificering af rammer, så er Quarkus et sted mellem "Aggregators/Code Generators" og "High-level fullstack frameworks". Dette er allerede mere end en aggregator, men det når ikke engang fuld stack, fordi... skræddersyet til backend-udvikling.

Meget høj hastighed af applikationslanceringen og lavt hukommelsesforbrug er lovet. Her er dataene fra udviklerens websted:

Tid fra start til første svar:

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 ingen information om denne teknologistak, vi kan antage, at dette er en slags fjederstøvle med et ekstra kropssæt.

Hej Verden!

Den enkleste applikation skrevet i Quarkus ville 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! Du kan køre applikationen ved hjælp af Maven i udviklingstilstand:

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

Forskellen fra en almindelig applikation er, at der ikke er nogen applikationsklasse! Quarkus understøtter hot reload, så du kan ændre din applikation uden at genstarte den, hvilket gør udviklingen endnu hurtigere.

Hvad er det næste? Du kan tilføje en tjeneste til en controller ved hjælp af en annotering Indsprøjte. Servicekode:

@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 Quarkus bruger standardannotationer fra velkendte rammer - CDI og JAX-RS. Der er ingen grund til at lære noget nyt, hvis du har arbejdet med CDI og JAX-RS før, selvfølgelig.

Arbejde med databasen

Dvale- og standard JPA-annoteringer for enheder bruges. Som med REST-controllere skal du skrive et minimum af kode. Det er nok at angive afhængighederne i assembly-filen, tilføje anmærkninger @Entity og konfigurer datakilde i application.properties.

Alle. Ingen sessionFactory, persistence.xml eller andre servicefiler. Vi skriver kun den kode, der er nødvendig. Men hvis det er nødvendigt, kan du oprette en persistence.xml-fil og konfigurere ORM-laget mere fint.

Quarkus understøtter caching af entiteter, samlinger til en-til-mange-relationer og forespørgsler. Ved første øjekast ser det godt ud, men det er det lokal caching for én Kubernetes-node. De der. Cachen for forskellige noder er ikke synkroniseret med hinanden. Jeg håber, det er midlertidigt.

Asynkron kodeudførelse

Som nævnt ovenfor understøtter Quarkus også den reaktive programmeringsstil. Koden for den tidligere ansøgning kan skrives i en anden form.

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

Asynkron kode kan også overføres til tjenesten, resultatet bliver det samme.

Test

Tests til Quarkus-applikationer kan skrives i JUnit4 eller JUnit5. Nedenfor er en eksempeltest for et slutpunkt, den er skrevet ved hjælp af RestAssured, men en anden ramme kan bruges:

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

@QuarkusTest-annotationen instruerer dig i at køre programmet, før du kører test. Resten er kode, som alle udviklere kender.

Platformspecifik applikation

Da Quarkus er tæt integreret med GraalVM, er det naturligvis muligt at generere platformsspecifik kode. For at gøre dette skal du installere GraalVM og angive miljøvariablen GRAALVM_HOME. Yderligere registrere en profil til montering og angiv det, når du bygger applikationen:

mvn package -Pnative

Interessant nok kan den genererede applikation testes. Og dette er vigtigt, fordi udførelsen af ​​native kode kan afvige fra kørsel på JVM. @SubstrateTest-annotationen kører platformsspecifik applikationskode. Genbrug af eksisterende testkode kan udføres ved hjælp af arv; Som et resultat vil koden til test af en platformsafhængig applikation se sådan ud:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Det genererede billede kan pakkes i Docker og køres i Kubernetes eller OpenShift, beskrevet detaljeret i Kørselsvejledning.

værktøjer

Quarkus-rammen kan bruges med Maven og Gradle. Maven er fuldt understøttet, i modsætning til Gradle. Desværre understøtter Gradle i øjeblikket ikke generering af et tomt projekt; der er detaljeret information på hjemmesiden lærebog.

ekspansion

Quarkus er en udvidelsesbar ramme. I øjeblikket er der en ordre 40 udvidelser, som tilføjer forskellige funktioner - fra support Fjeder DI beholder и Apache kamel før logning og publicering af metrics for kørende tjenester. Og der er allerede en udvidelse til at understøtte skrivning af applikationer i Kotlin, ud over Java.

Konklusion

Quarkus er efter min mening ganske på linje med tidens tendenser. Udvikling af backend-kode bliver nemmere og nemmere, og denne ramme forenkler og fremskynder yderligere serviceudvikling ved at tilføje native support til Docker og Kubernetes. Et kæmpe plus er den indbyggede understøttelse af GraalVM og genereringen af ​​platformafhængige billeder, som gør det muligt for tjenester at starte rigtig hurtigt og optage lidt hukommelsesplads. Og dette er meget vigtigt i vores tid med masse passion for mikrotjenester og serverløs arkitektur.

Officiel side - quarkus.io. Eksempler på projekter til en hurtig start er allerede tilgængelige på GitHub.

Kilde: www.habr.com