Mit Wicket ist es sehr einfach, Webanwendungen zu schreiben. Wenn man dem Wicket-Pfad folgt und keine besonderen Wünsche hat. Im folgenden besteht der Wunsch darin, den Zustand einer Seite in Seitenparametern abzulegen. Wenn durch einen Link, also eine Aktion, die der Nutzer wählen kann, nur ein Parameter verändert wird, sollen natürlich alle anderen Parameter unverändert weitergereicht werden.

Zuerst erstellen wir uns ein paar Hilfsklassen, welche die Handhabung wesentlich vereinfachen werden. Die Idee ist dabei folgende: die Parameter, die mit dem Request übergeben werden, werden auf Attribute einer JavaBean gemappt und mit Wicket-Bordmitteln in den entsprechenden Datentyp konvertiert. Aus der JavaBean kann man dann die gewünschten Werte auslesen. Die Attribute der JavaBean können dann neu gesetzt werden. Ein weiteres Mal wird mit Wicket-Bordmitteln aus den Attributen der JavaBean eine Liste von Parametern gewonnen, die dann (fast) direkt in einem Link benutzt werden können.

Zuerst erstellen wir uns eine Annotation, mit der wir die Attribute markieren, die von und in PageParameter umgewandelt werden sollen.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PublicProperty
{	
}

Als nächstes erstellen wir uns ein Interface, was von der JavaBean implementiert werden muss. Die Aufgabe des Interface liegt darin, sicherzustellen, dass von der JavaBean eine Kopie angefertigt werden kann, damit die Änderungen an der Kopie und nicht am Original vorgenommen werden.

import org.apache.wicket.IClusterable;

public interface PageStateBeanInterface<T extends PageStateBeanInterface<?>> extends IClusterable
{
	public T getClone();
}

Jetzt kommt der aufwendigste Teil. Wir schreiben uns eine Hilfsklasse, welche die Transformation von und in PageParameter durchführt.

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.wicket.Application;
import org.apache.wicket.IConverterLocator;
import org.apache.wicket.PageParameters;
import org.apache.wicket.Session;
import org.apache.wicket.model.PropertyModel;
import org.apache.wicket.util.convert.IConverter;

public class BeanPagePropertyUtil
{
	public static <B> PageParameters getBeanPageParameters(B bean)
	{
		return new PageParameters(getParameter(bean));
	}
	
	public static <B> PageParameters getBeanPageParameters(B bean,B defaults)
	{
		Map<String, Object> beanParameter = getParameter(bean);
		Map<String, Object> defaultParameter = getParameter(defaults);
		for (String s : defaultParameter.keySet())
		{
			Object defaultValue = defaultParameter.get(s);
			if (defaultValue!=null)
			{
				Object curValue = beanParameter.get(s);
				if (defaultValue.equals(curValue))
				{
					beanParameter.remove(s);
				}
			}
		}
		return new PageParameters(beanParameter);
	}
	
	protected static <B> List<String> getPublicProperties(B bean)
	{
		List<String> ret=new ArrayList<String>();
		
		Method[] methods = bean.getClass().getMethods();
		for (Method m : methods)
		{
			PublicProperty annotation = m.getAnnotation(PublicProperty.class);
			if (annotation!=null)
			{
				String name = m.getName();
				if (name.startsWith("get")) ret.add(name.substring(3));
				else
				{
					if (name.startsWith("is")) ret.add(name.substring(2));
				}
			}
		}
		
		return ret;
	}
	
	public static <B> Map<String,Object> getParameter(B bean)
	{
		Map<String,Object> ret=new HashMap<String, Object>();
		
		Locale locale = Session.get().getLocale();
		IConverterLocator converterLocator = Application.get().getConverterLocator();
		
		for (String s : getPublicProperties(bean))
		{
			PropertyModel<?> propertyModel = new PropertyModel(bean,s);
			IConverter converter = converterLocator.getConverter(propertyModel.getObjectClass());
			Object value = propertyModel.getObject();
			if (value!=null)
			{
				ret.put(s, converter.convertToString(value, locale));
			}
		}
		return ret;
	}

	public static <B> void setParameter(B bean,PageParameters pageParameters)
	{
		Locale locale = Session.get().getLocale();
		IConverterLocator converterLocator = Application.get().getConverterLocator();
		
		for (String s : getPublicProperties(bean))
		{
			PropertyModel<Object> propertyModel = new PropertyModel<Object>(bean,s);
			IConverter converter = converterLocator.getConverter(propertyModel.getObjectClass());
			String svalue = pageParameters.getString(s);
			if (svalue!=null)
			{
				propertyModel.setObject(converter.convertToObject(svalue, locale));
			}
			else
			{
				propertyModel.setObject(null);
			}
		}
	}

	public static <B> void setParameter(B bean,Map<String,?> parameter)
	{
		for (String s : getPublicProperties(bean))
		{
			if (parameter.containsKey(s))
			{
				PropertyModel<Object> propertyModel = new PropertyModel<Object>(bean,s);
				Object value=parameter.get(s);
				propertyModel.setObject(value);
			}
		}
	}
}

Es ist wichtig, darauf hinzuweisen, dass es vorgesehen ist, eine mit Standardwerten initialisierte JavaBean als Abgleich zu benutzen. So kann sichergestellt werden, dass Seitenparameter dann aus der Url entfernt werden, wenn der Wert dem Standardwert entspricht. Das reduziert die Gefahr für Double-Content-Probleme wesentlich.

Jetzt haben wir alles zusammen, um Seitenparameter in JavaBean-Attribute zu überführen und zurück wandeln zu können. Als nächstes benötigen wir noch ein paar Komponenten, die den Prozess der Parameterlistenerstellung und der Konvertierung für uns übernehmen. Dazu fügen wir der Seite eine Komponente hinzu, die folgendes Interface implementiert:

public interface PageStateInterface<B extends PageStateBeanInterface<B>>
{
	public B getState();
	public B getDefaults();
}

Die Komponente konvertiert die Seitenparameter in die Attribute und stellt über die Schnittstelle die beiden Zustände zur Verfügung. Damit andere Komponenten auf diese Werte zugreifen können, erstellen wir gleichzeitig eine Funktion, welche die Komponente im Komponentenbaum sucht.

import org.apache.wicket.Component;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.panel.Panel;

public class PageContext<B extends PageStateBeanInterface<B>> extends Panel implements PageStateInterface<B>
{
	private static final Logger _logger=LoggerFactory.getLogger(PageContext.class);

	B _defaults;

	B _state;

	public PageContext(String id, PageParameters pageParameters, B defaults)
	{
		super(id);

		_defaults=defaults;
		_state=_defaults.getClone();
		BeanPagePropertyUtil.setParameter(_state, pageParameters);
	}

	public B getDefaults()
	{
		return _defaults;
	}

	public B getState()
	{
		return _state.getClone();
	}

	public static <B extends PageStateBeanInterface<B>> PageStateInterface<B> getPageState(Page page, Class<? extends B> type)
	{
		NodeVisitor visitor=new NodeVisitor(type);
		page.visitChildren(PageContext.class, visitor);
		return visitor.getPageState();
	}

	static class NodeVisitor<B extends PageStateBeanInterface<B>> implements IVisitor<Component>
	{
		Class<B> _type;

		PageStateInterface<B> _pageState;

		public NodeVisitor(Class<B> type)
		{
			_type=type;
		}

		public PageStateInterface<B> getPageState()
		{
			return _pageState;
		}

		public Object component(Component component)
		{
			if (component instanceof PageContext)
			{
				PageContext rawContext=(PageContext) component;
				if (_type.isAssignableFrom(rawContext.getDefaults().getClass()))
				{
					_pageState=rawContext;
					return IVisitor.STOP_TRAVERSAL;
				}
			}
			return IVisitor.CONTINUE_TRAVERSAL;
		}
	}
}

Des weiteren erstellen wir eine Linkklasse, die sich um das setzen der richtigen Seitenparameter kümmert.

import java.util.Map;

import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.util.collections.MiniMap;

public class PageStateLink<P extends Page, B extends PageStateBeanInterface<B>> extends BookmarkablePageLink<P>
{
	Map<String, ?> _linkParameter;

	Class<B> _beanType;

	public PageStateLink(String id, Class<P> pageClass, Class<B> beanType, Map<String, ?> linkParameter)
	{
		super(id, pageClass);
		_beanType=beanType;
		_linkParameter=linkParameter;
		if (_linkParameter == null) _linkParameter=new HashMap<String,?>();
	}

	public PageStateLink(String id, Class<P> pageClass, Class<B> beanType)
	{
		this(id, pageClass, beanType, null);
	}

	@Override
	protected void onBeforeRender()
	{
		PageStateInterface<B> pageState=PageContext.getPageState(getPage(), _beanType);
		if (pageState != null)
		{
			B bean=pageState.getState();
			B defaults=pageState.getDefaults();
			BeanPagePropertyUtil.setParameter(bean, _linkParameter);
			onAfterSetParameter(bean);
			PageParameters beanPageParameters=BeanPagePropertyUtil.getBeanPageParameters(bean, defaults);
			applyPageParameter(beanPageParameters);
		}
		super.onBeforeRender();
	}

	protected void onAfterSetParameter(B bean)
	{

	}

	private void applyPageParameter(PageParameters pageParameters)
	{
		this.parameters=pageParametersToMiniMap(pageParameters);
	}

	private MiniMap<String, Object> pageParametersToMiniMap(PageParameters parameters)
	{
		if (parameters != null)
		{
			MiniMap<String, Object> map=new MiniMap<String, Object>(parameters, parameters.keySet().size());
			return map;
		}
		else
		{
			return null;
		}

	}
}

Die Methode applyPageParameter wurde nur aus Geschwindigkeitsgründen erstellt, da sonst jeder Aufruf von setParameter dazu führt, dass die interne Map kopiert wird.

Um auf die JavaBean über ein Modell zuzugreifen, schreiben wir uns noch eine Modellklasse, bevor wir uns dann ansehen, wie man die Klassen dann benutzt.

import org.apache.wicket.Component;
import org.apache.wicket.model.LoadableDetachableModel;

public class PageStateModel<B extends PageStateBeanInterface<B>> extends LoadableDetachableModel<B>
{
	Component _component;
	Class<? extends B> _type;
	
	public PageStateModel(Component component, Class<? extends B> type)
  {
		_component=component;
		_type=type;
  }
	
	@Override
	protected B load()
	{
	  PageStateInterface<B> pageState=PageContext.getPageState(_component.getPage(), _type);
	  if (pageState!=null)
	  {
	  	return pageState.getState();
	  }
		return null;
	}
}

Ok. Das war ganz schön aufwendig, aber dafür ist die Verwendung um so einfacher. Wir erstellen eine JavaBean und eine Seite, auf der wir dann die Komponenten einbinden.

public class ConfigBean implements PageStateBeanInterface<ConfigBean>
{
	Integer _start;
	Integer _stop;
	String _name;

	@PublicProperty
	public Integer getStart()
	{
		return _start;
	}

	public void setStart(Integer start)
	{
		_start=start;
	}

	@PublicProperty
	public Integer getStop()
	{
		return _stop;
	}

	public void setStop(Integer stop)
	{
		_stop=stop;
	}

	@PublicProperty
	public String getName()
	{
		return _name;
	}

	public void setName(String name)
	{
		_name=name;
	}

	public ConfigBean getClone()
	{
		ConfigBean ret=new ConfigBean();
		ret._name=_name;
		ret._start=_start;
		ret._stop=_stop;
		return ret;
	}
}

import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.PropertyModel;

public class TestPage extends WebPage
{
	IModel<ConfigBean> _config=new PageStateModel<ConfigBean>(this, ConfigBean.class);

	public StatelessTestPage(PageParameters pageParameters)
	{
		add(new PageContext<ConfigBean>("context", pageParameters, new ConfigBean()));

		add(new Label("start", new PropertyModel<Integer>(_config, "start")));
		add(new Label("stop", new PropertyModel<Integer>(_config, "stop")));
		add(new SubPanel("sub"));
	}

	public static class SubPanel extends Panel
	{
		IModel<ConfigBean> _config=new PageStateModel<ConfigBean>(this, ConfigBean.class);

		public SubPanel(String id)
		{
			super(id);

			add(new Label("name", new PropertyModel<Integer>(_config, "name")));

			PageStateLink<StatelessTestPage, ConfigBean> link=new PageStateLink<StatelessTestPage, ConfigBean>("link", StatelessTestPage.class, ConfigBean.class, new HashMap<String,Object>("Name","Klaus"));
			add(link);
			PageStateLink<StatelessTestPage, ConfigBean> link2=new PageStateLink<StatelessTestPage, ConfigBean>("link2", StatelessTestPage.class, ConfigBean.class, new HashMap<String,Object>("Start", 1));
			add(link2);
			PageStateLink<StatelessTestPage, ConfigBean> link3=new PageStateLink<StatelessTestPage, ConfigBean>("link3", StatelessTestPage.class, ConfigBean.class, new HashMap<String,Object>("Start", null));
			add(link3);
			PageStateLink<StatelessTestPage, ConfigBean> link4=new PageStateLink<StatelessTestPage, ConfigBean>("link4", StatelessTestPage.class, ConfigBean.class, new HashMap<String,Object>("Name", "Bert", "Stop", null));
			add(link4);
		}
	}
}

Wie man sieht, muss ich bei den Modellen eigentlich nichts besonderes machen. Die Links übergibt man eine Map mit neuen Parametern, mit denen der aktuelle Zustand, der in der JavaBean gespeichert wurde, für diesen Link, diese Nutzeraktion überschrieben wird. Dabei spielt es keine Rolle, in welcher Komponente so ein Link benutzt wird, da sich die Linkklasse und die Modellklasse selbsttätig um die Informationen bemühen.

Der hier vorgeschlagene Ansatz ist sicher a) verbesserungswürdig und b) ausbaufähig. Er soll als Anregung dienen, wie man dieses und möglicherweise ähnliche Probleme lösen kann und dabei besonders von der Komponentenarchitektur von Wicket profitieren kann.

Wie in den Kommentaren der letzten Tage sichtbar wurde, eignet sich Wicket nicht "ungeschminkt" für Webseiten, die ihre Zustandsinformationen klassisch in URL-Parametern ablegen. In meinem Buch beschreibe ich eine einfache Variante, die bereits zum Ziel führen kann.

Die Herausforderung liegt darin, dass man von den Vorteilen, die Wicket mitbringt nicht all zu viele einbüßt. Daher werde ich mich in den nächsten Tagen mal damit beschäftigen, wie man mit möglichst wenig Aufwand Anwendungen realisieren kann, die auf der einen Seite URL-Parameter benutzen, auf der anderen Seite aber nicht auf saubere Komponenten verzichten müssen.

Auch wenn es schwer ist, sich von der Herangehensweise wie man sie mit JSP,PHP,... gewöhnt ist, zu lösen, erschließt man das volle Potential von Wicket erst dann, wenn man sich auf den "Wicket-Pfad" begibt. Der einzige Aspekt, der es notwendig macht, sich mit der Frage von URL-Parametern zu beschäftigen, ist die Suchmaschinentauglichkeit der Anwendung. Da muss man allerdings auch überlegen, ob man nicht einen Sitemap generiert, die alle gewünschten Inhalte ansteuerbar macht, so dass man nicht gezwungen ist, eine SEO-taugliche Navigation aufzusetzen.

Wicket ist ganz sicher nicht für jede Anforderung geeignet. Unbestritten. Die Alternativen sind IMHO allerdings auch nicht zufriedenstellender.

Wer schon Webanwendungen entwickelt hat, der wird der sehr gut geschriebenen Ausführung von Jeff Schwartz folgen können. Rückblickend ist es eigentlich erschreckend, wie naheliegend die Lösung die ganze Zeit war. Denn Wicket ist kein Hexenwerk, sondern einfach nur gut durchdachter Java-Code.