ProHoster > blogg > administration > Quarkus är en överljudssubatomisk Java. Kort översikt över ramverket

Quarkus är en överljudssubatomisk Java. Kort översikt över ramverket

Quarkus är en överljudssubatomisk Java. Kort översikt över ramverket

Inledning

Den XNUMX mars, RedHat (snart IBM) представила nytt ramverk - quarkus. Enligt utvecklarna är detta ramverk baserat på GraalVM och OpenJDK HotSpot och är designat för Kubernetes. Quarkus-stacken innehåller: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus och andra.

Målet är att göra Java till den ledande plattformen för Kubernetes-distribution och serverlös applikationsutveckling, vilket ger utvecklare en enhetlig strategi för utveckling i både reaktiva och imperativa stilar.

Om man tittar på detta klassificering av ramverk, då ligger Quarkus någonstans mellan "Aggregators/Code Generators" och "High-level fullstack frameworks". Detta är redan mer än en aggregator, men det når inte ens full stack, eftersom... skräddarsydd för backend-utveckling.

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

Tid från start till första svar:

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 hittade ingen information om denna teknikstack, vi kan anta att det här är någon form av Spring Boot med ett extra bodykit.

Hej världen!

Den 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! Du kan köra applikationen med Maven i utvecklingsläge:

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

Skillnaden mot en vanlig applikation är att det inte finns någon applikationsklass! Quarkus stöder hot reload, så att du kan ändra din applikation utan att starta om den, vilket gör utvecklingen ännu snabbare.

Vad kommer härnäst? Du kan lägga till en tjänst till en kontrollenhet med en anteckning Injicera. Servicekod:

@ApplicationScoped
public class GreetingService {

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

Kontroller:

@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 standardkommentarer från bekanta ramverk - CDI och JAX-RS. Det finns ingen anledning att lära sig något nytt om du har arbetat med CDI och JAX-RS tidigare, förstås.

Arbeta med databasen

Viloläge och standard JPA-anteckningar för entiteter används. Som med REST-kontroller måste du skriva ett minimum av kod. Det räcker med att ange beroenden i monteringsfilen, lägg till kommentarer @Entity och konfigurera datakällan i application.properties.

Allt. Inga sessionFactory, persistence.xml eller andra tjänstefiler. Vi skriver bara den kod som behövs. Men om det behövs kan du skapa en persistence.xml-fil och konfigurera ORM-lagret finare.

Quarkus stöder cachning av entiteter, samlingar för en-till-många-relationer och frågor. Vid första anblicken ser det bra ut, men det är det lokal cachning, för en Kubernetes-nod. De där. Cachen för olika noder är inte synkroniserade med varandra. Jag hoppas att detta är tillfälligt.

Asynkron kodexekvering

Som nämnts ovan stöder Quarkus också den reaktiva programmeringsstilen. Koden för den tidigare ansökan kan skrivas i en annan 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 kod kan också överföras till tjänsten, resultatet blir detsamma.

testning

Tester för Quarkus-applikationer kan skrivas i JUnit4 eller JUnit5. Nedan är ett exempeltest för en endpoint, det är 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 + "!"));
   }
}

@QuarkusTest-kommentaren instruerar dig att köra programmet innan du kör tester. Resten är kod bekant för alla utvecklare.

Plattformsspecifik applikation

Eftersom Quarkus är tätt integrerat med GraalVM är det givetvis möjligt att generera plattformsspecifik kod. För att göra detta måste du installera GraalVM och ange miljövariabeln GRAALVM_HOME. Ytterligare registrera en profil för montering och ange det när du bygger programmet:

mvn package -Pnative

Intressant nog kan den genererade applikationen testas. Och detta är viktigt eftersom exekveringen av inbyggd kod kan skilja sig från exekveringen på JVM. @SubstrateTest-kommentaren kör plattformsspecifik applikationskod. Återanvändning av befintlig testkod kan göras med hjälp av arv; som ett resultat kommer koden för att testa en plattformsberoende applikation att se ut så här:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Den genererade bilden kan paketeras i Docker och köras i Kubernetes eller OpenShift, beskrivet i detalj i Avstånd.

Verktyg

Quarkus-ramverket kan användas med Maven och Gradle. Maven stöds fullt ut, till skillnad från Gradle. Tyvärr stöder Gradle för närvarande inte generering av ett tomt projekt, det finns detaljerad information på webbplatsen lärobok.

expansionen

Quarkus är ett utbyggbart ramverk. För närvarande finns en beställning 40 förlängningar, som lägger till olika funktioner - från support Fjäder DI-behållare и Apache kamel innan du loggar och publicerar mätvärden för att köra tjänster. Och det finns redan en tillägg för att stödja skrivapplikationer i Kotlin, förutom Java.

Slutsats

Quarkus är enligt mig ganska i linje med tidens trender. Utveckling av backend-kod blir enklare och enklare, och detta ramverk förenklar och snabbar upp tjänsteutvecklingen ytterligare genom att lägga till inbyggt stöd för Docker och Kubernetes. Ett stort plus är det inbyggda stödet för GraalVM och genereringen av plattformsberoende bilder, vilket gör att tjänster kan starta riktigt snabbt och ta upp lite minnesutrymme. Och detta är mycket viktigt i vår tid av masspassion för mikrotjänster och serverlös arkitektur.

Officiell webbplats - quarkus.io. Exempel på projekt för en snabbstart finns redan på GitHub.

Källa: will.com

Lägg en kommentar