GWT im Einsatz

Inhalt

Vorwort

Danksagung

Zu diesem Buch

Teil 1 Erste Schritte

2 Die Standardanwendung erstellen

2.1 Der Entwicklungslebenszyklus der GWTStandardanwendung

2.2 Phase 1: Eine GWT- Anwendung erstellen

2.2.1 Das Projekt erstellen

2.2.2 Eine Anwendung erstellen

2.2.3 Internationalisierung einrichten

2.2.4 Internationalisierung implementieren

2.2.5 Unit-Testfälle erstellen

2.2.6 Import in ein IDE

2.3 Zusammenfassung

3 Zur eigenen Anwendung fortschreiten

3.1 Beschreibung des Anwendungsbeispiels

3.2 Phase 2: Die Anwendung entwickeln

3.2.1 Internationalisierung implementieren

3.2.2 Anwendung erstellen

3.2.3 Formate anwenden

3.3 Phase 3: Testen und Debuggen im Hostmodus

3.3.1 Auf den Hostmodus vorbereiten

3.3.2 Dashboard im Hostmodus ausführen

3.3.3 Dashboard im Hostmodus mit Eclipse debuggen

3.4 Phase 4: Code kompilieren

3.4.1 Code kompilieren und für den Webmodus vorbereiten

3.4.2 Kompilierungsergebnisse anzeigen

3.5 Phase 5: Code bereitstellen

3.5.1 Bereitstellung auf einem Webserver

3.5.2 Bereitstellung auf einem Dateisystem

3.6 Phase 6: Ausführung im Webmodus

3.7 Anwendungsprotokollierung implementieren

3.7.1 Informationen auf der Clientseite protokollieren

3.7.2 Informationen auf der Serverseite protokollieren

3.8 Zusammenfassung

Teil 2 Benutzeroberflächen erstellen

4 Mit Widgets arbeiten

4.1 Was ist ein Widget?

4.2 Die Standard-Widgets in GWT

4.3 Neue Widgets erstellen

4.4 Das Dashboard-Widget entwickeln

4.5 Zusammenfassung

5 Mit Panels arbeiten

5.1 Was ist ein Panel?

5.1.1 Panels als Java-Objekte verwenden

5.1.2 Panels als DOM-Elemente betrachten

5.2 Die Standard-Panels in GWT

5.2.1 Mit einfachen Panels interagieren

5.2.2 Komplexere Panels

5.2.3 Auf HTML-Tabellen basierende Panels

5.2.4 Zusammengesetzte Panels

5.3 Neue Panels erstellen

5.3.1 Panels von Grund auf neu erstellen

5.3.2 Panels durch Erweiterung eines vorhandenen Panels erstellen

5.4 Das Panel erstellen

5.5 Zusammenfassung

6 Ereignisbehandlung

6.1 Ereignisse untersuchen

6.1.1 Unterschiede bei browserspezifischen Ereignismodellen

6.1.2 Das GWT-Ereignisbehandlungsmodell

6.2 Auf Ereignisse horchen

6.2.1 Ereignisse versenken

6.2.2 Versenkte Ereignisse mit der Methode verwalten

6.2.3 Versenkte Ereignisse mit der Methode verknüpfen

6.2.4 Ereignisvorschau

6.2.5 Ereignisse durch Erweiterung von Listener-Klassen behandeln

6.2.6 Ereignisse in Ihren GWT-Code verschieben

6.2.7 Ereignisbehandlung durch den Browser verhindern

6.3 Browser-Standardereignisse behandeln

6.3.1 Auf Änderungen reagieren

6.3.2 Klick, klick

6.3.3 Fokus erhalten und verlieren

6.3.4 Tastatureingaben erfassen

6.3.5 Bilder laden

6.3.6 Mauseingaben verwalten

6.3.7 Bildlauf

6.3.8 Fenstergrößenänderung

6.3.9 Schließ-Ereignisse

6.4 Andere Ereignistypen behandeln

6.4.1 Formulare behandeln

6.4.2 Auf schließende Popup-Fenster reagieren

6.4.3 Registerkarten-Ereignisse

6.4.4 Tabellenereignisse

6.4.5 Baumstruktur-Ereignisse

6.5 Drag & Drop implementieren

6.5.1 Ziehen implementieren

6.5.2 Ablegen implementieren

6.6 Zusammenfassung

7 Zusammengesetzte Widgets erstellen

7.1 Was ist ein zusammengesetztes Widget?

7.2 Die Entwicklung zusammengesetzter Widgets

7.3 Editierbare Beschriftungen erstellen

7.3.1 Schritt 1: Komponenten ermitteln

7.3.2 Schritt 2: Panel-Layout und Struktur auswählen

7.3.3 Schritt 3: Die passenden GWT-Java-Schnittstellen implementieren

7.3.4 Schritt 4: Das zusammengesetzte Widget erstellen

7.3.5 Schritt 5: Das zusammengesetzte Widget formatieren

7.4 Ein zusammengesetztes Widget aus anderen zusammengesetzten Widgets erstellen

7.4.1 Schieberegler erstellen

7.4.2 Das Composite

erstellen

7.5 Das Dashboard-Composite erstellen

7.6 Zusammenfassung

8 JSNI-Komponenten erstellen

8.1 Einführung in JSNI

8.1.1 JSNI im Überblick

8.2 Kommunikation via JSNI

8.2.1 Mit dem Browser via GWT-Java kommunizieren

8.2.2 Mit dem Browser via JavaScript kommunizieren

8.2.3 Über eine JavaScript- API mit einer GWT- Anwendung kommunizieren

8.2.4 Kommunikation zwischen GWT- Anwendungen

8.3 Eine JavaScript-Bibliothek laden

8.3.1 Mit HTML eine JavaScript-Bibliothek laden

8.3.2 Mit der Modul-XML-Datei eine JavaScript-Bibliothek laden

8.4 Eine einfache JavaScript-Bibliothek kapseln

8.4.1 Auf eine geladene JavaScript-Bibliothek zugreifen

8.4.2 Das Widget in einer Anwendung einsetzen

8.5 Eine komplexe JavaScript-Bibliothek kapseln

8.5.1 Klassen erstellen

8.5.2 JavaScript-Objekte als Java-Objekte belassen

8.5.3 Benutzerdefinierten Code aus einer Bibliothek aufrufen

8.5.4 Komplexes, gekapseltes Widget in einer Anwendung einsetzen

8.6 Zusammenfassung

9 Eine Anwendung modularisieren

9.1 Modularisierungsstruktur erstellen

9.1.1 Modularisierung in GWT

9.1.2 Andere Module in eine Anwendung einbinden

9.1.3 Quell- und andere Ressourcenpfade festlegen

9.1.4 Serverressourcen einer Anwendung definieren

9.1.5 Die GWT-Eigenschaften einer Anwendung verwalten

9.1.6 Klassen basierend auf Eigenschaftswerten ersetzen

9.1.7 Generatoren in der Modul-XML-Datei registrieren

9.1.8 Ressourcen zur Laufzeit in eine Anwendung injizieren

9.1.9 Den Eintrittspunkt einer Anwendung festlegen

9.1.10 Die Modul-XML-Datei der Anwendung

9.2 Drittanbietermodule einbinden

9.3 Eigene Module packen

9.4 Java-Package-Struktur erstellen

9.5 Zusammenfassung

Teil 3 Fortgeschrittene Techniken

10 Kommunikation mit GWT-RPC

10.1 Grundlegende RPC-Konzepte

10.1.1 Überblick zur asynchronen Kommunikation

10.1.2 Beschränkungen bei der Kommunikation mit Remoteservern

10.1.3 Das Projekt

10.2 GWT-RPC implementieren

10.2.1 Überblick zu den serialisierbaren Datenobjekten

10.2.2 Den GWT-RPC-Dienst definieren

10.2.3 Vorbereitung der Clientseite eines GWT-RPC-Aufrufs

10.2.4 Aufruf des entfernten Serverdienstes

10.3 Zusammenfassung des Projekts

10.3.1 Projektübersicht

10.3.2 Serverseitige Dienstimplementierung

10.3.3 Aufruf des Dienstes auf dem Client

10.4 Zusammenfassung

11 Die clientseitige RPC-Architektur

11.1 Clientcode strukturieren

11.1.1 Die Komponente kapseln

11.1.2 Remoteaufrufe in einer Fassade kapseln

11.1.3 Rückrufroutine mit dem Kommandomuster

11.2 Verschiedene Abfragetechniken untersuchen

11.2.1 Aspekte der Abfragetechnik

11.2.2 Implementierung einer sich fortlaufend aktualisierenden Komponente

11.2.3 Server-Pushs durch Blockieren von Server-Threads emulieren

11.3 Benutzerdefinierte Feldserialisierer schreiben

11.3.1 Klasse für einen benutzerdefinierten Feldserialisierer erstellen

11.3.2 Benutzerdefinierte Feldserialisierung implementieren

11.4 Zusammenfassung

12 Klassisches Ajax und HTMLFormulare

12.1 Klassisches Ajax mit

12.1.1 HTTP-Methoden

12.1.2 Einfaches RPC mit

12.1.3 Mit XML-Daten laden

12.2 Grundlagen zu

12.2.1 Grundlagen zu

12.2.2 Auf Ereignisse hören

12.2.3 Ziel ändern

12.2.4 Verschiedene Formularelemente verwenden

12.3 Zusammenfassung

13 Interoperabilität mit JSON erzielen

13.1 Einführung in JSON

13.1.1 Das JSON-Datenformat

13.1.2 Mit JSONParser JSON-Nachrichten analysieren

13.2 Die JSON-Datenobjekte in GWT

13.2.1 Das Objekt

13.2.2 Grundlegende JSON-Typen

13.2.3 JSONValue-Objekte in einem JSONArray speichern

13.2.4 JSONValue-Objekte in einem JSONObject sammeln

13.3 Suchkomponente mit JSON erstellen

13.3.1 Die Yahoo Search- API

13.3.2 Suchkomponente implementieren

13.3.3 JSON-Daten an den Server senden

13.3.4 JSON-Serverantwort analysieren und validieren

13.4 Proxy-Dienst für Yahoo Search implementieren

13.4.1 JSON mit Java auf dem Server verwenden

13.4.2 JSON mit Perl auf dem Server verwenden

13.4.3 JSON mit Ruby auf dem Server verwenden

13.5 Zusammenfassung

14 Automatische Codegenerierung

14.1 Neue Typen generieren

14.2 GWT-Generatoren

14.2.1 Grundlegender Generatorcode

14.3 Generator für das Dashboard erstellen

14.3.1 Auf die Eingabeklasse zugreifen

14.3.2 Auf Kontexteigenschaften zugreifen

14.3.3 Protokollierung für Generatoren

14.3.4 Generieren der neuen Typenstruktur

14.3.5 Die neue Klasse erstellen

14.3.6 Generierte Klassen verwenden

14.4 Zusammenfassung

15 Anwendungen basierend auf GWTEigenschaften modifizieren

15.1 Kurze Zusammenfassung zu den Eigenschaften

15.2 Browserunterschiede verwalten

15.2.1 Wie GWT Browserunterschiede verwaltet

15.2.2 Das Flash-Widget erstellen

15.2.3 Eigenschaftsersetzung einrichten

15.3 Vollständige Unterstützung der Internationalisierung

15.3.1 Die statische Internationalisierung

15.3.2 Die dynamische Internationalisierung

15.4 Anwendung gebietsschemaspezifisch ändern

15.4.1 Standardkomponente implementieren

15.4.2 Gebietsschemaspezifische Klassen

15.5 Benutzerdefinierte Eigenschaften implementieren

15.5.1 Benutzerdefinierte Eigenschaften definieren

15.5.2 Benutzerdefinierten Eigenschaftsanbieter definieren

15.5.3 Ermittelten Eigenschaftswert überprüfen

15.5.4 Code erstellen

15.6 Zusammenfassung

Teil 4 Abschließende Ergänzungen

16 GWT-Anwendungen testen und bereitstellen

16.1 GWT-Code mit JUnit testen

16.1.1 JUnit für GWT-Entwickler

16.1.2 Testfall erstellen

16.1.3 Asynchronen Code testen

16.2 GWT- Anwendungen bereitstellen

16.2.1 Projekt organisieren

16.2.2 RPC-Servlets installieren

16.3 Zusammenfassung

17 Wie GWT funktioniert

17.1 Der Kompilierungsprozess und die Ausgabe

17.1.1 Der Kompilierungsvorgang

17.1.2 Was der Compiler ausgibt

17.2 Der Lademechanismus von GWT

17.2.1 Altanwendungen

17.2.2 Standardanwendungen

17.2.3 Bootstrapping für die Standardanwendung

17.2.4 Website-übergreifende Anwendungen

17.3 Java in JavaScript kompilieren

17.3.1 Das generierte JavaScript untersuchen

17.3.2 Java-Standardobjekte: Das

Objekt

17.3.3 Programmcode als JavaScript untersuchen

17.3.4 Überblick über das Initialisierungscodesegment

17.4 Zusammenfassung

Register