Vert.x – Erste Schritte und Eindrücke

Vert.x ist ein Open Source Framework, welches von der Eclipse Foundation entwickelt wurde. Vert.x ist ein Event-driven Framework für die Java Virtual Machine.

Was ist vert.x?

Schauen wir uns zu erst einmal die Definition von vert.x an.

Vert.x is a polyglot, event driven and non blocking framework, which enables you to write reactive applications.

Was aber bedeutet überhaupt polyglot, event driven, non blocking oder reactive?

Polyglot

Polyglot sagt aus, dass Sie vert.x in verschiedenen Sprachen nutzen können. Dies ist möglich, da die gängigsten APIs für die unterstützen Sprachen bereitgestellt werden. Somit können Sie anhand Ihrer Anforderungen selbst entscheiden in welcher Sprache Sie diese gerne implementieren möchten. Vorausgesetzt, bei der ausgewählten Sprachen handelt es sich um ein der folgenden Sprachen: “Java, Javascript, Groovy, Ruby, Ceylon, Scala or Kotlin”.;-) )

Event driven

Don’t call us, we’ll call you.

Sobald ein von Ihnen bestimmtes Ereignis eintritt, wird Vert.x sie benachrichtigen, in dem es Events für diesen Fall sendet. Dies bedeutet, Sie können Aufgaben asynchron ausführen und Sie werden dennoch benachrichtigt, sobald die Aufgabe erledigt ist.

Non blocking

Sollte sich eine Software während einer essenziellen Berechnung oder sonst einer rechenintensiven Operation aufhängen, handelt es sich in den meisten Fällen um einem Worst-Case-Szenario. Die Folge davon ist eine lange Wartezeit für den User, bevor dieser seine Antwort erhält. Vert.x blockiert keine Threads. Dadurch ist es möglich mit einer kleineren Anzahl von Threads die Vorteile von Nebenläufigkeit (concurrency) auszuschöpfen.

Reactive

Reactive ist die Konsequenz von event driven und non blocking. Dies bedeutet, dass das Program mit asynchronen Daten-Streams aufgebaut wird. Sie können mehr über “reactive programming” in Andre Staltz’s Reactive tutorial erfahren.

Eigenschaften von vert.x

• lightweight
  • Core Vert.x ist 650kb
• schnell
  • Sie können viele Benchmarks finden, die dies bestätigen.
• kein Application Server
  • kein Deployment notwendig. Lassen Sie Ihren Code, wann immer sie wollen, laufen.
• modular
  • es sind viele Komponenten erhältlich, so können Sie selbst entscheiden, was Sie brauchen.
• simpel, aber nicht allzu simpel
• ideale Wahl, um leichtgewichtige und hochperformante Microservices zu bauen
• polyglot

Unser erstes Verticle

Bevor wir in die wunderbare Welt von vert.x abtauchen, klären wir noch den Begriff Verticle. Ein Verticle ist jede Komponente die, folgende Eigenschaften aufweist:

• Single-threaded
• event-driven
• nicht-blockierend

Dies ist zunächst einmal, alles was Sie darüber wissen müssen. Anhand des folgenden Beispiels sehen Sie nun wie leicht man eine Full Web Application schreiben kann.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

//1.
public class BNovaVerticle extends AbstractVerticle {

//2. 
    @Override
    public void start(Promise <Void> startPromise) throws Exception {
//3. 
        vertx.createHttpServer().requestHandler(req -> {
        req.response()
        .putHeader("content-type", "text/plain")
        .end("Hello from b-nova");
//4. 
        }).listen(8888, http ->{
            if (http.succeeded()) {
            startPromise.complete();
            System.out.println("HTTP server started on port 8888");
            } else {
            startPromise.fail(http.cause());
            }
        });
    }
}

Nun schauen wir uns den Code einmal genauer an.

1. Zuerst wird die Klasse BNovaVerticle erstellt und von der Klasse AbstractVerticle erweitert.
2. Um unseren Web-Server zu implementieren, müssen wir zunächst die start()-Methode der AbstractVerticle Klasse überschreiben.
3. Anschliessend erstellen wir den HttpServer und registrieren den RequestHandler. Sobald ein Request ankommt, wird eine Antwort mit “Hello from b-nova” gesendet.
4. Danach wird der Port des Webserver auf 8080 festgelegt. Insofern der Server sich auf diesem Port starten lässt, haben wir es geschafft.

EventBusReader

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class EventBusReaderVerticle extends AbstractVerticle {

    @Override
    public void start(Promise<Void> startPromise) throws Exception {
//1.
        vertx.eventBus().consumer("myCustomAddress", message -> {
        System.out.println("message received = " + message.body());
        });
    }
}

1. Zunächst wird der Consumer auf dem Event Bus registriert. Dadurch hört der Consumer die angegebene Adresse ab. (myCustomAddress ist einfach ein String, welchen Sie frei wählen können)

Publisher

Schauen wir uns nun auch noch die Publisher Seite an. Wir modifizieren unseren BNovaVerticle so, dass er jedes Mal eine Nachricht publiziert, sobald ein Request verarbeitet wird.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class BNovaVerticle extends AbstractVerticle {

    @Override
    public void start(Promise<Void> startPromise) throws Exception {
    
    vertx.createHttpServer().requestHandler(req -> {
    
    vertx.eventBus().publish("myCustomAddress", "Hello b-nova");
    
    }).listen(8888, http -> {
        if (http.succeeded()) {
        startPromise.complete();
        System.out.println("HTTP server started on port 8888");
        } else {
        startPromise.fail(http.cause());
        }
    });
    }
}

Jedes Mal, wenn ein Request eingeht wird eine Nachricht über den Event Bus gesendet. Sollten Sie mehrere Empfänger auf derselben Adresse registrieren, dann wird die Nachricht zu allen Empfänger gesendet.

Fazit

Beachten Sie, dass dies nur ein kleiner Ausschnitt davon ist, was das vert.x-Framework bietet. Sollten Sie eine leichtgewichtige und hochperformante Applikation bauen, schauen Sie sich zuvor alle praktischen Module an die Vert.x bereitstellt.