EnterpriseTales

Polyglott mit Vert.x: Eine JVM-Alternative zu Node.js

Lars Röwekamp und Matthias Weßendorf

Die Umsetzung asynchroner Kommunikation im Enterprise-Java-Umfeld ist seit jeher nicht gerade trivial. Kein Wunder also, dass sich mittlerweile etliche, deutlich einfacher zu programmierende Alternativen herausgebildet haben. Am bekanntesten ist sicherlich das eventgetriebene und asynchrone JavaScript-Framework Node.js, das Googles V8 JavaScript Engine zur Ausführung verwendet. Mit Vert.x ist nun ein neuer Stern am Horizont erschienen, der einen genaueren Blick lohnt – allein schon aufgrund der Tatsache, dass eine JVM als Runtime verwendet wird.

Quickvote

Haben Sie schon mit vert.x gearbeitet? Dann Teilen Sie Ihre Erfahrungen mit der Community – entweder hier als Kommentar oder in unserem aktuellen Quickvote:

Was halten Sie von vert.x?

Node.js findet mittlerweile auch außerhalb der Hipster-Szene große Anerkennung. Selbst Industriegrößen wie Microsoft sind auf den Zug aufgesprungen [1].

Ein großer Vorteil von Node.js ist, dass es Entwicklern erlaubt wird, auf einfachste Art und Weise asynchrone, nichtblockierende Netzwerkprogramme zu schreiben:

var http = require('http');
http.createServer(function (req, res) {

      console.log('Handling a request');

  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello Worldn');
}).listen(1337, '127.0.0.1');
console.log('Done: Server running at http://127.0.0.1:1337/'); 

Dieses kleine Programm von der Node.js-Website [2] startet einen einfachen HTTP-Server und schreibt bei jedem Request eine Logging-Nachricht auf die Konsole. Der createServer()-Funktion wird ein Callback zur Request-Verarbeitung übergeben, der erst dann aufgerufen wird, sobald auch ein HTTP-Client eine Anfrage an den laufenden Server stellt.

Ein Node.js für die JVM?

Mit Vert.x [3] steht eine Alternative zu Node.js bereit, die auf der JVM basiert und somit sämtliche Vorteile (Skalierbarkeit/Verfügbarkeit) dieser nutzt. Vert.x kommt mit einem sehr einfachen Concurrency Model für die nebenläufige Programmierung daher. Dem Java-Programmierer wird dadurch einiges an komplexer Arbeit abgenommen. Vert.x versteht sich genau wie Node.js eher als Plattform denn als klassisches Webframework. Ein Programm auf Basis von Vert.x wird Verticle genannt. Das in Listing 1 gezeigte Java-Programm beschreibt einen vollständigen HTTP-Server, der statische Dokumente ausliefert. In guter alter Java-Manier wird der requestHandler()-Methode eine anonyme Implementierung des Handler-Interface übergeben. Dessen handle()-Methode übernimmt die asynchrone Verarbeitung der HTTP-Requests.

Listing 1: Vert.x-basierter HTTP-Server
import org.vertx.java.core.Handler;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.deploy.Verticle;

public class HttpServer extends Verticle {
    public void start() {
        vertx.createHttpServer().requestHandler(new Handler() {
            public void handle(HttpServerRequest req) {
                String file = req.path.equals("/") ? "index.html" : req.path;
                req.response.sendFile("webroot/" + file);
            }
        }).listen(8080);
    }
} 
Nicht nur Java …

Die Java-Syntax kann schon einmal etwas geschwätziger und auch umständlicher ausfallen, als es wirklich notwendig ist. Der gleiche Server auf Basis von Ruby sieht wie folgt aus:

require "vertx"

Vertx::HttpServer.new.request_handler do |req|
    file = req.uri == "/" ? "index.html" : req.uri
    req.response.send_file "webroot/#{file}"
end.listen(8080) 

Neben Java und Ruby (via JRuby) unterstützt das Vert.x-Framework in der aktuellen Entwicklungsversion noch einige weitere Programmiersprachen:

  • JavaScript und CoffeeScript (via Rhino)
  • Groovy
  • Python (via Jython)

An der Unterstützung zusätzlicher Sprachen, wie beispielsweise Scala, wird derzeit gearbeitet. Für den Betrieb des Vert.x-Frameworks wird Java in der Version 1.7 benötigt.

Geschrieben von
Lars Röwekamp und Matthias Weßendorf
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.