Wicket (Framework)

Wicket ist ein komponentenbasiertes Web-Framework für die Programmiersprache Java. Es ist ein Open-Source-Projekt und ist heute unter der Apache Lizenz, Version 2.0 verfügbar.

Funktionalität

Konzeptionell ist es am ehesten mit Tapestry vergleichbar, konkurriert aber in ersten Linie mit JavaServer Faces und Google Web Toolkit.

Eigenschaften von Wicket sind:

• Trennung von Logik (Java) und Darstellung (HTML und CSS). Jede Komponente speichert ihre Daten in ein zugehöriges Datenmodell.
• Automatische Zustandsverwaltung.
• Wicket-Templates können (mit Einschränkungen) mittels gängiger WYSIWYG-HTML-Tools erstellt und gewartet werden.
• Bis auf web.xml sind keine XML-Konfigurationsdateien nötig. Für die Arbeit mit Wicket sind ausschließlich Java- und (X)HTML-Kenntnisse erforderlich
• Die Übernahme der Benutzerdaten erfolgt mit Java. Dabei wird durch Java zuerst geprüft, ob eine Eingabe erforderlich ist, anschließend werden die Daten in den entsprechenden Datentyp umgewandelt. Abschließend werden die Daten auf Zulässigkeit (Validierung) geprüft. Diese drei Schritte können komponentenweise oder gemeinsam für ein Webformular über ein Fehlerbehandlungssystem abgefangen werden. Werden alle Schritte fehlerfrei durchlaufen, so werden die Daten im Datenmodell abgelegt.
• Die Darstellung kann über CSS gesteuert werden.
• Auch AJAX ist ohne JavaScript-Kenntnisse möglich. Dafür gibt es einzelne Klassen, die Ajax-Funktionalität bereitstellen. Allen Komponenten kann auch nachträglich Ajax-Funktionalität über sogenannte Behaviors hinzugefügt werden. So gibt es unter anderem die Klasse AjaxEventBehavior, zum Reagieren auf ein bestimmtes JavaScript-Ereignis oder die Klasse AbstractSelfUpdatingTimerBehavior, zum automatischen Aktualisieren einzelner Komponenten in bestimmten Zeitintervallen.
• es ist möglich, eigene wiederverwendbare Komponenten zu entwickeln und diese ggf. mit AJAX-Funktionalität anzureichern.
• sogenannte Ressourcen ermöglichen es, dynamisch generierte Daten einzubinden (z. B. PDF-Daten) oder auf statische Daten (JavaScript-/CSS-Dateien) zuzugreifen.
• mit sogenannten Panels kann man Teile einer Seite ändern oder austauschen, bzw. die Seite aus verschiedenen Komponenten aufbauen.
• Integration von externen JavaScript-Bibliotheken.
• Schrittweise Migration von HTML-Seiten nach Wicket ist möglich.

Geschichte

Die Architektur von Wicket wurde 2004 von Jonathan Locke und Miko Matsumura entworfen, und war bis zur Version 1.2 auf sourceforge.org verfügbar. Später wurde das Framework dann unter der Apache Lizenz als OpenSource-Projekt verfügbar. Eine Gruppe von Programmierern der niederländischen Firma Topicus, die von Eelco Hillenius, Martijn Dashorst und Johan Compagner geleitet wurden, bilden neben einigen anderen bis heute das Kernteam. Wicket ist als Open-Source-Projekt unter der Apache Lizenz, Version 2.0 verfügbar.

Beispiel

Ein einfaches Beispiel besteht aus vier Dateien:

• eine Application-Klasse, die als erstes aufgerufen wird
• eine Java-Datei, die die Seite darstellt
• eine zur Java-Datei zugehörige HTML-Datei.
• und die Datei web.xml des Tomcat-Servers für die Konfiguration, welche Klasse die Applications-Klasse ist.

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <filter>
        <filter-name>WicketApplication</filter-name>
        <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
        <init-param>
            <param-name>applicationClassName</param-name>
            <param-value>com.myapp.wicket.Application</param-value>
        </init-param>
        <init-param>
            <param-name>debug</param-name>
            <param-value>2</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>WicketApplication</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <session-config><session-timeout>
            30
    </session-timeout></session-config>
    <welcome-file-list>
        <welcome-file/>
    </welcome-file-list>
</web-app>

Applications-Klasse

import org.apache.wicket.protocol.http.WebApplication;
 
public class Application extends WebApplication {
    public Class getHomePage() {
        return OnePage.class;       
    }
}

Web-Page (HTML)

Für jede Komponente, die dynamisch verändert werden soll, muss ein Attribut wicket:id angelegt werden.

<html>   
    <head>
        <title>Echo Application</title>
    </head>
    <body>
        <h1>Echo example</h1>
        <form wicket:id="form">
            <input wicket:id="field" type="text" />
            <input wicket:id="button1" type="submit" value="Button" />
            <input wicket:id="button2" type="button" value="Button deaktivieren..." />
        </form>
        <p wicket:id="message">Fun Fun Fun</p>
    </body>    
</html>

Web-Page (Java)

Alle Komponenten, die eine wicket:id haben, müssen wieder in die Klasse, die von WebPage erbt, hinzugefügt werden.

import org.apache.wicket.ajax.AjaxEventBehavior;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.TextField;
import org.apache.wicket.model.Model;
 
public class OnePage extends WebPage {
 
    public OnePage() {
        final Label label = new Label("message", new Model(""));
        label.setOutputMarkupId(true);
        Form form = new Form("form");
        final TextField field = new TextField("field", new Model(""));
        field.setOutputMarkupId(true);
        form.add(field);
        final Button but1 = new Button("button1") {
 
            @Override
            public void onSubmit() {
                String value = (String) field.getModelObject();
                label.setModelObject("Normal-Request: " + value);
                field.setModelObject("");
                // setResponsePage(AnotherPage.class);
            }
        };
        but1.setOutputMarkupId(true);
        form.add(but1);
        final Button but2 = new Button("button2", new Model("Button deaktivieren ..."));
        but2.add(new AjaxEventBehavior("onclick") {
 
            @Override
            protected void onEvent(AjaxRequestTarget target) {
                but1.setEnabled(!but1.isEnabled());
                if (but1.isEnabled()) {
                    but2.setModelObject("Button deaktivieren ...");
                } else {
                    but2.setModelObject("Button aktivieren ...");
                }
                target.addComponent(but2);
                target.addComponent(but1);
            }
        });
        form.add(but2);
        add(form);
        add(label);
    }
}

Vergleich mit anderen Frameworks

• Vergleich mit Google Web Toolkit (engl.), (siehe auch Google Web Toolkit)
• Vergleich mit Java Server Faces (engl.), (siehe auch Java Server Faces)

Literatur

• Martijn Dashorst, Eelco Hillenius: Wicket in Action. Manning, Greenwich/Connecticut 2008, ISBN 978-1932394986

Weblinks

• Wicket-Website
• API-Documentation (V 1.3.2)
• Wicket-Projektseite bei Sourceforge
• Wiederverwendbare Komponenten und Patterns für Wicket
• Website mit Wicket-Demos und Wicket-Komponenten

Blogs

• Eelco Hillenius
• Martijn Dashorst
• Jonathan Locke