Quarkus — Überschall-Subatomare Java. Eine kurze Übersicht über das Framework

Einführung

Am siebten März wird die Firma RedHat (bald IBM) hat ein neues Framework — unterstützt Quarkus die Verwendung des Advanced Message Queuing Protocol (. Laut den Entwicklern basiert dieses Framework auf GraalVM und OpenJDK HotSpot und ist für Kubernetes gedacht. Der Quarkus-Stack umfasst: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus und andere.

Das Ziel der Entwicklung ist es, Java zur führenden Plattform für die Bereitstellung in Kubernetes und die Entwicklung serverloser Anwendungen zu machen, indem den Entwicklern ein einheitlicher Ansatz für die Entwicklung sowohl im reaktiven als auch im imperativen Stil geboten wird.

Wenn man sich die Maschine verwendet. Klassifikation der Frameworks ansieht, befindet sich Quarkus irgendwo zwischen „Aggregatoren/Code-Generatoren“ und „High-Level Fullstack-Frameworks“. Es ist bereits mehr als ein Aggregator, kommt aber nicht ganz an Full-Stack heran, da es auf die Backend-Entwicklung ausgelegt ist.

Es wird eine sehr hohe Geschwindigkeit beim Start der Anwendung und ein geringer Speicherverbrauch versprochen. Hier sind die Daten von der Website 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

Beeindruckend, nicht wahr?

*Informationen zu diesem Technologiestack habe ich nicht gefunden, man kann vermuten, dass es sich um eine Art Spring Boot mit zusätzlicher Ausrüstung handelt..

4) Wechseln Sie in das Verzeichnis, in das Sie das Beispielprojekt heruntergeladen haben:

Das einfachste auf Quarkus geschriebene Programm würde so aussehen:

@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! Die Anwendung kann mit Maven im Entwicklungsmodus gestartet werden:

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

Der Unterschied zu einer üblichen Anwendung ist — es gibt keine Klasse Application! Quarkus unterstützt Hot Reload, sodass man die Anwendung ändern kann, ohne sie neu zu starten, was die Entwicklung noch schneller macht.

Was kommt als Nächstes? Man kann einen Dienst im Controller mit der Annotation hinzufügen Inject. Der Dienstcode:

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

Beachten Sie, dass in Quarkus die Standardannotation aus den vertrauten Frameworks — CDI und JAX-RS — verwendet werden. Es ist nichts Neues zu lernen, wenn Sie zuvor mit CDI und JAX-RS gearbeitet haben.

Arbeiten mit der Datenbank

Hibernate und standardmäßige JPA-Annotationen für Entitäten werden verwendet. Wie bei REST-Controllern muss nur wenig Code geschrieben werden. Es reicht aus, die Abhängigkeiten in der Build-Datei anzugeben und die Annotationen zu setzen. @Entity und die Datenquelle in der application.properties zu konfigurieren.

Das war's. Keine sessionFactory, persistence.xml und andere Service-Dateien. Wir schreiben nur den Code, der benötigt wird. 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 Abfragen. Auf den ersten Blick sieht das großartig aus, aber es ist lokales Caching für einen einzelnen Kubernetes-Knoten. Das bedeutet, dass die Caches verschiedener Knoten nicht untereinander 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 anderer 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 "Hallo " + name + "!";
       });
   }
}

Asynchroner Code kann auch in einen Service verschoben werden, das Ergebnis bleibt dasselbe.

Tests

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

@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 weist an, die Anwendung zu starten, bevor die Tests ausgeführt werden. Ansonsten ist der Code bekannt und vertraut für alle Entwickler.

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 gesetzt werden. Dann muss ein Build-Profil angegeben werden und bei der Erstellung der Anwendung angegeben werden:

mvn package -Pnative

Interessanterweise kann die generierte Anwendung getestet werden. Das ist wichtig, da die Ausführung von „nativem“ Code von der Ausführung auf der JVM abweichen kann. Die Annotation @SubstrateTest führt plattformabhängigen Code der Anwendung aus. Die Wiederverwendung bestehenden Testcodes kann durch Vererbung erfolgen, sodass der Code zum Testen einer plattformabhängigen Anwendung so aussieht:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Das generierte Bild kann in Docker verpackt und in Kubernetes oder OpenShift ausgeführt werden, was detailliert beschrieben ist in Anleitung.

Werkzeug

Das Framework Quarkus kann mit Maven und Gradle verwendet werden. Maven wird vollständig unterstützt, im Gegensatz zu Gradle. Leider unterstützt Gradle derzeit nicht die Erstellung eines leeren Projekts, es gibt auf der Website detaillierte Lehrbuch.

Erweiterungen

Quarkus ist ein erweiterbares Framework. Momentan gibt es etwa 40 Erweiterungen, die verschiedene Funktionalitäten hinzufügen – von der Unterstützung von Spring DI-Container und Apache Camel bis hin zu Logging und der Veröffentlichung von Metriken für laufende Dienste. Außerdem gibt es bereits eine Erweiterung zur Unterstützung der Anwendungsentwicklung in Kotlin, zusätzlich zu Java.

Fazit

Meiner Meinung nach ist Quarkus durchaus im Trend. Die Entwicklung von Backend-Code wird immer einfacher, und dieses Framework vereinfacht und beschleunigt die Entwicklung von Diensten noch weiter, indem es native Unterstützung für Docker und Kubernetes hinzufügt. Ein großer Vorteil ist die eingebaute Unterstützung von GraalVM und die Erstellung plattformabhängiger Bilder, was es ermöglicht, Dienste wirklich schnell startfähig und speichersparend zu machen. Das ist in der heutigen Zeit, in der Mikroservices und serverlose Architekturen im Trend liegen, sehr wichtig.

Die offizielle Website ist – quarkus.io. Beispiele für Projekte zum schnellen Start sind bereits auf GitHub.

Quelle: habr.com