• Tapestry 5 - Die Entwicklung von Webanwendungen mit Leichtigkeit

  Seite I

• Inhaltsübersicht

  Seite 5

• + Inhaltsverzeichnis

  Seite 7

  • Einleitung

    Seite 7

  • Vorwort von Howard M. Lewis Ship

    Seite 7

  • Danksagungen

    Seite 7

  • + Teil I Tapestry für Einsteiger

    Seite 7

    • 1 Von Servlets bis MVC-Frameworks

      Seite 7

    • 2 Tapestry-Schnelleinstieg

      Seite 7

    • 3 Tapestry als ereignisgetriebenes MVC-Framework

      Seite 7

    • 4 Navigation zwischen Seiten

      Seite 8

    • 5 Entwicklung von zustandsbehafteten Anwendungen

      Seite 8

    • 6 Lokalisierung

      Seite 8

    • 7 Formulare

      Seite 9

    • 8 Dynamische Formulare

      Seite 9

    • 9 Arbeiten mit JavaBeans

      Seite 9

    • 10 Multimedia-Inhalte

      Seite 10

  • + Teil II Tapestry für Fortgeschrittene

    Seite 10

    • 11 Entwicklung wiederverwendbarer Komponenten

      Seite 10

    • 12 Mixins

      Seite 11

    • 13 Ajax

      Seite 11

    • 14 Integration von Hibernate und Spring

      Seite 11

    • 15 Testen von Tapestry-Anwendungen

      Seite 12

    • 16 Sicherheit

      Seite 12

  • + Teil III Tapestry für Profis

    Seite 12

    • 17 Tapestry IoC und Dependency Injection

      Seite 12

    • 18 AOP mit Tapestry

      Seite 13

    • 19 Typumwandlung/Type Coercion

      Seite 14

    • 20 Verarbeitung von Anfragen durch Tapestry

      Seite 14

    • 21 Bytecodemanipulation mit Tapestry

      Seite 14

  • A Anhang

    Seite 14

  • Stichwortverzeichnis

    Seite 16

• Einleitung

  Seite 17

• Vorwort von Howard M. Lewis Ship

  Seite 21

• Danksagungen

  Seite 23

• + Teil I Tapestry für Einsteiger

  Seite 25

  • + 1 Von Servlets bis MVC-Frameworks

    Seite 27

    • 1.1 Wie alles begann

      Seite 27

    • 1.2 Model View Controller

      Seite 30

    • 1.3 Tapestry und das Model View Controller Pattern

      Seite 31

    • 1.4 Zusammenfassung

      Seite 32

  • + 2 Tapestry-Schnelleinstieg

    Seite 35

    • 2.1 Starten von Tapestry-Anwendungen mit Eclipse Web Tools Platform

      Seite 35

    • 2.2 Starten von Tapestry-Anwendungen mit Run-Jetty-Run

      Seite 40

    • + 2.3 Struktur von Tapestry-Anwendungen

      Seite 42

      • 2.3.1 Tapestry-Seiten

        Seite 42

      • 2.3.2 Tapestry Markup Language

        Seite 44

      • 2.3.3 Tapestry-Komponenten

        Seite 50

      • 2.3.4 Tapestry IoC

        Seite 56

    • 2.4 Nonstop-Entwicklung mit Tapestry

      Seite 57

    • 2.5 Fehlerberichte

      Seite 58

    • 2.6 Zusammenfassung

      Seite 59

  • + 3 Tapestry als ereignis-getriebenes MVC-Framework

    Seite 61

    • 3.1 Behandeln der Benutzeraktionen

      Seite 61

    • 3.2 Namenskonvention vs. Annotationen

      Seite 63

    • 3.3 Kontext eines Ereignisses

      Seite 64

    • 3.4 Erzeugen einer Antwort mit Handler-Methoden

      Seite 65

    • 3.5 Auslösen von Ereignissen mit der Komponente EventLink

      Seite 67

    • 3.6 Programmatisches Auslösen eigener Ereignisse

      Seite 68

    • 3.7 Event Bubbling

      Seite 70

    • 3.8 Abfangen von Exceptions aus Handler-Methoden

      Seite 70

    • 3.9 Zusammenfassung

      Seite 71

  • + 4 Navigation zwischen Seiten

    Seite 73

    • 4.1 Erstellen von Verweisen zwischen Seiten

      Seite 73

    • 4.2 Übermitteln von Informationen an eine Zielseite

      Seite 74

    • + 4.3 Übermitteln von Informationen an eine Tapestry-Seite

      Seite 76

      • 4.3.1 Generieren von Handler-Methoden für den Aktivierungskontext

        Seite 81

    • 4.4 Navigation durch Aktionen

      Seite 82

    • 4.5 Zusammenfassung

      Seite 86

  • + 5 Entwicklung von zustands-behafteten Anwendungen

    Seite 87

    • 5.1 Lebenszyklus eines Servlets

      Seite 87

    • 5.2 Lebenszyklus einer JavaServer Page

      Seite 88

    • + 5.3 Lebenszyklus einer Tapestry-Seite

      Seite 88

      • 5.3.1 Teilnehmen am Lebenszyklus einer Tapestry-Seite

        Seite 89

      • 5.3.2 Wann werden pageLoaded(), pageAttached() und pageDetached() aufgerufen?

        Seite 92

    • + 5.4 Verwalten des Seitenzustandes

      Seite 94

      • 5.4.1 Strategien zum Zwischenspeichern der Eigenschaften

        Seite 95

      • 5.4.2 Verwerfen des Zustands einer Seite

        Seite 97

      • 5.4.3 Unterbinden des Verwerfens des Seitenzustands

        Seite 98

    • + 5.5 Verwaltung des Anwendungszustandes

      Seite 98

      • 5.5.1 Erzeugen eines Session State Objects

        Seite 99

      • 5.5.2 Überprüfung der Existenz eines Session State Objects

        Seite 100

      • 5.5.3 Arbeiten mit dem Dienst ApplicationStateManager

        Seite 101

      • 5.5.4 Eingreifen in den Prozess der Instanziierung eines Session State Objects

        Seite 102

    • 5.6 Zusammenfassung

      Seite 103

  • + 6 Lokalisierung

    Seite 105

    • 6.1 Internationalisierung und Lokalisierung in Java

      Seite 105

    • 6.2 Anwendungsweiter Nachrichtenkatalog

      Seite 106

    • 6.3 Komponenten-Nachrichtenkatalog

      Seite 106

    • 6.4 Lokalisierte Templates

      Seite 106

    • 6.5 Zugreifen auf den Nachrichtenkatalog

      Seite 107

    • 6.6 Unterstützte Sprachen

      Seite 109

    • 6.7 Lokalisierung statischer Ressourcen

      Seite 109

    • 6.8 Umschalten zwischen unterstützten Sprachen einer Anwendung

      Seite 112

    • 6.9 Zusammenfassung

      Seite 115

  • + 7 Formulare

    Seite 117

    • 7.1 Erzeugen eines einfachen Login-Formulars

      Seite 118

    • 7.2 Behandlung der Ereignisse der Komponente Form

      Seite 121

    • 7.3 Mehrere Formulare auf einer Seite

      Seite 125

    • + 7.4 Überblick über Tapestrys Formularkomponenten

      Seite 126

      • 7.4.1 Texteingabe in Text- und Passwortfelder

        Seite 126

      • 7.4.2 Checkboxen

        Seite 129

      • 7.4.3 Radiobuttons

        Seite 131

      • 7.4.4 Auswahllisten

        Seite 134

      • 7.4.5 Palette

        Seite 139

      • 7.4.6 Eingabe eines Datums

        Seite 141

      • 7.4.7 Hochladen von Dateien

        Seite 143

      • 7.4.8 Abschicken von Formularen

        Seite 146

    • 7.5 Labels für Formularfelder

      Seite 148

    • + 7.6 Eingabevalidierung

      Seite 150

      • 7.6.1 Überschreiben von Validierungsmeldungen

        Seite 154

      • 7.6.2 Eigene Validatoren

        Seite 155

    • 7.7 Null-Werte in Formularfeldern

      Seite 160

    • 7.8 Umwandlung von Eingaben zwischen Client und Server

      Seite 162

    • 7.9 Zusammenfassung

      Seite 167

  • + 8 Dynamische Formulare

    Seite 169

    • + 8.1 Variable Anzahl von Formularfeldern

      Seite 169

      • 8.1.1 Beispielszenario

        Seite 170

      • 8.1.2 Implementierung des Beispielszenarios

        Seite 171

    • + 8.2 Erweitern der Formulare durch Benutzerinteraktionen

      Seite 176

      • 8.2.1 Beispielszenario

        Seite 176

      • 8.2.2 Implementierung des Beispielszenarios

        Seite 176

    • 8.3 Teilformulare

      Seite 179

    • 8.4 Zusammenfassung

      Seite 182

  • + 9 Arbeiten mit JavaBeans

    Seite 183

    • + 9.1 Formulare für JavaBeans

      Seite 183

      • 9.1.1 Don’t Repeat Yourself

        Seite 183

      • 9.1.2 Generieren von Formularen mit BeanEditForm

        Seite 185

      • 9.1.3 Verstecken bestimmter Eigenschaften von JavaBeans

        Seite 187

      • 9.1.4 Angepasste Formularfelder

        Seite 189

      • 9.1.5 Reihenfolge der Formularfelder

        Seite 191

      • 9.1.6 Virtuelle Eigenschaften

        Seite 192

      • 9.1.7 Programmatisches Ändern von Metadaten einer JavaBean

        Seite 192

      • 9.1.8 Eingabenvalidierung

        Seite 194

    • 9.2 Darstellen von JavaBeans

      Seite 196

    • + 9.3 Darstellen mehrerer JavaBeans

      Seite 197

      • 9.3.1 Paging

        Seite 200

      • 9.3.2 Zugriff auf die Werte der aktuellen Iteration

        Seite 201

      • 9.3.3 Überschreiben der Darstellung von Spalten

        Seite 202

    • + 9.4 Datentypen von Eigenschaften

      Seite 203

      • 9.4.1 Neue Datentypen zum Editieren von Eigenschaften

        Seite 203

      • 9.4.2 Neue Datentypen zum Darstellen von Eigenschaften

        Seite 205

    • 9.5 Zusammenfassung

      Seite 207

  • + 10 Multimedia-Inhalte

    Seite 209

    • 10.1 Senden eines einfachen Textes als Bytestrom

      Seite 209

    • 10.2 Anbieten einer Download-Funktionalität

      Seite 210

    • 10.3 Anzeigen eines Diagramms

      Seite 212

    • 10.4 Zusammenfassung

      Seite 215

• + Teil II Tapestry für Fortgeschrittene

  Seite 217

  • + 11 Entwicklung wieder-verwendbarer Komponenten

    Seite 219

    • 11.1 Bestandteile einer Komponente

      Seite 219

    • 11.2 Parameter von Komponenten

      Seite 219

    • 11.3 Bidirektionale Parameter

      Seite 221

    • + 11.4 Standard-Bindings der Parameter

      Seite 222

      • 11.4.1 Standard-Binding-Methoden

        Seite 224

      • 11.4.2 Generierung von Standard-Binding-Methoden

        Seite 225

    • 11.5 Vererbung von Bindings

      Seite 226

    • 11.6 Eigene Binding-Präfixe

      Seite 228

    • 11.7 Markup-Erzeugung einer Komponente

      Seite 232

    • 11.8 Informelle Parameter

      Seite 236

    • 11.9 Vererben von Templates

      Seite 237

    • 11.10 Umgebungsdienste

      Seite 239

    • 11.11 Komponentenbibliotheken

      Seite 241

    • 11.12 Zusammenfassung

      Seite 243

  • + 12 Mixins

    Seite 245

    • 12.1 Was sind Mixins?

      Seite 245

    • 12.2 Instanz-Mixins

      Seite 249

    • 12.3 Implementierungs-Mixins

      Seite 251

    • 12.4 Parameter von Mixins

      Seite 252

    • 12.5 Mixins in Tapestry

      Seite 253

    • 12.6 Zusammenfassung

      Seite 254

  • + 13 Ajax

    Seite 255

    • 13.1 Einfache Ajax-Funktionalität

      Seite 255

    • 13.2 Aktualisieren von Zones mit zusätzlichem Inhalt

      Seite 258

    • 13.3 Visuelle Rückmeldung über Ajax-Updates

      Seite 261

    • 13.4 Aktualisierung mehrerer Zones

      Seite 261

    • 13.5 Ajax-Unterstützung in Tapestry-Komponenten

      Seite 264

    • 13.6 Ajax und JavaScript

      Seite 265

    • 13.7 Optimierung der Ladezeit durch Ajax

      Seite 266

    • + 13.8 Erzeugen eines Autovervollständigers

      Seite 269

      • 13.8.1 Erweitern von Autocomplete

        Seite 271

    • 13.9 Eigene Ajax-Komponenten

      Seite 275

    • 13.10 Zusammenfassung

      Seite 278

  • + 14 Integration von Hibernate und Spring

    Seite 281

    • + 14.1 Integration von Hibernate

      Seite 281

      • 14.1.1 Konfiguration von Hibernate in Tapestry-Anwendungen

        Seite 281

      • 14.1.2 Zugriff auf die Hibernate-Session

        Seite 282

      • 14.1.3 Commit von Transaktionen

        Seite 283

      • 14.1.4 Hibernate-Entitäten als Aktivierungskontext

        Seite 284

      • 14.1.5 Zwischenspeichern von Entitäten mit @Persist

        Seite 284

      • 14.1.6 Darstellen der Hibernate-Entitäten mit Komponente Grid

        Seite 285

      • 14.1.7 Zugriff auf Hibernate-Metriken

        Seite 286

      • 14.1.8 Suche nach Hibernate-Entitäten

        Seite 287

      • 14.1.9 Teilnahme an der Hibernate-Konfiguration

        Seite 288

      • 14.1.10 Konfiguration der Hibernate-Integrationsbibliothek

        Seite 289

    • + 14.2 Integration von Spring

      Seite 289

      • 14.2.1 Konfiguration von Spring

        Seite 290

      • 14.2.2 Benutzen von Spring-Beans in Tapestry-Anwendungen

        Seite 292

      • 14.2.3 Benutzung von Tapestry-Diensten in Spring-Beans

        Seite 294

      • 14.2.4 Benutzung von Spring-Beans in Seiten und Komponenten

        Seite 296

    • 14.3 Zusammenfassung

      Seite 296

  • + 15 Testen von Tapestry- Anwendungen

    Seite 299

    • 15.1 Unit-Tests für Dienste

      Seite 299

    • + 15.2 Unit-Tests für Seiten und Komponenten

      Seite 302

      • 15.2.1 Einfacher Unit-Test für eine Seite

        Seite 302

      • 15.2.2 Unit-Tests zur Überprüfung von Markup

        Seite 304

      • 15.2.3 Testen von Links

        Seite 305

      • 15.2.4 Testen von Formularen

        Seite 306

      • 15.2.5 Überschreiben von Diensten zur Verbesserung der Testbarkeit

        Seite 309

      • 15.2.6 Testen von Komponenten

        Seite 311

    • + 15.3 Integrationstests

      Seite 312

      • 15.3.1 Ein einfacher Integrationstest

        Seite 312

      • 15.3.2 Klicken auf Links in Integrationstests

        Seite 313

      • 15.3.3 Testen von Formularen in Integrationstests

        Seite 314

      • 15.3.4 Testen von Ajax-Funktionalität in Integrationstests

        Seite 316

    • 15.4 Zusammenfassung

      Seite 318

  • + 16 Sicherheit

    Seite 319

    • + 16.1 Schützen der Seiten durch HTTPS

      Seite 319

      • 16.1.1 Basis-URLs

        Seite 320

      • 16.1.2 HTTPS und Entwicklungsmodus

        Seite 322

    • 16.2 Authentifizierung

      Seite 322

    • 16.3 Zusammenfassung

      Seite 324

• + Teil III Tapestry für Profis

  Seite 325

  • + 17 Tapestry IoC und Dependency Injection

    Seite 327

    • 17.1 Einführung

      Seite 327

    • 17.2 Inversion of Control

      Seite 327

    • + 17.3 Dependency Injection

      Seite 328

      • 17.3.1 Setter-Injektion

        Seite 328

      • 17.3.2 Konstruktor-Injektion

        Seite 329

      • 17.3.3 Feld-Injektion

        Seite 329

      • 17.3.4 Singleton-Antipattern

        Seite 330

    • 17.4 Warum braucht Tapestry IoC?

      Seite 330

    • + 17.5 Überblick über Tapestry IoC

      Seite 331

      • 17.5.1 Modul

        Seite 332

      • 17.5.2 Bind-Methoden

        Seite 332

      • 17.5.3 Build-Methoden

        Seite 334

      • 17.5.4 Abhängigkeiten von Diensten

        Seite 334

    • 17.6 Lebenszyklus eines Dienstes

      Seite 336

    • 17.7 Eifriges Laden von Diensten

      Seite 337

    • 17.8 Scope eines Dienstes

      Seite 338

    • + 17.9 Eindeutigkeit von Diensten

      Seite 339

      • 17.9.1 Eindeutigkeit durch explizite IDs

        Seite 339

      • 17.9.2 Eindeutigkeit durch Marker-Annotationen

        Seite 341

    • + 17.10 Konfiguration von Diensten

      Seite 343

      • 17.10.1 Erweiterungspunkte in Tapestry

        Seite 344

      • 17.10.2 Ungeordnete Konfigurationen

        Seite 345

      • 17.10.3 Geordnete Konfigurationen

        Seite 347

      • 17.10.4 Schlüssel-Wert-Paare als Konfiguration

        Seite 349

    • + 17.11 Konfiguration von Anwendungen mit Symbolen

      Seite 350

      • 17.11.1 Symbole

        Seite 350

      • 17.11.2 Bereitstellen von Symbolen

        Seite 352

    • 17.12 Überschreiben von Diensten

      Seite 357

    • + 17.13 Diensterzeugung für Fortgeschrittene

      Seite 357

      • 17.13.1 Implementieren von Chains

        Seite 357

      • 17.13.2 Implementieren von Pipelines

        Seite 359

    • 17.14 Zusammenfassung

      Seite 362

  • + 18 AOP mit Tapestry

    Seite 365

    • 18.1 Grundbegriffe von AOP

      Seite 365

    • 18.2 Tapestry und AOP

      Seite 366

    • 18.3 Autorisierung der Methodenaufrufe von Diensten

      Seite 368

    • 18.4 Überschreiben von Methodenparametern der Dienste

      Seite 369

    • 18.5 Überschreiben der Rückgabewerte von Dienstmethoden

      Seite 370

    • 18.6 Dekorieren von Komponentenmethoden

      Seite 371

    • 18.7 Zusammenfassung

      Seite 372

  • + 19 Typumwandlung/ Type Coercion

    Seite 375

    • 19.1 Verstehen der Typumwandlung

      Seite 375

    • 19.2 Erweitern des Umwandlungsgraphen

      Seite 376

    • 19.3 Durchführen der Typumwandlung

      Seite 377

    • 19.4 Zusammenfassung

      Seite 379

  • + 20 Verarbeitung von Anfragen durch Tapestry

    Seite 381

    • + 20.1 Die HttpServletRequestHandler-Pipeline

      Seite 381

      • 20.1.1 Bereitstellen eines eigenen HttpServletRequestFilters

        Seite 383

    • + 20.2 Die RequestHandler-Pipeline

      Seite 384

      • 20.2.1 Bereitstellen eines eigenen RequestHandlers

        Seite 384

    • + 20.3 Chain of Command des Dienstes Dispatcher

      Seite 385

      • 20.3.1 Behandlung von Anfragen an den Kontextpfad

        Seite 385

      • 20.3.2 Behandlung von Anfragen an Tapestry-Seiten

        Seite 386

      • 20.3.3 Auslösen von Komponentenereignissen

        Seite 386

      • 20.3.4 Behandlung von Anfragen an statische Ressourcen

        Seite 387

      • 20.3.5 Bereitstellen eines eigenen Dispatchers

        Seite 387

    • 20.4 Zusammenfassung

      Seite 387

  • + 21 Bytecodemanipulation mit Tapestry

    Seite 389

    • 21.1 Das zu implementierende Szenario

      Seite 389

    • 21.2 Bytecodemanipulation von Seitenklassen

      Seite 390

    • 21.3 Zusammenfassung

      Seite 395

• + A Anhang

  Seite 397

  • + A.1 Komponenten

    Seite 397

    • A.1.1 ActionLink

      Seite 397

    • A.1.2 AddRowLink

      Seite 397

    • A.1.3 AjaxFormLoop

      Seite 398

    • A.1.4 Any

      Seite 399

    • A.1.5 BeanDisplay

      Seite 399

    • A.1.6 BeanEditForm

      Seite 400

    • A.1.7 BeanEditor

      Seite 401

    • A.1.8 Checkbox

      Seite 402

    • A.1.9 DateField

      Seite 403

    • A.1.10 Delegate

      Seite 404

    • A.1.11 Errors

      Seite 404

    • A.1.12 EventLink

      Seite 404

    • A.1.13 ExceptionDisplay

      Seite 405

    • A.1.14 Form

      Seite 405

    • A.1.15 FormFragment

      Seite 406

    • A.1.16 FormInjector

      Seite 407

    • A.1.17 Grid

      Seite 408

    • A.1.18 Hidden

      Seite 410

    • A.1.19 If

      Seite 410

    • A.1.20 Label

      Seite 411

    • A.1.21 LinkSubmit

      Seite 411

    • A.1.22 Loop

      Seite 412

    • A.1.23 Output

      Seite 413

    • A.1.24 OutputRaw

      Seite 413

    • A.1.25 PageLink

      Seite 414

    • A.1.26 Palette

      Seite 414

    • A.1.27 PasswordField

      Seite 415

    • A.1.28 ProgressiveDisplay

      Seite 416

    • A.1.29 Radio

      Seite 416

    • A.1.30 RadioGroup

      Seite 417

    • A.1.31 RemoveRowLink

      Seite 417

    • A.1.32 RenderObject

      Seite 417

    • A.1.33 Select

      Seite 418

    • A.1.34 Submit

      Seite 419

    • A.1.35 SubmitNotifier

      Seite 419

    • A.1.36 TextArea

      Seite 419

    • A.1.37 TextField

      Seite 420

    • A.1.38 TextOutput

      Seite 421

    • A.1.39 Unless

      Seite 421

    • A.1.40 Upload

      Seite 421

    • A.1.41 Zone

      Seite 422

  • + A.2 Mixins

    Seite 422

    • A.2.1 Autocomplete

      Seite 422

    • A.2.2 DiscardBody

      Seite 423

    • A.2.3 NotEmpty

      Seite 423

    • A.2.4 RenderDisabled

      Seite 423

    • A.2.5 RenderInformals

      Seite 423

    • A.2.6 TriggerFragment

      Seite 424

  • + A.3 Seiten

    Seite 424

    • A.3.1 PropertyDisplayBlocks

      Seite 424

    • A.3.2 PropertyEditBlocks

      Seite 424

    • A.3.3 ServiceStatus

      Seite 424

    • A.3.4 Statistics

      Seite 424

• + Stichwortverzeichnis

  Seite 425

  • A

    Seite 425

  • B

    Seite 426

  • C

    Seite 426

  • D

    Seite 426

  • E

    Seite 427

  • F

    Seite 427

  • G

    Seite 427

  • H

    Seite 427

  • I

    Seite 427

  • J

    Seite 428

  • K

    Seite 428

  • L

    Seite 428

  • M

    Seite 428

  • N

    Seite 428

  • O

    Seite 428

  • P

    Seite 428

  • R

    Seite 429

  • S

    Seite 429

  • T

    Seite 429

  • U

    Seite 430

  • V

    Seite 430

  • W

    Seite 430

  • X

    Seite 430

  • Z

    Seite 430

• Copyright

  Seite 433

Tapestry ist ein komponentenorientiertes MVC-Framework zur Entwicklung von dynamischen und skalierbaren Web-Anwendungen in Java. Durch "Best Practices" wie RESTful URLs, Convention over Configuration und DRY (Don't Repeat Yourself) vereinfacht Tapestry die Webentwicklung unter Java. Das Buch "Tapestry - Entwicklung von Webanwendungen mit Leichtigkeit" bietet dem Leser einen schnellen und praxisnahen Einstieg in das Tapestry-Framework. Anhand vieler Beispiele, Kochrezepte und Praxistipps wird Tapestry schrittweise erläutert. Dieses Buch wendet sich an alle Java-Entwickler, sowohl Einsteiger als auch Profi, die Webanwendungen mit minimalem Aufwand und hohem Maß an Produktivität entwickeln möchten. Kenntnisse in Java und HTML werden dabei vorausgesetzt.

Beschreibung Folgende Themen werden behandelt

* Installation und Schnelleinstieg
* Die Konzepte des Frameworks
* Lokalisierung und Internationalisierung
* Arbeiten mit Formularen
* Generierung von Benutzerschnittstellen
* für JavaBeans
* Entwicklung von eigenen Komponenten
* und Mixins
* Ajax
* Testen von Webanwendungen
* Integration von Hibernate und Spring
* Framework
* Tapestry IoC, Dependency Injection, AOP und
* Bytecodemanipulation