Quarkus is een supersonisch subatomair Java. Kort overzicht van het raamwerk

Introductie

Op XNUMX maart zal RedHat (binnenkort IBM) gepresenteerd nieuw raamwerk - kwark. Volgens de ontwikkelaars is dit framework gebaseerd op GraalVM en OpenJDK HotSpot en ontworpen voor Kubernetes. De Quarkus-stack omvat: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus en anderen.

Het doel is om van Java het leidende platform te maken voor de implementatie van Kubernetes en de ontwikkeling van serverloze applicaties, waardoor ontwikkelaars een uniforme benadering van ontwikkeling krijgen in zowel reactieve als imperatieve stijlen.

Als je kijkt deze classificatie van frameworks, dan bevindt Quarkus zich ergens tussen “Aggregators/Code Generators” en “Fullstack frameworks op hoog niveau”. Dit is al meer dan een aggregator, maar bereikt niet eens de volledige stapel, omdat... op maat gemaakt voor backend-ontwikkeling.

Er wordt een zeer hoge snelheid bij het starten van applicaties en een laag geheugengebruik beloofd. Hier zijn de gegevens van de website van de ontwikkelaar:

Tijd vanaf start tot eerste reactie(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 gevonden over deze technologiestapel, we kunnen aannemen dat dit een soort Spring Boot is met een extra bodykit.

Hallo Wereld!

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";
   }
}

Het is letterlijk één les en dat is genoeg! U kunt de applicatie uitvoeren met Maven in de ontwikkelingsmodus:

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

Het verschil met een reguliere applicatie is dat er geen Application klasse is! Quarkus ondersteunt hot reload, zodat u uw applicatie kunt wijzigen zonder deze opnieuw te starten, waardoor de ontwikkeling nog sneller gaat.

Wat is het volgende? U kunt een service aan een controller toevoegen met behulp van een annotatie Injecteren. Servicecode:

@ApplicationScoped
public class GreetingService {

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

controleur:

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

Merk op dat Quarkus standaardannotaties gebruikt uit bekende raamwerken - CDI en JAX-RS. Als je al eerder met CDI en JAX-RS hebt gewerkt, hoef je natuurlijk niets nieuws te leren.

Werken met de databank

Er worden slaapstand- en standaard JPA-annotaties voor entiteiten gebruikt. Net als bij REST-controllers moet je een minimum aan code schrijven. Het volstaat om de afhankelijkheden in het assemblagebestand aan te geven en annotaties toe te voegen @Entity en configureer de gegevensbron in application.properties.

Alle. Geen sessionFactory, persistentie.xml of andere servicebestanden. Wij schrijven alleen de code die nodig is. Indien nodig kunt u echter een persistentie.xml-bestand maken en de ORM-laag nauwkeuriger configureren.

Quarkus ondersteunt het cachen van entiteiten, verzamelingen voor één-op-veel-relaties en query's. Op het eerste gezicht lijkt het geweldig, maar dat is het ook lokaal caching, voor één Kubernetes-knooppunt. Die. De caches van verschillende knooppunten zijn niet met elkaar gesynchroniseerd. Ik hoop dat dit tijdelijk is.

Asynchrone code-uitvoering

Zoals hierboven vermeld ondersteunt Quarkus ook de reactieve programmeerstijl. De code van de vorige applicatie kan in een andere vorm worden geschreven.

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

Asynchrone code kan ook naar de service worden overgedragen, het resultaat zal hetzelfde zijn.

Testen

Tests voor Quarkus-applicaties kunnen worden geschreven in JUnit4 of JUnit5. Hieronder staat een voorbeeldtest voor een endpoint, deze is geschreven met RestAssured, maar er kan ook een ander framework 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("Hello " + uuid + "!"));
   }
}

De @QuarkusTest-annotatie geeft aan dat u de applicatie moet uitvoeren voordat u tests uitvoert. De rest is code die bekend is bij alle ontwikkelaars.

Platformspecifieke applicatie

Omdat Quarkus nauw geïntegreerd is met GraalVM, is het uiteraard mogelijk om platformspecifieke code te genereren. Om dit te doen, moet u GraalVM installeren en de omgevingsvariabele GRAALVM_HOME opgeven. Verder registreer een profiel voor montage en specificeer dit bij het bouwen van de applicatie:

mvn package -Pnative

Interessant is dat de gegenereerde applicatie kan worden getest. En dit is belangrijk omdat de uitvoering van native code kan verschillen van de uitvoering op de JVM. De @SubstrateTest-annotatie voert platformspecifieke applicatiecode uit. Het hergebruiken van bestaande testcode kan via overerving, waardoor de code voor het testen van een platformafhankelijke applicatie er als volgt uit zal zien:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

De gegenereerde image kan worden verpakt in Docker en worden uitgevoerd in Kubernetes of OpenShift, zoals gedetailleerd beschreven in instructies.

Toolkit

Het Quarkus-framework kan worden gebruikt met Maven en Gradle. Maven wordt volledig ondersteund, in tegenstelling tot Gradle. Helaas ondersteunt Gradle momenteel geen het genereren van een leeg project; er staat gedetailleerde informatie op de website leerboek.

uitbreiding

Quarkus is een uitbreidbaar raamwerk. Momenteel is er een bestelling 40 uitbreidingen, die verschillende functionaliteit toevoegen - van ondersteuning Veer DI-container и Apache-kameel voordat u statistieken voor actieve services registreert en publiceert. En er is al een uitbreiding om naast Java het schrijven van applicaties in Kotlin te ondersteunen.

Conclusie

Wat mij betreft sluit Quarkus helemaal aan bij de trends van die tijd. Het ontwikkelen van backend-code wordt steeds eenvoudiger, en dit raamwerk vereenvoudigt en versnelt de ontwikkeling van diensten verder door native ondersteuning voor Docker en Kubernetes toe te voegen. Een groot pluspunt is de ingebouwde ondersteuning voor GraalVM en het genereren van platformafhankelijke images, waardoor services heel snel kunnen opstarten en weinig geheugenruimte in beslag nemen. En dit is erg belangrijk in onze tijd van massale passie voor microservices en serverloze architectuur.

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

Bron: www.habr.com