🥇 Quarkus – Überschall-subatomare Java. Kurzer Überblick über das Framework

Einführung

Am siebten März hat das Unternehmen RedHat (bald IBM) präsentierte ein neues Framework — Quarkus. Laut den Entwicklern basiert dieses Framework auf GraalVM und OpenJDK HotSpot und ist für Kubernetes konzipiert. Der Quarkus-Stack umfasst: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus und mehr.

Das Ziel der Entwicklung ist es, Java zur führenden Plattform für Bereitstellungen in Kubernetes und die Entwicklung von serverlosen Anwendungen zu machen, indem Entwicklern einen einheitlichen Ansatz sowohl für reaktive als auch für imperative Programmierung angeboten wird.

Werfen wir einen Blick auf dieses die Klassifikation von Frameworks, so befindet sich Quarkus irgendwo zwischen «Aggregatoren/Code-Generatoren» und «High-Level-Fullstack-Frameworks». Es ist mehr als ein Aggregator, erreicht jedoch nicht die volle Stack-Fähigkeit, da es auf die Backend-Entwicklung ausgelegt ist.

Hohe Startgeschwindigkeit und geringer Speicherverbrauch wurden versprochen. Hier sind die Daten von der Webseite des Entwicklers:

Zeit vom Start bis zur ersten Antwort (s):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditioneller Cloud-Native-Stack*
4.3
9.5

Speicherverbrauch (Mb):

Konfiguration
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditioneller Cloud-Native-Stack*
140
218

Impressive, nicht wahr?

*Zu diesem Technologie-Stack habe ich keine Informationen gefunden; es kann angenommen werden, dass es sich um ein Spring Boot mit zusätzlichem Aufsatz handelt..

Hallo Welt!

Die einfachste Anwendung, die mit Quarkus geschrieben wurde, sieht so aus:

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

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

Das ist buchstäblich eine Klasse und das reicht aus! Sie können die Anwendung mit Maven im Entwicklermodus starten:

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

Der Unterschied zu einer gewöhnlichen Anwendung ist, dass es keine Klasse Application gibt! Quarkus unterstützt Hot Reload, sodass Sie die Anwendung ändern können, ohne sie neu zu starten, wodurch die Entwicklung noch schneller wird.

Was kommt als Nächstes? Sie können einen Service im Controller mit der Annotation Inject. Der Service-Code:

@ApplicationScoped
public class GreetingService {

   public String greeting(String name) {
       return "Hallo " + 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
Hallo developer!

Beachten Sie, dass Quarkus die standardmäßigen Annotationen aus den vertrauten Frameworks — CDI und JAX-RS — verwendet. Es gibt nichts Neu zu lernen, wenn Sie zuvor mit CDI und JAX-RS gearbeitet haben.

Arbeiten mit der Datenbank

Hibernate und die Standard-JPA-Anmerkungen werden für die Entitäten verwendet. Wie auch bei REST-Controllern ist es erforderlich, nur minimalen Code zu schreiben. Es genügt, die Abhängigkeiten in der Build-Datei anzugeben und die Anmerkungen zu positionieren. @Entity und die Datasource in application.properties zu konfigurieren.

Das war's. Keine sessionFactory, persistence.xml und andere Servicedateien. Wir schreiben nur den notwendigen Code. Bei Bedarf kann jedoch eine persistence.xml-Datei erstellt werden, um die ORM-Schicht feiner zu konfigurieren.

Quarkus unterstützt das Caching von Entitäten, Sammlungen für Eins-zu-Viele-Beziehungen sowie von Anfragen. Auf den ersten Blick sieht das vielversprechend aus, aber es ist lokales Caching, das nur für einen einzelnen Kubernetes-Knoten gilt. Das bedeutet, dass die Caches verschiedener Knoten nicht miteinander synchronisiert sind. Ich hoffe, das ist nur vorübergehend.

Asynchrone Codeausführung

Wie bereits erwähnt, unterstützt Quarkus auch den reaktiven Programmierstil. Der Code der vorherigen Anwendung kann in einer anderen Form geschrieben werden.

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

Asynchroner Code kann auch in den Dienst übertragen werden, das Ergebnis bleibt dasselbe.

Testen

Tests für Quarkus-Anwendungen können in JUnit4 oder JUnit5 geschrieben werden. Im Folgenden ist ein Beispiel für einen Test für den Endpoint dargestellt, der mit RestAssured geschrieben wurde, aber auch ein anderer Rahmen verwendet werden kann:

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

Die Annotation @QuarkusTest gibt vor, die Anwendung zu starten, bevor die Tests ausgeführt werden. Ansonsten ist der Code für alle Entwickler vertraut.

Plattformabhängige Anwendung

Da Quarkus eng mit GraalVM integriert ist, kann natürlich plattformabhängiger Code generiert werden. Dazu muss GraalVM installiert und die Umgebungsvariable GRAALVM_HOME festgelegt werden. Dann muss ein Profil für den Build definiert werden und beim Bauen der Anwendung angegeben werden:

mvn package -Pnative

Interessanterweise kann die generierte Anwendung getestet werden. Das ist wichtig, da die Ausführung von "native" Code von der Ausführung auf der JVM abweichen kann. Die Annotation @SubstrateTest startet plattformabhängigen Code der Anwendung. Die Wiederverwendung des vorhandenen Testcodes kann durch Vererbung erfolgen, sodass der Code für das Testen der plattformabhängigen Anwendung so aussehen wird:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Das generierte Image kann in Docker verpackt und in Kubernetes oder OpenShift ausgeführt werden, wie ausführlich beschrieben in Anleitung.

Werkzeugset

Das Quarkus-Framework kann mit Maven und Gradle verwendet werden. Maven wird vollständig unterstützt, im Gegensatz zu Gradle. Leider unterstützt Gradle momentan nicht die Generierung eines leeren Projekts, es gibt auf der Website ein ausführliches Tutorial.

Erweiterungen

Quarkus ist ein erweiterbares Framework. Momentan existieren etwa 40 Erweiterungen, die verschiedene Funktionalitäten hinzufügen – von der Unterstützung des Spring DI Containers und Apache Camel bis zur Protokollierung und Veröffentlichung von Metriken für aktive Dienste. Es gibt bereits eine Erweiterung zur Unterstützung der Anwendungsentwicklung in Kotlin, zusätzlich zu Java.

Fazit

Meiner Meinung nach liegt Quarkus absolut im Trend. Die Entwicklung von Backend-Code wird immer einfacher, und dieses Framework erleichtert und beschleunigt die Entwicklung von Diensten noch weiter, indem es native Unterstützung für Docker und Kubernetes bietet. Ein riesiger Vorteil ist die eingebaute Unterstützung von GraalVM und die Generierung plattformspezifischer Images, was es ermöglicht, Dienste wirklich schnell zu starten und wenig Speicherplatz zu beanspruchen. Das ist heutzutage besonders wichtig, da Mikrodienste und serverlose Architekturen im Trend liegen.

Die offizielle Website — quarkus.io. Beispiele für Projekte für einen schnellen Start sind bereits verfügbar auf GitHub.

Quelle: habr.com