Vert.x

Vert.x
Basisdaten
Entwickler	Tim Fox
Aktuelle Version	4.5.7 (27. März 2024)
Betriebssystem	plattformübergreifend
Programmiersprache	Java, JavaScript, Groovy, Ruby, Ceylon, Kotlin, Scala
Kategorie	Framework für reaktive Programmierung
Lizenz	Apache-Lizenz
vertx.io

Vert.x ist ein ereignisorientiertes Framework für einfache Nebenläufigkeit, das in der Java Virtual Machine läuft und in den Programmiersprachen Java, JavaScript, Groovy, Ruby, Ceylon, Kotlin und Scala mit Apache-Lizenz verfügbar ist.

Vert.x bietet folgende Funktionen:

• Polyglot. Anwendungskomponenten können in Java, JavaScript, Groovy, Ruby, Ceylon, Kotlin und Scala geschrieben werden.
• Einfache Nebenläufigkeit, reaktive Programmierung.
• Einfaches, asynchrones Programmiermodell für skalierbare, nicht-blockierende Anwendungen.
• Verteilter Eventbus, der die Clientseite und Serverseite verbindet.
• Modulsystem und öffentliches Modul-Repository.

Ähnliche Umgebungen für andere Programmiersprachen sind z. B. Node.js für JavaScript, Twisted für Python, Perl Object Environment für Perl, libevent für C und EventMachine für Ruby.

Geschichte

Die Arbeit an Vert.x wurde von Tim Fox im Jahr 2011 begonnen, während er Mitarbeiter von VMware war. Im Dezember 2012, nachdem er VMware verließ, beanspruchte VMware die Vert.x Trade Mark, Domain, Blog, GitHub-Account und Google Group. Nach einigen Diskussionen stimmten im Januar 2013 alle Beteiligten dem Wechsel des Projekts zur Eclipse Foundation zu. Der Wechsel zur Eclipse Foundation wurde im August 2013 vollzogen. Im Mai 2014 gewann Vert.x den Award für “Most Innovative Java Technology” der JAX Innovation Awards.

Beispiele

Ein Webserver, der den Text "Hello from Vert.x!" zurückgibt, könnte im JavaScript zum Beispiel so geschrieben werden:

vertx.createHttpServer()
  .requestHandler(function (req) {
    req.response()
      .putHeader("content-type", "text/plain")
      .end("Hello from Vert.x!");
}).listen(8080);

In Java:

import io.vertx.core.AbstractVerticle;
public class Server extends AbstractVerticle {
  public void start() {
    vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hello from Vert.x!");
    }).listen(8080);
  }
}

In Ruby:

$vertx.create_http_server().request_handler() { |req|
  req.response()
    .put_header("content-type", "text/plain")
    .end("Hello from Vert.x!")
}.listen(8080)

In Groovy:

vertx.createHttpServer().requestHandler({ req ->
  req.response()
    .putHeader("content-type", "text/plain")
    .end("Hello from Vert.x!")
}).listen(8080)

In Python:

import vertx

server = vertx.create_http_server()

@server.request_handler
def handle(req):
    filename = "index.html" if req.uri == "/" else req.uri
    req.response.send_file("webroot/" + filename)
server.listen(8080)

In Clojure:

(ns example.server
  (:require [vertx.http :as http]))

  (-> (http/server)
    (http/on-request
      (fn [req]
        (let [uri (.uri req)]
          (-> req
            (http/server-response)
            (http/send-file (str "webroot/" (if (= "/" uri) "index.html" uri)))))))
    (http/listen 8080))

In Ceylon:

import io.vertx.ceylon.core { ... }
import io.vertx.ceylon.core.http { ... }
shared class Server() extends Verticle() {
  start() => vertx.createHttpServer()
    .requestHandler((req) =>
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hello from Vert.x!")
    ).listen(8080);
}

Wichtig ist, dass bei diesen Versionen keinerlei Überprüfungen stattfinden, ob beispielsweise die angeforderte Datei im Wurzelverzeichnis liegt.

Weblinks

• Offizielle Website (englisch)