🥇Quarkus - supersnelle subatomische Java. Korte samenvatting van het framework

Inleiding

Op 7 maart heeft RedHat (binnenkort IBM) heeft geïntroduceerd een nieuw framework — Quarkus. Volgens de ontwikkelaars is dit framework gebaseerd op GraalVM en OpenJDK HotSpot en is het bedoeld voor Kubernetes. De Quarkus-stack bevat: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus en anderen.

Het doel van de creatie is om Java het leidende platform te maken voor implementatie in Kubernetes en de ontwikkeling van serverless applicaties, waarbij ontwikkelaars een uniforme aanpak krijgen voor de ontwikkeling in zowel reactieve als imperatieve stijl.

Als we kijken naar deze de classificatie van frameworks, dan bevindt Quarkus zich ergens tussen 'Aggregators/Code Generators' en 'High-level fullstack frameworks'. Het is al meer dan een aggregator, maar het haalt de full-stack niet, aangezien het is gericht op backend-ontwikkeling.

Een zeer hoge opstartsnelheid van de applicatie en een laag geheugengebruik worden beloofd. Hier zijn de gegevens van de ontwikkelaarswebsite:

Tijd van start tot het eerste antwoord (s):

Configuratie
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditionele Cloud Native Stack*
4.3
9.5

Geheugenverbruik (Mb):

Configuratie
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditionele Cloud Native Stack*
140
218

Indrukwekkend, nietwaar?

*Ik heb geen informatie over deze technologie-stack gevonden, dus ik neem aan dat het een soort Spring Boot met extra uitbreiding is..

4) Ga vanuit de map waar je de voorbeeldcode hebt gedownload naar de map die bevat

De eenvoudigste applicatie geschreven in Quarkus zou er als volgt uitzien:

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

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

Dit is letterlijk één klasse en dat is genoeg! Je kunt de applicatie starten met Maven in ontwikkelingsmodus:

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

Het verschil met een gebruikelijke applicatie is dat er geen Application-klasse is! Quarkus ondersteunt hot reload, zodat je de applicatie kunt wijzigen zonder deze opnieuw op te starten, waardoor de ontwikkeling nog sneller wordt.

Wat nu? Je kunt een service aan de controller toevoegen met behulp van de annotatie Inject. De code van de service:

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

Let op dat Quarkus standaardannotaties uit bekende frameworks gebruikt — CDI en JAX-RS. Je hoeft niets nieuws te leren, als je eerder met CDI en JAX-RS hebt gewerkt, natuurlijk.

Werken met databases

Hibernate en standaard JPA-annotaties worden gebruikt voor entiteiten. Net als bij REST-controllers is het nodig om minimaal code te schrijven. Het is voldoende om de afhankelijkheden in het buildbestand op te geven en annotaties toe te voegen. @Entity en de datasource in application.properties te configureren.

Dat is alles. Geen sessionFactory, persistence.xml en andere servicebestanden. We schrijven alleen de code die nodig is. Indien nodig kan er echter een persistence.xml-bestand worden gemaakt om de ORM-laag gedetailleerder te configureren.

Quarkus ondersteunt het cachen van entiteiten, collecties voor één-op-veel relaties en ook van verzoeken. Op het eerste gezicht lijkt het geweldig, maar dit is lokale caching, voor één Kubernetes-knooppunt. Dat wil zeggen, de caches van verschillende knooppunten zijn niet met elkaar gesynchroniseerd. Ik hoop dat dit tijdelijk is.

Asynchrone uitvoering van code

Zoals eerder vermeld, ondersteunt Quarkus ook een reactieve programmeerstijl. De code van de vorige applicatie kan op een andere manier worden geschreven.

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

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public CompletionStage greeting(@PathParam("name") String name) {
       return CompletableFuture.supplyAsync(() -> {
           return "Hallo " + name + "!";
       });
   }
}

Asynchrone code kan ook naar een service worden overgebracht; het resultaat zal hetzelfde zijn.

Testen

Tests voor Quarkus-applicaties kunnen worden geschreven met JUnit4 of JUnit5. Hieronder volgt een voorbeeld van een test voor een endpoint, deze is geschreven met behulp van RestAssured, maar een andere framework kan ook worden gebruikt:

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

De annotatie @QuarkusTest geeft aan dat de applicatie moet worden gestart voordat de tests worden uitgevoerd. Verder is de code vertrouwd voor alle ontwikkelaars.

Platformafhankelijke applicatie

Aangezien Quarkus nauw is geïntegreerd met GraalVM, is het natuurlijk mogelijk om platformafhankelijke code te genereren. Hiervoor moet GraalVM worden geïnstalleerd en moet de omgevingsvariabele GRAALVM_HOME worden opgegeven. Vervolgens moet je een profiel voor de build opgeven en dit opgeven tijdens het bouwen van de applicatie:

mvn package -Pnative

Interessant is dat de gegenereerde applicatie getest kan worden. Dit is belangrijk omdat de uitvoering van 'natuurlijke' code kan verschillen van de uitvoering op de JVM. De annotatie @SubstrateTest voert platformafhankelijke code van de applicatie uit. Hergebruik van bestaande testcode kan worden bereikt via overerving, waardoor de code voor het testen van de platformafhankelijke applicatie er als volgt uitziet:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Het gegenereerde image kan worden verpakt in Docker en uitgevoerd in Kubernetes of OpenShift, dit is in detail beschreven in handleiding,.

Toolkit

Het Quarkus-framework kan worden gebruikt met Maven en Gradle. Maven wordt volledig ondersteund, in tegenstelling tot Gradle. Helaas ondersteunt Gradle op dit moment de generatie van een leeg project niet, er zijn gedetailleerde informatie op de website. een handleiding.

Extensies

Quarkus is een uitbreidbaar framework. Momenteel zijn er ongeveer 40 uitbreidingen, die verschillende functionaliteiten toevoegen - van ondersteuning voor Spring DI-container en Apache Camel tot logging en het publiceren van metrics voor werkende services. Er bestaat zelfs al een uitbreiding voor ondersteuning van het schrijven van applicaties in Kotlin, naast Java.

Conclusie

Naar mijn mening ligt Quarkus helemaal in de lijn der verwachtingen. Het ontwikkelen van backend-code wordt steeds eenvoudiger, en dit framework vereenvoudigt en versnelt de ontwikkeling van services nog verder, door 'natuurlijke' ondersteuning voor Docker en Kubernetes toe te voegen. Een groot pluspunt is de ingebouwde ondersteuning voor GraalVM en de generatie van platformafhankelijke images, waardoor services echt snel opstarten en weinig geheugen gebruiken. Dit is erg belangrijk in onze tijd van massale adoptie van microservices en serverless architectuur.

Officiële website - quarkus.io. Voorbeelden van projecten voor een snelle start zijn al beschikbaar op GitHub.

Bron: habr.com