RIA ohne JavaScript?

Das Google Web Toolkit vorgestellt
Kommentare

Wenn Sie auch zu den Java-Entwicklern gehören, denen bei dem Wort JavaScript ganz mulmig zumute wird, dann gibt’s dort seit kurzem etwas von Google – das Google Web Toolkit (GWT). Damit hat Google ein Werkzeug vorgestellt, mit dem sich RIA-Anwendungen, zumindest theoretisch, ohne eine selbst geschriebene Zeile JavaScript erstellen lassen. Das Toolkit ist eine Kombination aus einer spartanischen Entwicklungsumgebung, einem Java- nach JavaScript-Compiler und einer Sammlung von Oberflächen-Komponenten. Der Entwickler selbst schreibt seine RIA-Anwendung gegen eine Sammlung von Interfaces. Nach dem Kompilieren steht eine Anwendung zur Verfügung, die für sich allein in einem der aktuellen Webbrowser ausgeführt werden kann. Auch der asynchrone Aufruf von Server-Komponenten ist möglich.

Warum ein mulmiges Gefühl? Einige der Hauptprobleme bei der Erstellung von JavaScript-basierten RIA-Anwendungen lassen sich folgendermaßen zusammenfassen:

  • Die client- und serverseitig verwendeten Programmiersprachen sind unterschiedlich. Damit werden Änderungen am Anwendungsdesign deutlich komplexer und aufwändiger, weil der Code nicht ohne Weiteres vom Client auf den Server oder umgekehrt übertragen werden kann.
  • JavaScript ist eine untypisierte Sprache. Damit kann es durchaus sein, dass Programmierfehler erst zur Laufzeit entdeckt werden, wenn die Werte nicht den erwarteten Typen entsprechen.
  • Auch wenn es inzwischen für Java-Script leistungsfähige Editoren, Debugger und sogar Möglichkeiten zur Ausführung von JUnit-ähnlichen Tests gibt – insgesamt sind die Entwicklungs- und Testwerkzeuge für eine Programmiersprache wie Java deutlich ausgereifter.
  • Nicht zu vergessen ist der immense Aufwand, der sich aus Browser-Inkompatibilitäten ergibt. Natürlich gibt es auch hier inzwischen JavaScript-Bibliotheken, die dem Entwickler bei diesem Problem unter die Arme greifen. Erwähnt sei hier das JavaScript-Framework Prototype.

Weitere Probleme, denen man sich als Entwickler stellen muss, haben nichts mit der verwendeten Sprache an sich, sondern mit der Funktionsweise von Webbrowsern und der Infrastruktur zu tun. Das fängt beispielsweise bei der asynchronen Kommunikation mit einem Server an und reicht  bis hin zu Problemen bei der Verknüpfung mit der Browser-Historie oder der Mehrsprachigkeit von RIA-Anwendungen. Von einem Toolkit für die Erstellung solcher Anwendungen kann man also erwarten, dass es Lösungen für die angesprochenen Probleme bereitstellt.

Hallo Welt

Sich Neuem per „Hallo Welt“ zu nähern, ist ein bewährter Ansatz, der auch hier als Einstieg dienen soll: Das Web Toolkit kann hier heruntergeladen werden. Es gibt eine Version für Windows und eine für Linux. Die Datei entpackt man einfach in ein Verzeichnis, und man kann sofort mit der Erstellung eines ersten Projekts beginnen. Am einfachsten ist es, gleich mit einem Eclipse-Projekt zu beginnen. Dazu wird zunächst eine Eclipse-Projektstruktur mit dem Kommandozeilenaufruf projectCreator -eclipse HalloWelt –out HalloWelt erstellt. Anschließend werden die GWT-Quelldateien erstellt: applicationCreator –eclipse HalloWelt –out HalloWelt de.client.HalloWelt. Das erstellte Verzeichnis (-out) muss jetzt nur noch als Eclipse-Projekt importiert werden. Abbildung 1 zeigt die erstellte Projektstruktur.

Abb. 1: Projektstruktur

Neben der angegebenen Klasse de.client.HalloWelt wurde ein Verzeichnis public angelegt, in dem sich die HTML-Datei HalloWelt.html befindet. Eine Ebene höher fällt die Datei HalloWelt.gwt.xml auf. Des Weiteren wurde die Datei gwt-user.jar in das Projekt eingebunden und zwei batch-Dateien HalloWelt-compile.cmd und HalloWelt-shell.cmd erstellt. Dadurch, dass gleichzeitig eine Datei HalloWelt.launch erstellt wurde, befindet sich in der Run-Konfiguration von Eclipse ein Eintrag HalloWelt, damit kann das Projekt sofort ausgeführt werden. Es wird die GWT-Shell gestartet und ein eigener Webbrowser geöffnet, der den URL http://localhost:8888/de.HalloWelt/HalloWelt.html anzeigt (Abb. 2). Klickt man auf den Button Click me, erscheint neben dem Button der Text Hallo World, klickt man erneut, verschwindet er wieder.

Abb. 2: Aufruf der Anwendung im Hosted-Modus

Als Nächstes sollte die Schaltfläche Compile | Browse angeklickt werden. Damit wird das Projekt kompiliert und das Ergebnis im aktuell eingestellten Webbrowser des Betriebssystems angezeigt. Für die kompilierten Dateien wurde innerhalb des Eclipse-Projekts ein Verzeichnis www erstellt, in dem sich alle für die Ausführung benötigten Dateien befinden (Projekt ggf. aktualisieren!). Die Datei HalloWelt.html lässt sich übrigens von dort aus mit einem Browser anzeigen, das Ergebnis ist also auch ohne Webserver funktionsfähig! Nun stellt sich sicherlich die Frage, was hier überhaupt passiert ist? Die erstellte Java-Klasse de.client.HalloWelt implementiert das Interface com.google.gwt.core.client.EntryPoint (Listing 1).

Listing 1
---------------------------------------------------------------------
public void onModuleLoad() {
    final Button button = new Button("Click me");
    final Label label = new Label();

    button.addClickListener(new ClickListener() {
      public void onClick(Widget sender) {
        if (label.getText().equals(""))
          label.setText("Hello World!");
        else
          label.setText("");
      }
    });
    RootPanel.get("slot1").add(button);
    RootPanel.get("slot2").add(label);
  }

Wie zu erkennen ist, wird zunächst ein Button mit der Beschriftung „Click me“ und ein leeres Label erstellt. Am Button wird ein ClickListener registriert, der die dynamische Funktionalität implementiert, also das Verhalten, dass man durch Anklicken den Text „Hello World“ ein- und ausblenden kann. Die Aufrufe von RootPanel.get().add() sorgen dafür, dass die erstellten Komponenten auch in der HTML-Seite sichtbar sind (Listing 2).

Listing 2
--------------------------------------------------------------------

  
    Wrapper HTML for HalloWelt  

HalloWelt

This is an example ... from scratch.

Im Meta-Tag ist angegeben, welches Modul geladen werden soll (dabei handelt es sich um das Verzeichnis, das nach dem Kompilieren erstellt wird; die GWT-Shell selbst sucht nach der Datei de.HalloWelt.gwt.xml). Das gesamte Laufzeitverhalten wird durch den Import der JavaScript-Datei gwt.js angestoßen. Auch die beiden Elemente mit den IDs slot1 und slot2 finden sich wieder. Durch den Aufruf von RootPanel.get(“slot1“).add(button) wurde also der Button dem td-Element hinzugefügt. Man könnte auch ein leeres body-Element angeben. Dann müsste man die gesamte Oberfläche über die GWT-Komponenten aufbauen.

Mit dem Starten der GWT-Shell aus Eclipse heraus (es geht natürlich auch ohne Eclipse mit Hilfe der batch-Datei) wurde der so genannte Hosted-Modus des Google Web Toolkits ausgeführt. Dabei wird gleichzeitig ein abgespeckter Tomcat gestartet, der den Server-Zugriff emuliert. Der Hosted-Modus hat einen ganz entscheidenden Vorteil: er erlaubt das Debuggen. Dazu muss nur ein Breakpoint gesetzt und die Shell im Debug-Modus gestartet werden (Abb. 3).

Abb. 3: Debug im Hosted-Modus

Um es noch einmal ganz deutlich herauszustellen: Hier wird Java-Quellcode debugged, der später zur Laufzeit als JavaScript ausgeführt wird. Die GWT-Shell sorgt im Hosted-Modus für die Synchronisation zwischen beiden Welten. Durch das Kompilieren der Anwendung wird aus dem Java-Quellcode der eigentliche JavaScript-Code erstellt. Das ist kein Novum des GWT, das Projekt Java2Script geht einen ganz ähnlichen Weg. Generiert wird jeweils eine browserspezifische HTML-Datei, die den gesamten Script-Code für die Ausführung eines Moduls enthält. Zur Laufzeit wird dann je nach Client-Browser die passende Datei nachgeladen. Das Ausführen zur Laufzeit wird als Web-Modus bezeichnet. Besonders beim Blick in die Dokumentation ist es wichtig, diese beiden Modi genau auseinander zu halten.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -