Google Web Toolkit

Aus EUFH-Wiki

Das Google Web Toolkit (GWT) ist ein quelloffenes Framework mit dessen Hilfe Webentwickler AJAX-Anwendungen in Java entwickeln und anschließend in JavaScript und HTML konvertieren können.

Allgemeine Einführung

In Zeiten des Web 2.0 ist AJAX nicht mehr wegzudenken. Allerdings bringt die Entwicklung von AJAX-Anwendungen fürs Web gewisse Herausforderungen mit sich. Ein Webentwickler muss gleichzeitig beispielsweise an JavaScript, HTML und CSS-Dateien arbeiten – ohne dass ihm dafür eine vergleichbare Entwicklungsumgebung wie für Desktop-Applikationen im Java-Umfeld zur Verfügung stünde.^[1] Außerdem gibt es deutliche Unterschiede zwischen Java und JavaScript, weshalb der Umstieg für einen erfahrenen Java-Entwickler nicht so leicht fällt, wie die Namensgleichheit vermuten lassen könnte. Weitere Java-Script-spezifische Schwächen werden im folgenden Abschnitt erläutert.

Schwächen von JavaScript

Wie bereits erwähnt gibt es deutliche Unterschiede zwischen der Entwicklung von Desktop-Anwendungen und der von AJAX-Anwendungen fürs Web. JavaScript ist aus folgenden Gründen benachteiligt:

JavaScript ist nicht typisiert, weshalb manche Fehler erst bei der Laufzeit und nicht schon beim Kompilieren entdeckt werden können.
Durch die hohe Flexibilität der Sprache, ist es für Werkzeuge schwierig den Programmierer zu unterstützen, wie es bei Entwicklungsumgebungen, wie z.B. Eclipse üblich ist. Außerdem gibt es wesentlich weniger gute, professionelle Entwicklungsumgebungen als für Java.
Obwohl JavaScript standardisiert ist, kann es je nach verwendetem Browser unterschiedlich interpretiert werden, da jeder seine eigene Laufzeitumgebung mit sich bringt. Entsprechend muss Entwicklungsaufwand darauf verwendet werden, die Eigenheiten der Browser abzufangen.
JavaScript ist nur schwer zu debuggen.
Für JavaScript gibt es bisher noch keine Test-Frameworks vergleichbar mit denen für Java, wie zum Beispiel JUnit.^[2]

Vorteile von Java

Die beschriebenen Schwächen von JavaScript findet man bei Java besser gelöst. Es gibt feste Datentypen, ein ausgefeiltes Speichermanagement (siehe GarbageCollector) und ein mächtiges Exception-Handling. Außerdem wird strikt objektorientiert entwickelt, was deutliche Vorteile für die Übersicht, Konzeption und die Wartung des Codes mit sich bringt. Durch Einführung einer zusätzlichen Abstraktionsschicht lassen sich Applikationen einfacher entwerfen, da keine Rücksicht auf das Zusammenspiel von JavaScript, HTML und CSS genommen werden muss. Hier bietet das GWT nämlich zusätzliche Features, die im Folgenden erläutert werden. .^[3]

Erweiterungen durch das GWT

Wie schon angedeutet, geht das GWT über die reine Konvertierung von Java in JavaScript und HTML hinaus. Verschiedene Strukturen und Automatismen erleichtern die Entwicklung weiter.

Wiederverwendbare Widgets - Widgets sind eigenständige Programmteile mit Benutzeroberfläche, die Teilaufgaben übernehmen und zu komplexeren Widgets zusammengesetzt werden können. ^[4]
Erleichterter Umgang mit Remote Procedure Call (RPC) – RPCs sind wesentlicher Bestandteil von AJAX-Applikationen und bieten auf Grund der Häufigkeit ihres Vorkommens deutliche Erleichterungen und Zeitersparnis bei der Entwicklung. ^[5]
Automatische Unterstützung der Zurück-Schaltfläche – Durch die asynchrone Gestaltung von AJAX-Applikationen wird oftmals die Funktionalität der Zurück-Schaltfläche des Browsers ausgehebelt. Mit dem GWT werden dieses und ähnliche Probleme gelöst, ohne dabei den Entwickler einzuschränken. ^[6]
Nutzbarkeit von Entwicklungsumgebungen – Durch Einsatz des GWT hat der Entwickler Zugriff auf alle gängigen Entwicklungsumgebungen für JAVA wie zum Beispiel Eclipse. So lassen sich erprobte Funktionen für Debugging, Versionierung und Collaboration (Zusammenarbeit mehrer Entwickler) nutzen.^[7]
Browser-Kompatibilität – Bei Konvertierung in JavaScript werden vom GWT die Eigenheiten der wichtigsten Browser (Internet Explorer, Firefox, Mozilla, Safari und Opera) berücksichtigt, so dass der keine Zeit auf Browser-spezifische Anpassungen verwendet werden muss.^[8]
Automatisierte Tests – Das GWT ermöglicht die Integration von JUnit zum automatisierten Testen.^[9]
Einbindung von JavaScript – Bei Bedarf kann nativer JavaScript-Code eingebunden werden. Zum Beispiel weil Programmteile schon fertig in JavaScript entwickelt sind. Hierfür stellt das GWT als Schnittstelle das JavaScript Native Interface (JSNI) zur Verfügung.^[10]

Bevor das GWT eingesetzt wird, sollte man aber auch folgende Punkte berücksichtigen:

Nicht von Suchmaschinen indizierbar – Da die Webcrawler der Suchmaschinen heutzutage kein JavaScript lesen und verarbeiten können, werden solche Anwendungen gar nicht oder nur sehr schlecht indiziert. Dieser Nachteil liegt aber an JavaScript im Allgemeinen und ist nicht GWT-spezifisch.^[11]
Nicht einfach degradierbar – JavaScript wird zwar bei den meisten Browsern mitgeliefert und erreicht deshalb eine hohe Verfügbarkeit, jedoch ist man beim GWT darauf angewiesen. Sollte ein Benutzer JavaScript deaktiviert haben, sieht er nur eine leere Seite. Die einzige Möglichkeit besteht darin, ihn darauf hinzuweisen JavaScript zu aktivieren. Vor allem bei beruflich genutzten Computern ist dies aber häufig aus Sicherheitsgründen nicht gewünscht. Sollen diese auch unterstützt werden, muss eine zweite Version der Anwendung vorgehalten werden. Andere Entwicklungs-Frameworks bieten hier bessere Möglichkeiten zur Degradierung als das GWT.^[12]
Keine klare Trennung zwischen Programmcode und Oberfläche/Layout - ^[13]

Komponenten

Die beschriebenen Funktionen des GWT sind in den vier (teilweise wird der GWT Hosted Web Browser nicht als eigene Komponente gezählt^[14]) Hauptkomponenten des GWT zusammengefasst, welche in diesem Abschnitt kurz beschrieben sind.

GWT Java-to-JavaScript Compiler – Dies ist der Kern des GWT. Der Compiler übersetzt Java-Programmcode vom Entwickler automatisch in JavaScript, wobei automatische Optimierungen vorgenommen werden.^[15]
GWT Hosted Web Browser – Erlaubt dem Entwickler GWT-Anwendungen im sog. Hosted-Modus auszuführen. Das bedeutet, die Anwendung wird als Java Bytecode in der JVM ausgeführt ohne als JavaScript kompiliert zu werden.^[16]
JRE Emulationsbibliothek – Wie bereits erwähnt, unterscheidet sich JavaScript sehr stark von Java. Damit GWT den geschriebenen Java-Code als JavaScript kompilieren kann stellt das GWT JavaScript-Implementierungen der gebräuchlichsten Klassen der Standard-Java-Bibliothek (z.B. Klassen aus java.lang und java.util) zu Verfügung.^[17]
GWT Web UI Klassenbibliothek – Schnittstellen und Klassen zur Erstellung von Widgets.^[18]

Bezug und Installation

In diesem Abschnitt wird erklärt, woher man das GWT beziehen kann, wie es installiert wird und welches die ersten Schritte zur Erstellung einer Anwendung sind.

Bezug

Zuerst sollte sichergestellt werden, dass das Java SDK installiert ist. Sollte das nicht der Fall sein kann man das Sun Java Standard Edition SDK direkt bei Java beziehen. Anschließend kann das GWT kostenlos direkt von Google bezogen werden. Die aktuelle Version kann auf dieser Seite für die Plattformen Windows, Linux und Mac bezogen werden: http://code.google.com/intl/de-DE/webtoolkit/versions.html. Die Datei ist mit 20-28MB (je nach Plattform) recht klein und sollte schnell herunterladbar sein, so dass man direkt zum nächsten Schritt übergehen kann: der Installation.

Installation

Nachdem das GWT heruntergeladen wurde, muss es zunächst entpackt werden. Das Toolkit muss nicht installiert werden, so dass alle benötigten Dateien im entpackten Ordner zu finden sind. Die Hauptanwendung ist der applicationCreator, welcher im Folgenden kurz beschrieben wird.

Beispieldateien

Google empfiehlt sich zuerst die mitgelieferten Beispieldateien anzusehen.^[19] Man findet diese im Unterordner samples/. Jedes Beispiel kann sowohl im sog. Hosted-Modus als auch im Web-Modus aufgerufen werden. Über projektname-shell.cmd öffnet man die Applikation im Hosted-Modus. D.h. sie wird als Java Bytecode mit der Java Virtual Machine ausgeführt, wobei das GWT einen Browser simuliert. Dieser Modus wird normalerweise während der Entwicklung zum Debugging verwendet, da auf alle Debugging-Funktionalitäten der eingesetzten Java-Entwicklungsumgebung zugegriffen werden kann, was die Entwicklung deutlich erleichtert Der Web-Modus hingegen zeigt, wie die Applikation fertig aussieht. Über projektname-compile.cmd kann die in Java geschriebene Applikation kompiliert und in JavaScript und HTML konvertiert werden, um sie im Browser anzuzeigen. Zur Veröffentlichung der Anwendung müssen die Dateien im Unterordner www/ in auf einen Webserver hochgeladen werden. Ein ausführliches „Getting Started“ findet man unter http://code.google.com/intl/de-DE/webtoolkit/gettingstarted.html, an dem diese Einführung orientiert ist.

Erste Schritte

Um eine neue Anwendung zu erzeugen, öffnet man den applicationCreator über die Kommandozeile. Im Beispiel unten würde das so aussehen:

Start -> Ausführen -> "cmd"
"cd D:\gwt\"
"applicationCreator org.keulmaassen.client.Gwtfinal"

Es lassen sich ebenfalls Projektdateien für die Entwicklungsumgebung Eclipse erzeugen. Dazu führt man zuerst den projectCreator über die Kommandozeile aus.

projectCreator -eclipse MeinProjekt

Anschließend wird wieder der applicationCreator ausgeführt, allerdings mit dem zusätzlichen Parameter –eclipse.

applicationCreator -eclipse MeinProjekt org.keulmaassen.client.Gwtfinal

Wenn man das Verzeichnis mit den erzeugten Ecplise-Dateien anschließend in Eclipse importiert, lässt sich dort an der Anwendung arbeiten und sie im Hosted-Modus ausführen.

Konkretes Beispiel

Beschreibung

Mit Hilfe dieses Beispiels sollen die Kerneigenschaften des Google Web Toolkits näher gebracht werden. Zu Beginn wird die typische Struktur von GWT-Projekten beschrieben. Im weiteren Verlauf wird auf die GWT typischen Tools eingegangen. Darunter fallen sogenannte Panels, Widgets und Listener. Zuletzt werden die beschriebenen Techniken in einem konkreten, lauffähigen Beispiel eingesetzt.

GWT-Beispiel

Projektstruktur

Die grundlegende Ordnerstruktur von GWT-Projekten werden durch die mitgelieferte Skripte applicationCreator und projectCreator erzeugt. Führt man das Skript applicationCreator ohne weitere Optionen in einer DOS-Box aus, wird die folgende Ordner- und Dateistruktur erzeugt. Das erzeugte Package heisst org.keulmaassen.client .

D:\gwt\samples\gwtexamplefinal>D:\gwt\applicationCreator org.keulmaassen.client.Gwtexamplefinal
Created directory D:\gwt\samples\gwtexamplefinal\src
Created directory D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen
Created directory D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\client
Created directory D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\public
Created file D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\Gwtexamplefinal.gwt.xml
Created file D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\public\Gwtexamplefinal.html
Created file D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\public\Gwtexamplefinal.css
Created file D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\client\Gwtexamplefinal.java
Created file D:\gwt\samples\gwtexamplefinal\Gwtexamplefinal-shell.cmd
Created file D:\gwt\samples\gwtexamplefinal\Gwtexamplefinal-compile.cmd

Verzeichnisse

D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen

Dies ist das Package-Root-Verzeichnis. Hier findet man alle zum Package gehörenden Unterordner bzw. Subpackages.

D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\client

Hier befinden sich die Java-Dateien aus denen durchs kompilieren Javascripts erzeugt werden.

D:\gwt\samples\gwtexamplefinal\src\org\keulmaassen\public

Im public Order werden jene Dateien abgelegt, die statisch sind. Dazu gehören z.B. Bilder, HTML, und Stylesheets.

Dateien

Gwtfinal.java

Das Google Web Toolkit bietet die Möglichkeit Java-Quellcode in Javascript umzuwandeln. Dateien mit Javacode befinden sich in den Unterordnern .../client/ und .../server. Klassen die sich im client-Ordner befinden werden später auch vom Browser des Benutzers ausgeführt. Dieses Javascript wird in eine Html-Datei eingebunden. Der typische name des Skriptes lautet nocache.js.

Gwtfinal.html

Bei der Gwtfinal.html handelt es sich um die Datei, die durch den Browser des Benutzers aufgerufen wird. Das hier eingebundene Javascript wird bei Aufruf ausgeführt. Zusammen mit weiteren statischen Dateien liegt diese Datei im public-Ordner des Projekts.

Eine HTML Host Page könnte dann wie folgt aussehen:

<html>
  <head>
 
    <!-- An dieser Stelle können Stylesheets eingebunden werden. -->
    <link rel="stylesheet" href="Calendar.css">
 
    <!-- Der Titel der Applikation-->
    <title>Calendar App</title>
 
  </head>
  <body>
 
    <!-- Der fully-qualified module name, gefolgt von 'nocache.js' -->
    <script language="javascript" src="com.example.cal.Calendar.nocache.js"></script>
 
  </body>
 </html>

^[20]

Gwtfinal.css

In der Gwtfinal.css werden Formatierungen vorgenommen um die Darstellung der Anwendung anzupassen.

Gwtfinal.gwt.xml

Diese Datei legt die Eigenschaften des Basismodules fest. Des Weiteren wird hier definiert von welche übergeordneten Modulen das Projekt erbt. Hier werden auch die EntryPoints festgelegt. Diese bestimmen welche Objekte beu Aufruf instanziert werden sollen.

Gwtfinal-shell.cmd und Gwtexamplefinal-compile.cmd

Das Skript Gwtexamplefinal-shell.cmd führt die Anwendung im Hosted Mode aus. Gwtexamplefinal-compile.cmd hingegen wandelt den Java Code in Javascript um, sodass man per Webbrwoser auf die Anwendung zugreifen kann.

GWT-Modules

GWT-Projekte können aus einem oder mehreren GWT-Modules bestehen. Aufgabe der Modules ist es Funtionalitäten für das GWT-Projekt bereitzustellen oder zu beschränken. Eine Module kann dabei von anderen Modules Funktionalität erben. Eine minimale Konfiguration für ein solches Module wäre wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<module>
	<inherits name="com.google.gwt.user.User"/>
	<entry-point class="org.example.client.MainEntryPoint"/>
</module>

<inherits name="com.google.gwt.user.User"/>

Dieses Modul ist fundamental für Benutzeroberfläche in GWT-Projekten.

<entry-point class="org.example.client.MainEntryPoint"/>

Jede Klasse, die das EntryPoint Interface implementiert, muss hier definiert sein. Die Anzahl der Klassen ist dabei unbegrenzt. Wenn ein Modul geladen wird, werden alle als EntryPoint definierten Klassen instanziert. Bei der Instanzierung wird die OnModuleLoad-Methode augrufen. ^[21]

Werkzeuge und Methoden

Widgets - Widgets sind Objekte die, die grafische Darstellung von Ein- und Ausgabe per Benutzerobefläsche unterstützen. Zu Widgets gehören Schaltflächen, Texteingabefenster, Dropdown-Menüs aber auch komplexeres wie z.B. Trees und calendars. Eine ausführliche Zusammenfassung der wichtigsten Widgets findet man unter diesem Link

Panels - Panels sind besondere Widgets, die wiederrum weitere Widgets enthalten können. Panels dienen dabei fast ausschliesslich der Gestaltung des Layouts. Eine Liste der GWT spezifischen Panels findet man unter diesem Link.

Listener - Listener werden eingesetzt um Events abzufangen. Es gibt viele unterschiedliche Arten von Listener, die auf spezielle Events hören. Zu diesen Events gehören z.B. der Klick auf eine Schaltfläche und Eingaben durch die Tastatur. Die Events gehen dabei von Widgets aus. Jedes dieser Widgets hat einen Sender, der bei Bedarf ein Signal sendet, welches der Listener empfängt. Der im Beispiel eingesetzte PushButton nutzt Listener, um den MouseOver-Effekt zu realisiseren.

Implementierung

Gwtfinal.java

package org.keulmaassen.client;
 
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.Frame;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.PushButton;
import com.google.gwt.user.client.ui.TabPanel;
 
// Die Klasse Gwtfinal implementiert die Klasse EntryPoint.
public class Gwtfinal implements EntryPoint{
  public void onModuleLoad() { // Wird bei Aufruf ausgeführt.
 
// HTML Code, in diesem Fall einen DIV-Container erzeugen.
 
    HTML header = new HTML( "<div id='headerslot'>
<div id ='imageslot'>
</div>
Diese mit dem Google Web Toolkit erzeugt Mini-Webseite soll beispielhaft Widgets, 
Panels und weitere Techniken näher bringen </div>");
 
    // Hier wird per IFRAME das EUFH WIKI huinzugefügt.
    Frame frame = new Frame("http://www.eufh.de/wiki/Google_Web_Toolkit#Konkretes_Beispiel");
    frame.setWidth("100%");
    frame.setHeight("450px");
    // ---------------------------------------
 
    // Das EUFH Logo im Header
    Image imagewidget = new Image("logo.gif"); // Das EUFH Logo
 
    // Pushbutton
    PushButton pushbutton = new PushButton("Click Me", "Get Off!");
    pushbutton.setStylePrimaryName("demo-PushButton");
 
 
 
    /* Hier werden die Tabs für das TabPanel vordefiniert*/
    TabPanel tabs = new TabPanel();
    tabs.setStyleName("gwt-TabPanel");
    tabs.add(new HTML("<div id='installation'></div>"), "IFRAME");
    tabs.add(new HTML("<div id='pushbuttonslot'></div>"), "Buttons");
    tabs.add(new HTML("Platzhalter"), "Beispiel");
    tabs.setWidth("100%");
    tabs.setHeight("500px");
    tabs.selectTab(0);
 
    // pushbutton, TabPanel, usw werden ausgegeben.
    // get("...") dient dazu, z.B. das Image an einer 
    // gekennzeichneten Stelle auszugeben. 
    RootPanel.get().add(header);
    RootPanel.get("imageslot").add(imagewidget);
    RootPanel.get().add(tabs);
    RootPanel.get("installation").add(frame);
    RootPanel.get("pushbuttonslot").add(pushbutton);
  }
}

Gwtfinal.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <script type="text/javascript" language="javascript" src="org.keulmaassen.Gwtfinal.nocache.js"></script>
  </head>
  <body>
  </body>
</html>

Gwtfinal.css

.gwt-TabPanel {
  margin-top: 40px;
  border: 1px solid silver;
}
 
.gwt-TabPanelBottom {
  background-color: #E8E8E8;
}
 
.gwt-TabBar {
  padding-top: 2px;
  border-bottom: 4px solid #878787;
  background-color: #fff;
}
 
.gwt-TabBarItem {
  padding: 4px;
  cursor: pointer;
  background-color: #e8e8e8;
  border-bottom: 2px solid white;
  margin-right: 2px;
}
 
.gwt-TabBarItem-selected {
  padding: 4px;
  font-weight: bold;
  cursor: default;
 
  background-color: #878787;
  border-bottom: 2px solid #87ffff;
  margin-right: 2px;
}
 
 
.demo-PushButton
{
    border                      :   1px solid #666;
    margin                      :   3px 1px;
    font-size                   :   80%;
    cursor                      :   hand;
    cursor                      :   pointer;
    background-color            :   #ff0;
    padding                     :   0 10px;
    width                       :   100px;
}
.demo-PushButton-down-hovering
{
    background-color            :   #ccf;
}
.demo-PushButton-up-hovering
{
    background-color            :   #0f0;
}

Gwtfinal.gwt.xml

<module>
      <inherits name='com.google.gwt.user.User'/>
      <inherits name='com.google.gwt.user.theme.standard.Standard'/>
      <entry-point class='org.keulmaassen.client.Gwtfinal'/>
      <stylesheet src='Gwtfinal.css' />
 
</module>

Quellenangaben

↑ Vgl. Steyer, R.: Das Google Web Toolkit, in: http://www.contentmanager.de/magazin/artikel_1292_google_web_toolkit_gwt_ajax_java.html, zugegriffen am 31.12.2008.
↑ Vgl. Seemann, M.: Das Google Web Toolkit GWT, O’Reilly 2007, S. 3.
↑ Vgl. Steyer, R.: Das Google Web Toolkit, in: http://www.contentmanager.de/magazin/artikel_1292_google_web_toolkit_gwt_ajax_java.html, zugegriffen am 31.12.2008.
↑ Google: Google Web Toolkit - Product Overview, in: http://code.google.com/intl/de/webtoolkit/overview.html, zugegriffen am 31.12.2008.
↑ Vgl. Steyer, R.: Das Google Web Toolkit, in: http://www.contentmanager.de/magazin/artikel_1292_google_web_toolkit_gwt_ajax_java.html, zugegriffen am 31.12.2008.
↑ Vgl. Steyer, R.: Das Google Web Toolkit, in: http://www.contentmanager.de/magazin/artikel_1292_google_web_toolkit_gwt_ajax_java.html, zugegriffen am 31.12.2008.
↑ Google: Google Web Toolkit - Product Overview, in: http://code.google.com/intl/de/webtoolkit/overview.html, zugegriffen am 31.12.2008.
↑ Google: Google Web Toolkit - Product Overview, in: http://code.google.com/intl/de/webtoolkit/overview.html, zugegriffen am 31.12.2008.
↑ Google: Google Web Toolkit - Product Overview, in: http://code.google.com/intl/de/webtoolkit/overview.html, zugegriffen am 31.12.2008.
↑ Vgl. Steyer, R.: Das Google Web Toolkit, in: http://www.contentmanager.de/magazin/artikel_1292_google_web_toolkit_gwt_ajax_java.html, zugegriffen am 31.12.2008.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 22.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 22.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 22.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 23.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 23.
↑ Vgl. Wikipedia: Google Web Toolkit, in: http://en.wikipedia.org/wiki/Google_Web_Toolkit#Components, zugegriffen am 31.12.2008.
↑ Vgl. Smeets, B., Boness, U., Bankras, R.: Beginning Google Web Toolkit, From Novice to Professional, Apress, New York 2008, S. 23.
↑ Vgl. Wikipedia: Google Web Toolkit, in: http://en.wikipedia.org/wiki/Google_Web_Toolkit#Components, zugegriffen am 31.12.2008.
↑ Vgl. Google: Getting Started, in: http://code.google.com/intl/de-DE/webtoolkit/gettingstarted.html, zugegriffen am 31.12.2008.
↑ Vgl. Embedding the Application: The Host Page, in: http://code.google.com/intl/de-DE/docreader/#p=google-web-toolkit-doc-1-5&s=google-web-toolkit-doc-1-5&t=DevGuideHostPage, zugegriffen am 31.12.08.
↑ Vgl. Developerlife: GWT Tutorial - Anatomy of a GWT Project, in: http://developerlife.com/tutorials/?p=124, zugegriffen am 31.12.08.

Von „http://www.eufh.de/wiki/Google_Web_Toolkit“

Kategorie: Entwicklung von E-Business Systemen