Quelltext der Seite Apache Wicket

{{Infobox Software
|Name                  = 
|Logo                  = [[Datei:Apache Wicket Logo.png|275px|Logo von Apache Wicket]]
|Screenshot            = 
|Beschreibung          = <!-- Beschreibung des Screenshots! -->
|Maintainer            = 
|Hersteller            = <!-- Wikidata -->
|Management            = 
|Erscheinungsjahr      = 
|AktuelleVersion       = <!-- Wikidata -->
|AktuelleVersionFreigabeDatum = <!-- Wikidata -->
|AktuelleVorabVersion  = 
|AktuelleVorabVersionFreigabeDatum = 
|Betriebssystem        = [[plattformübergreifend]]
|Programmiersprache    = <!-- Wikidata -->
|Kategorie             = [[Webframework]]
|Lizenz                = <!-- Wikidata -->
|Deutsch               = 
|Website               = <!-- Wikidata -->
|Dateien               = 
}}

'''Apache Wicket''' ist ein komponentenbasiertes [[Webframework]] für die Programmiersprache [[Java (Programmiersprache)|Java]]. Es ist ein [[Open Source|Open-Source]]-Projekt und heute unter Version 2.0 der [[Apache-Lizenz]] verfügbar.

== Ziel ==
Wicket verfolgt das Ziel, eine komfortable, leistungsfähige und flexible Möglichkeit zur Erstellung von [[Webanwendung]]en für erfahrene Java-Programmierer bereitzustellen, wodurch es ermöglicht werden soll, komplexen Anforderungen gerecht zu werden und eine hohe Produktivität zu erlangen. Durch den komponentenorientierten Ansatz von Wicket ist es sehr leicht möglich, eigene wiederverwendbare Komponenten zu entwickeln.

Wicket zwingt den Programmierer, im Gegensatz zu vielen anderen Frameworks, konsequent objektorientiert zu programmieren. Es wird großer Wert auf Wiederverwendbarkeit gelegt.

== Funktionalität ==
Eigenschaften von ''Wicket'' sind:
* Trennung von Logik (Java) und Darstellung ([[Hypertext Markup Language|HTML]] und [[Cascading Style Sheets|CSS]]).
* Jede Komponente kann ihre Daten in ein zugehöriges Datenmodell speichern.
* Automatische Zustandsverwaltung.
* Bis auf web.xml sind keine [[Extensible Markup Language|XML]]-Konfigurationsdateien nötig. Für die Arbeit mit Wicket sind ausschließlich Java- und (X)HTML-Kenntnisse erforderlich.
* Die Übernahme der Benutzereingaben 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 Web-Formular über ein Fehlerbehandlungssystem abgefangen werden. Werden alle Schritte fehlerfrei durchlaufen, so werden die Daten im Datenmodell abgelegt.
* [[Ajax (Programmierung)|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 <code>AjaxEventBehavior</code>, zum Reagieren auf ein bestimmtes JavaScript-Ereignis oder die Klasse <code>AbstractSelfUpdatingTimerBehavior</code>, zum automatischen Aktualisieren einzelner Komponenten in bestimmten Zeitintervallen.
* Mit sogenannten Panels kann man Teile einer Seite ändern oder austauschen bzw. die Seite aus verschiedenen Komponenten aufbauen.
* Es ist sehr leicht möglich, wiederverwendbare Komponenten zu entwickeln und diese ggf. mit Ajax-Funktionalität anzureichern.
* Alle erforderlichen Dateien einer Komponente (Java- und HTML-Datei plus ggf. Icon-, CSS- oder JavaScript-Dateien) können zur besseren Wiederverwendbarkeit in eine [[Java Archive|jar]]-Datei gepackt werden.
* Sogenannte Ressourcen ermöglichen es, dynamisch generierte Daten einzubinden (z.&nbsp;B. PDF-Daten) oder auf statische Daten (JavaScript-/CSS-Dateien) zuzugreifen.
* Der Aufbau einer [[Uniform Resource Locator|URL]] kann über <code>URLCodingStrategies</code> bestimmt werden.
* Leichte Integrierbarkeit von externen JavaScript-Bibliotheken
* Schrittweise Migration von HTML-Seiten nach Wicket ist möglich.
* Ab Version 1.5 können alle Komponenten sehr einfach Events miteinander austauschen.
* WicketTester ermöglicht den UnitTest einzelner Seiten und auch den Ablauf über mehrere Seiten.

Konzeptionell ist ''Wicket'' am ehesten mit [[Apache Tapestry]] vergleichbar, konkurriert aber in erster Linie mit [[JavaServer Faces]] und [[Google Web Toolkit]].

== Geschichte ==
Die Architektur von Wicket wurde 2004 von Jonathan Locke und Miko Matsumura entworfen und war bis zur Version 1.2 auf [[SourceForge|sourceforge.org]] verfügbar.
Später wurde das Framework dann unter der [[Apache-Lizenz]] als Open-Source-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|Open-Source]]-Projekt unter der Apache-Lizenz, Version 2.0 verfügbar.

Ab der Version 6.0.0 setzt Wicket zwingend [[Java Development Kit|JDK]] 6 oder höher voraus. Darüber hinaus wird nun von Wicket im Hintergrund [[jQuery]] als [[Ajax (Programmierung)|Ajax]]-Implementierung verwendet.

Mit Wicket 7.x wird zwingend [[Java 7]] und [[Servlet]] (Version 3.x) Container voraus gesetzt.

Seit Wicket 8.x besteht eine vollständige Unterstützung von [[Java 8]].

== Lebenszyklus einer Wicket-Komponente ==
Jede Wicket-Komponente durchläuft einen bestimmten Lebenszyklus. Dabei gibt es drei Hauptphasen:
* Initialisierung
* Rendering
* Removing

Die einzelnen Methoden können jeweils bei Bedarf überschrieben werden.

{| class="wikitable" style="text-align:left"
! Phase !! Beteiligte Methoden !! Beschreibung
|-
| Initialisierung
| <code>'''onInitialize'''</code>
| Wird am Anfang des Lebenszyklus ausgeführt. Diese Methode eignet sich als "spezieller Konstruktor" für die Initialisierung aller Komponenten insbesondere bei Klassen, die von WebPage erben.<br />
Beim Überschreiben muss die Methode super.onInitialize() '''als erstes''' aufgerufen werden.<br /><br />
<syntaxhighlight lang="java">

 protected void onInitialize() {
     super.onInitialize();
     .....
 }

</syntaxhighlight>
|-
|rowspan="7" | Rendering
| '''<code>onConfigure</code>'''
| Diese Methode wird aufgerufen, bevor das Rendering startet. Insofern ist das die ideale Stelle, um den Status von Komponenten zu steuern, wie z.&nbsp;B. Sichtbarkeit oder Aktivierung. Da die Methoden <code>isVisible</code> oder <code>isEnabled</code> während des Renderns einer Page oder Komponente mehrfach aufgerufen werden, ist es dringend zu empfehlen diese Methoden nicht direkt, sondern stattdessen die Methode <code>onConfigure</code> zu benutzen, um den Status zu steuern. Ist die Sichtbarkeit einer Komponente auf <code>false</code>, so wird die nachfolgende Methode (onBeforeRender) gar nicht mehr aufgerufen.
|-
| '''<code>onBeforeRender</code>'''
| Diese Methode wird aufgerufen, bevor das Rendering beginnt. Insofern ist es die letzte Chance, die Komponentenhierarchie zu ändern oder Komponenten hinzuzufügen oder zu löschen. Wird diese Methode überschrieben, so muss der Aufruf von <code>super.onBeforeRender()</code> '''ganz am Schluss''' erfolgen, da hierbei das Rendering aller nachfolgenden Komponenten angestoßen wird.<br /><br />
<syntaxhighlight lang="java">

 protected void onBeforeRender() {
     .....
     super.onBeforeRender();
 }

</syntaxhighlight>
|-
| '''<code>onRender</code>'''
|
|-
| '''<code>onComponentTag</code>'''
| hier kann man beliebige Änderungen am Element (Tag) vornehmen. Es kann sowohl die Art der Komponente getauscht, als auch dessen Style verändert werden. Auch hier darf der Aufruf der Methode der Super-Klasse nicht vergessen werden.<br /><br />
<syntaxhighlight lang="java">

 protected void onComponentTag(ComponentTag tag) {
     super.onComponentTag(tag);
     .....
 }

</syntaxhighlight>
|-
| '''<code>onComponentTagBody</code>'''
| Diese Methode kann man überschreiben, wenn man den Inhalt einer Komponente verändern will. In Kombination mit der Methode replaceComponentTagBody kann man einen veränderten Inhalt rendern. Will man das Originalverhalten der Komponenten haben, dann muss man die Methode der Super-Klasse aufrufen.

<syntaxhighlight lang="java">

 public void onComponentTagBody(MarkupStream markupStream, ComponentTag tag) {
     if(!isEnabled()){
         replaceComponentTagBody(markupStream, tag, "(diese Komponente ist deaktiviert)");
     }
     else{
         super.onComponentTagBody(markupStream, tag);
     }
 }

</syntaxhighlight>
|-
| '''<code>onAfterRenderChildren</code>'''
|
|-
| '''<code>onAfterRender</code>'''
|
|-
|Removing
| '''<code>onRemove</code>'''
| Die Methode kann benutzt werden, um bestimmte Ressourcen, die die Komponente braucht, wieder freizugeben.
|}

== 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'', den Deployment Descriptor der Web Application für die Konfiguration, welche Klasse die Applications-Klasse ist.

=== Application-Klasse ===
Die Application-Klasse dient als zentraler Einstiegspunkt für die Webapplikation. Hier können verschiedene Einstellungen vorgenommen werden, die für die ganze Applikation gültig sind. Unter anderem wird hier die Startseite festgelegt:

<syntaxhighlight lang="java">
package com.myapp.wicket;

import org.apache.wicket.protocol.http.WebApplication;

public class Application extends WebApplication {
    public Class getHomePage() {
        return OnePage.class;
    }
}
</syntaxhighlight>

=== Web-Page (Java) ===
Jede Seite (Page) wird durch eine Java-Klasse und eine zugehörige gleichnamige HTML-Datei repräsentiert.
Alle Komponenten der Klasse werden hier definiert. Alle Komponenten, die in der HTML-Datei eine wicket:id haben, werden als Komponenten hinzugefügt.

<code>'''OnePage.java''':</code>

<syntaxhighlight lang="java">
package com.myapp.wicket;

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);
    }
}
</syntaxhighlight>

=== Web-Page (HTML) ===
Für jede Komponente, die dynamisch verändert werden soll, muss ein Attribut '''wicket:id''' angelegt werden.

<code>'''OnePage.html''':</code>

<syntaxhighlight lang="html">
<?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:wicket>
    <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>
</syntaxhighlight>

=== web.xml ===
Die Application wird lediglich über die folgende <code>'''web.xml'''</code> - Datei in den Servlet-Container als Web-Applikation eingebunden:

<syntaxhighlight lang="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>
    </filter>
    <filter-mapping>
        <filter-name>WicketApplication</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>
</syntaxhighlight>

== Kritik ==
Wicket ist sehr leistungsfähig, wenn es darum geht, komplexe Anforderungen an die Webapplikation zu erfüllen. Geschäftslogik kann vollständig in Java programmiert werden, ohne sich über die Besonderheiten einer Webanwendung Gedanken machen zu müssen. Der Status der Bearbeitung innerhalb einer Session wird jedoch von Wicket serverseitig geführt, wodurch der Entwickler einer Wicketanwendung gezielt das Ressourcenproblem vieler gleichzeitiger Benutzer lösen muss. Im Gegensatz dazu werden oft bei JavaScript-basierten Webframeworks der Status clientseitig gehalten und nur ggf. die Daten vom Server nachgeladen.

Da in Wicket sehr gut [[JavaScript]]- oder auch [[Cascading Style Sheets|CSS]]-Frameworks eingebunden werden können, stellt Wicket eine flexible Webentwicklungsplattform dar.

== Versionen ==
Wicket hat im Laufe der Zeit eine große Entwicklung durchlebt.
* ab '''Wicket 1.4''' gibt es Unterstützung für Generische Datentypen. Die letzte Version der 4er-Reihe ist hier '''Wicket 1.4.23'''.
* mit '''Wicket 1.5''' wurde die API radikal geändert. Die letzte Version ist hier '''Wicket 1.5.10'''.
* mit '''Wicket 6.x''' wurde die Wicket-eigene [[Ajax (Programmierung)|Ajax]]-Unterstützung durch [[jQuery]] ersetzt. Die letzte Version ist '''Wicket 1.6.20'''.
* mit '''Wicket 7.x''' setzt Wicket zwingend [[Java 7]] und [[Servlet]] (Version 3.x) Container voraus.
* seit '''Wicket 8.0''' wird '''[[Java 8]]''' vollständig unterstützt. Es wird zusätzlich '''Servlet 3.1''' voraus gesetzt.
* '''Wicket 9.0''' basiert auf '''[[Java-Technologie#Version 11|Java 11]]''' und nutzt [[JUnit|JUnit5]]. Die interne Klasse <code>Duration</code> wird durch <code>java.time.Duration</code> aus dem [[JDK]] ersetzt.
* '''Wicket 10''' basiert auf [[Java-Technologie#Version 17|Java 17]], Servlet (Version 5+) und [[Spring (Framework)]] 6.

== Literatur ==
* Martijn Dashorst, Eelco Hillenius: ''Wicket in Action''. Manning, Greenwich CT 2008, ISBN 978-1-932394-98-6
* Michael Mosmann: ''Praxisbuch Wicket''. Hanser, 2009, ISBN 978-3-446-41909-4
* {{Literatur
   |Autor=Roland Förther, Carl-Eric Menzel, Olaf Siefart
   |Titel=Wicket
   |TitelErg=Komponentenbasierte Webanwendungen in Java
   |Verlag=dpunkt.verlag
   |Datum=2009
   |ISBN=978-3-89864-569-0
   |Seiten=250
   |Sprache=de
   |Online=https://www.dpunkt.de/buecher/2921.html
   |Abruf=2010-01-04}}
* {{Literatur
   |Autor=Igor Vaynberg
   |Titel=Apache Wicket Cookbook
   |Verlag=Packt Publishing
   |Datum=2011
   |ISBN=978-1-84951-160-5
   |Seiten=312
   |Sprache=en}}

== Weblinks ==
* [https://wicket.apache.org/ Wicket-Website]
** [https://cwiki.apache.org/WICKET/index.html Wiki zum Thema Wicket]
** [https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+1.5 Migrations-Hinweise für Wicket 1.5]
** [https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+6.0 Migrations-Hinweise für Wicket 6.0]
<!-- ** [https://s.apache.org/wicket7migrate Migrations-Hinweise für Wicket 7.0] -->
** [https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+7.0 Migrations-Hinweise für Wicket 7.0]
** [https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+10.0 Migrations-Hinweise für Wicket 10]
* [http://wicketstuff.org/ Website mit Wicket-Demos und Wicket-Komponenten]
* [http://code.google.com/p/wicket-guide/ Wicket Guide (Dokumentation zu Wicket, die auch Version 6.x abdeckt)]
* [https://ptrthomas.wordpress.com/2008/09/04/wicket-and-gwt-compared-with-code/ Vergleich mit Google Web Toolkit] (englisch), siehe auch [[Google Web Toolkit]]
* [https://ptrthomas.wordpress.com/2007/05/14/a-wicket-user-tries-jsf/ Vergleich mit Java Server Faces] (englisch), siehe auch [[JavaServer Faces]]|

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=7674275-1}}

[[Kategorie:Freies Webframework]]
[[Kategorie:Java-Bibliothek]]
[[Kategorie:Apache-Projekt|Wicket]]