Wicket-Webkomponenten

Einbindung von Wicket

Wicket-Anwendungen sind Webanwendungen gemäß der Java Servlet Specification.
Die Web-Anwendung wird so konfiguriert, dass alle Web-Requests von WicketFilter behandelt werden.
Dieser Filter ist unter der Angabe der Applikationsklasse im web.xml der Web-Anwendung zu deklarieren.
Die von WebApplication abgeleitete Applikationsklasse ist für die Konfiguration der Anwendung zuständig.
Wicket verarbeitet die Web-Requests unter Zuhilfenahme der Page-Klassen der Anwendung. Die Startseite der Anwendung wird in der Applikationsklasse festgelegt.

Applikation wird per WicketFilter in web.xml eingebunden

<?xml version="1.0" encoding="UTF-8"?>
<web-app>

    <filter>
        <filter-name>wicketFilter</filter-name>
        <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
        <init-param>
            <param-name>applicationClassName</param-name>
            <param-value>de.ralfebert.wicket.SomeWicketApplication</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>wicketFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

Anwendungsklasse: Konfiguration + Festlegung HomePage

public class SomeWicketApplication extends WebApplication {

    @Override
    protected void init() {
        // Web-Applikation wird in init()-Methode konfiguriert, z.B.
        getApplicationSettings().setDefaultMaximumUploadSize(Bytes.megabytes(2));
    }
    
    @Override
    public Class<HomePage> getHomePage() {
        // Festlegung Startseite
        return SomePage.class;
    }

}

Page + Markup

Logik und Anzeige werden strikt getrennt: Zu jeder Page-Klasse wird parallel eine gleichnamige XHTML-Seite abgelegt.

SomePage.java:

public class SomePage extends WebPage {

    public SomePage() {
    }

}

SomePage.html:

<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd" >
    <head><title>SomePage</title></head>
    <body>...</body>
</html>

Seiten-Markup

Das XHTML-Markup wird durch einen XML-Namespace für Wicket erweitert. Dies ist die einzige Ergänzung zum Markup, die XHTML-Seiten sind valides XHTML.

Tags werden mit einem Attribut wicket:id versehen und sind so für die zugehörige Seitenklasse zugänglich:

<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd" >
    <head><title>SomePage</title></head>
    <body>
        <div wicket:id="message">Some message</div>
    </body>
</html>

Snippet: XHTML 1.0 Strict-Header

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd"
      lang="de" xml:lang="de">
    
    <head>  
        <title>Page title</title>
    </head>
    
    <body>
    
    </body>
    
</html>

Komponenten hinzufügen

Zu den im Markup vergebenen wicket:ids müssen in der Seite entsprechende Komponenten hinzugefügt werden (strikte 1:1 Zuordnung!):

public class SomePage extends WebPage {

    public SomePage() {
        add(new Label("message", "Hello world!"));
    }

}

Komponenten sind hierarchisch strukturiert (alle Komponenten haben eine add-Methode): Hierarchie der Komponenten muss exakt mit der Hierarchie der Tags im Markup übereinstimmen.

Beziehung Komponenten - Markup

Modelle

Wicket-Komponenten kann ein Modell-Objekt zugeordnet werden.
Modellobjekte handhaben die Daten für eine Komponente und werden von der Komponente verwendet (ein Label zeigt z.B. die String-Repräsentation seines Modells an).

Zustände sollten in der Regel in Modell-Objekten gehalten werden, z.B.:

Model<Integer> counterModel = new Model<Integer>(0);
add(new Label("counter", counterModel));

Stateful Pages

In Wicket halten die Seiten und deren Komponenten serverseitig den Zustand der Anwendung.
Erzeuge Page-Objekte werden von Wicket intern in PageMaps in der Web-Session gehalten, Folgeanfragen für eine Seite gehen immer an das Page-Objekt, welches die Seite gerendert hat.
Dies wird auch durch Referenzierung der Seite in den URLs erreicht - ein Neu-Laden der Seite wird von demselben Page-Objekt behandelt:
```
http://localhost:8080/?wicket:interface=:4::::
```

Links und Ereignisbehandlung

Link-Komponenten können zum Auslösen von Aktionen auf einer Seite verwendet werden, die serverseitig im onClick-Ereignis behandelt werden können:

add(new Link("someLink") {
    
    @Override
    public void onClick() {
        // handle click here
    }

});

HTML-Markup:
```
<a wicket:id="someLink">Link</a>
```

Tipps & Tricks: Empfehlenswerte Firefox-Plugins

HTML Validator: http://users.skynet.be/mgueury/mozilla/
Firebug: http://getfirebug.com/
Firecookie: http://www.softwareishard.com/blog/firecookie/

Eclipse IDE Tipps & Tricks: Anonyme, inneren Klassen

Anlegen von anonymen, inneren Klassen:
Überschreiben von Methoden (oder Source > Overwrite/Implement methods):

Eclipse IDE Tipps & Tricks: Ignorieren von Packages

Gleichnamige Klassen wie Button, Label aus anderen Packages können bei der Typvervollständigung stören.
Wird ein Eclipse-Workspace nur zur Entwicklung mit Wicket verwendet, empfiehlt es sich, diese Klassen mittels Window > Preferences > Java Appearance > Type Filters auszublenden.
Dies betrifft insb.:
- java.awt.*
- javax.swing.*
- javax.media.*

Training

Ralf Ebert » Articles » Apache Wicket » Apache Wicket

Ralf Ebert is an independent software developer, technical writer and trainer. He makes apps for Mac OS X and iOS and builds software solutions for companies using Eclipse RCP and Ruby on Rails. He offers training courses for software developers and writes books and articles about software development.