rattlab.net » Coding

Persistenz für den Feedreader

Peter — Tue, 28 Oct 2008 20:01:33 +0000

Heute möchte ich mich mit Persistenz beschäftigen. Als Ausgangspunkt dient mir der Feedreader, der im letzten Teil etwas dynamischer wurde. Ich werde JPA mit Hibernate einsetzen, um die Daten, die aus den Newsfeeds ausgelesen werden, in einer Datenbank zu speichern und von dort auch wieder auszulesen. Außerdem werden wir auch hier wieder mit Wicket in Berührung kommen, denn der Code kann und sollte etwas verbessert werden, wenn wir unsere Daten aus einer Datenbank holen.

Vorarbeit

Bevor wir loslegen, müssen wir erstmal die benötigten Bibliotheken herunterladen. Das machen wir natürlich nicht per Hand, sondern wie bisher auch mit Maven. In unserer pom.xml ergänzen wir folgende Abhängigkeiten:

		
			org.hibernate
			hibernate-annotations
			3.3.1.GA
		
		
			org.hibernate
			hibernate-commons-annotations
			3.3.0.ga
		
		
			org.hibernate
			hibernate-entitymanager
			3.3.2.GA
		
		
			org.hibernate
			hibernate
			3.2.6.ga
			
				
					javax.transaction
					jta
				
			
		
		
			org.apache.geronimo.specs
			geronimo-jta_1.1_spec
			1.1
		
		
			hsqldb
			hsqldb
			1.8.0.7

Die ersten beiden Abhängigkeiten brauchen wir für die (JPA-)Annotations, die wir verwenden wollen. Mit dem Entity Manager hatte ich meine Probleme, da ich erst nicht wusste, dass ich ihn brauch und dann gab es auch noch ein Problem mit der Version der Annotation-Library, denn mit der 3.3.0 will der Manager mit Version 3.3.2 offenbar nicht zusammenarbeiten. Dann folgt Hibernate selbst, aber eine der Abhängigkeiten von Hibernate klammern wir aus, da sie von Sun nicht freigegeben ist und Maven uns nur den Hinweis bringen würden, dass wir sie manuell runterladen müssten. Dazu sind wir aber zu faul (also zumindest ich bin es) und deswegen holen wir das Ding aus dem Geronimo-Projekt. In diesem stehen viele Enterprise APIs unter der Apache License zur Verfügung, was uns etwas die Arbeit erleichtert. Schließlich besorgen wir uns noch die HSQLDB.

$ mvn install
[...]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4 minutes 54 seconds
[INFO] Finished at: Fri Oct 03 12:04:18 CEST 2008
[INFO] Final Memory: 10M/18M
[INFO] ------------------------------------------------------------------------
$ mvn eclipse:eclipse
[...]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1 minute 42 seconds
[INFO] Finished at: Fri Oct 03 12:30:47 CEST 2008
[INFO] Final Memory: 6M/12M
[INFO] ------------------------------------------------------------------------

Nun wollen wir erstmal die Datenbank zum Laufen bekommen. HSQLDB ist eine kleine leichte Datenbank, die komplett in Java geschrieben wurde und die Daten (zumeist) komplett im Speicher behält. Für geringe Datenmengen oder Tests eignet sie sich damit sehr gut. Sie kann einerseits wie ein Datenbank-Server betrieben werden, der an einem Port lauscht, oder direkt in dem Programm angesprochen werden, von dem die Datenbank verwendet werden soll.

In meinem Projekt-Verzeichnis erstelle ich einen Unterordner für die HSQLDB und kopiere anschließend das Jar dort hinein. Der Pfad zum lokalen Maven-Repository wird bei euch sicher anders sein. Dann starte ich erstmals den Server:

$ cd /cygdrive/c/myprojects
$ mkdir hsqldb
$ cp /cygdrive/c/Users/ex-ratt/.m2/repository/hsqldb/hsqldb/1.8.0.7/hsqldb-1.8.0.7.jar hsqldb
$ cd hsqldb
$ java -cp hsqldb-1.8.0.7.jar org.hsqldb.Server
...

Nun läuft der Datenbank-Server. Da wir keine weiteren Parameter übergeben haben, wurde die Datenbank “test” genannt, zu sehen an den drei Dateien, die im hsqldb-Verzeichnis erstellt wurden (test.lck, test.log und test.properties). Im Log finden wir eine SQL-Anweisung, die einen User mit Namen “sa” und ohne Passwort anlegt und ihm Administrator-Rechte gibt.

Konfiguration

Damit Hibernate weiß, wie es auf die Datenbank zugreifen soll, müssen wir noch eine Konfiguration erstellen. Wir halten uns dabei an den JPA-Standard. Eine Datei namens persistence.xml beinhaltet diese Konfiguration und muss im META-INF-Verzeichnis liegen, das wiederum im Classpath zu finden sein muss. Damit hatte ich meine lieben Probleme. Damit das Starten aus Eclipse heraus funktioniert, legt man im Verzeichnis WEB-INF ein Verzeichnis classes an und da hinein kommt META-INF mitsamt der persistence.xml. In meinem Fall sähe der komplette Pfad so aus: C:/myprojects/wicket/src/main/webapp/WEB-INF/classes/META-INF/persistence.xml. Will man Jetty über Maven starten, so kann man META-INF unter target/classes ablegen.


	
		org.hibernate.ejb.HibernatePersistence
		net.rattlab.model.Game
		net.rattlab.model.News

Die erste wichtige Information ist der Provider. Normalerweise findet man JPA im Application-Server-Umfeld und dieser stellt eine Implementierung bereit. Wir aber haben keinen solchen Server, sondern nutzen direkt Hibernate und müssen das angeben. Dann folgen die nötigen Parameter wie z.B. Nutzername, Passwort und URL. Eigentlich sollte man die persistenten Klassen nicht extra angeben müssen, aber das funktionierte bei mir leider nicht wie gewünscht.

Die Klassen selber werden mit Annotationen versehen, die beschreiben, wie die Variablen der Objekte in der Datenbank abgebildet werden sollen. Ursprünglich hat man das bei Hibernate mit XML-Dateien gemacht, JPA bietet nun aber die Annotationen an (die Hibernate aber auch selber anbietet bzw. erweitert). Werfen wir also einen Blick auf unsere beiden persistenten Klassen:

package net.rattlab.model;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@NamedQueries({
	@NamedQuery(name = "findAllNews", query = "from News order by date desc"),
	@NamedQuery(name = "countNews", query = "select count(*) from News")
})
public class News implements Serializable {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private long id;

	@ManyToOne(cascade = CascadeType.ALL)
	private Game game;

	private String page;

	private String url;

	private String title;

	@Lob
	private String description;

	@Temporal(value = TemporalType.TIMESTAMP)
	private Date date;

	public News() {}

	public News(Game game, String page, String url, String title, String description, Date date) {
		this.game = game;
		this.page = page;
		this.url = url;
		this.title = title;
		this.description = description;
		this.date = date;
	}

	public long getId() {
		return id;
	}

	public Game getGame() {
		return game;
	}

	public String getPage() {
		return page;
	}

	public String getUrl() {
		return url;
	}

	public String getTitle() {
		return title;
	}

	public String getDescription() {
		return description;
	}

	public Date getDate() {
		return date;
	}

	public void setId(long id) {
		this.id = id;
	}

	public void setGame(Game game) {
		this.game = game;
	}

	public void setPage(String page) {
		this.page = page;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public void setDate(Date date) {
		this.date = date;
	}
}

Mit @Entity wird die Klasse markiert, damit ihre Objekte persistent gemacht werden können. Standardmäßig geht die JPA-Implementierung davon aus, dass jedes Attribut in die Datenbank abgebildet werden soll. Da außerdem je nach Java-Datentyp bestimmte Datenbank-Datentypen automatisch zugeordnet werden, können wir uns an vielen Variablen die Annotationen sparen. Damit ein Datenbankeintrag eindeutig referenziert werden kann, braucht jede Zeile eine ID – diese müssen wir mit in unsere Klasse einbauen und mit @Id markieren, @GeneratedValue(strategy = GenerationType.AUTO) zeigt dabei an, dass der Wert generiert werden soll. Zu Game gibt es eine Beziehung, so kann jedes Spiel mehrere News haben, aber jede News ist genau einem Spiel zugeordnet. Eine Fremdschlüsselspalte wird automatisch angelegt.

package net.rattlab.model;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.NamedQuery;

import org.hibernate.annotations.CollectionOfElements;
import org.hibernate.annotations.MapKey;

@Entity
@NamedQuery(name = "findAllGames", query = "from Game")
public class Game implements Serializable {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private long id;

	private String name;

	@CollectionOfElements
	@JoinTable(name = "feed", joinColumns = @JoinColumn(name = "game"))
	@Column(name = "url")
	@MapKey(columns = @Column(name = "site"))
	private Map feeds;

	public Game() {}

	public Game(String name) {
		setName(name);
		feeds = new HashMap();
	}

	public void addFeed(String page, String url) {
		feeds.put(page, url);
	}

	public Map getFeeds() {
		return feeds;
	}

	public long getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	public void setId(long id) {
		this.id = id;
	}

	public void setName(String name) {
		this.name = name;
	}
}

Hier benötigt die Map, die die Feed-URLs mit ihren Namen speichert, besondere Aufmerksamkeit. Mit JPA allein ist es nicht möglich, primitive Datentypen oder Strings in einer Collection oder Map zu halten, weshalb wir hier direkt auf Hibernate-Annotations zurückgreifen müssen. Für die Map muss eine eigene Tabelle angelegt werden, deren Spaltennamen wir vorgeben, sonst würden diese KEY und VALUE heißen.

Da wir für Tabellen- und Spaltennamen kaum Vorgaben gemacht haben, werden sie einfach aus den Namen der Attribute abgeleitet. Die Tabellen heißen also Game und News, die Spalten name, page usw. Bei Galileo Computing findet ihr eine gute Übersicht über alle Entity-Annotationen.

Lesen und Schreiben auf der Datenbank

Jetzt ersetzen wir erstmal ganz plump die beiden Listen in der WicketApplication und fügen Datenbankzugriffe hinzu. Hier werden NamedQuerys erstellt, die wir vorher mit @NamedQuery in den Entities angegeben haben. Auf die manuelle Sortierung der News können wir jetzt verzichten, da diese beim Datenbankzugriff schon sortiert ausgelesen werden (siehe entsprechenden benannten Query).

package net.rattlab.wicket;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import net.rattlab.model.Game;
import net.rattlab.model.News;

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

import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.FeedException;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

/**
 * Application object for your web application. If you want to run this application without deploying, run the Start class.
 *
 * @see net.rattlab.wicket.Start#main(String[])
 */
public class WicketApplication extends WebApplication {

	private EntityManagerFactory entityManagerFactory;

	/**
	 * Constructor
	 */
	public WicketApplication() {
		entityManagerFactory = Persistence.createEntityManagerFactory("feed");

		EntityManager entityManager = entityManagerFactory.createEntityManager();
		createGames(entityManager);
		createNews(entityManager);
		entityManager.close();
	}

	/**
	 * Creates the games and news feeds.
	 */
	protected void createGames(EntityManager entityManager) {
		EntityTransaction transaction = entityManager.getTransaction();
		transaction.begin();

		Game starcraft2 = new Game("StarCraft 2");
		Game diablo3 = new Game("Diablo 3");

		starcraft2.addFeed("inStarCraft", "http://starcraft2.ingame.de/feed.php?type=RSS1.0&section=345");
		starcraft2.addFeed("StarCraft 2 Mecca", "http://forum.gamersunity.de/external.php?type=rss2&forumids=195");
		diablo3.addFeed("inDiablo", "http://diablo3.ingame.de/feed.php?type=RSS1.0");
		diablo3.addFeed("Diablo 3 Source", "http://diablo3.4players.de/rss_feed.xml");

		entityManager.persist(starcraft2);
		entityManager.persist(diablo3);

		transaction.commit();
	}

	/**
	 * Creates the news from the news feeds.
	 */
	protected void createNews(EntityManager entityManager) {
		EntityTransaction transaction = entityManager.getTransaction();
		transaction.begin();
		SyndFeedInput input = new SyndFeedInput();
		for (Game game : getGames(entityManager)) {
			Map feeds = game.getFeeds();
			for (String page : feeds.keySet()) {
				String feedUrl = feeds.get(page);
				try {
					URL url = new URL(feedUrl);
					SyndFeed feed = input.build(new XmlReader(url));
					for (Object o : feed.getEntries()) {
						// rome 0.9 does not support generics
						SyndEntry entry = (SyndEntry) o;
						entityManager.persist(new News(game, page, entry.getLink(), entry.getTitle(),
								entry.getDescription().getValue(), entry.getPublishedDate()));
					}
				}
				catch (MalformedURLException exc) {}
				catch (IllegalArgumentException e) {}
				catch (FeedException e) {}
				catch (IOException e) {}
			}
		}
		transaction.commit();
	}

	@Override
	protected void init() {
		super.init();
		getMarkupSettings().setStripWicketTags(true);
	}

	public static WicketApplication get() {
		return (WicketApplication) Application.get();
	}

	/**
	 * @see org.apache.wicket.Application#getHomePage()
	 */
	public Class getHomePage() {
		return HomePage.class;
	}

	@SuppressWarnings("unchecked")
	public List getGames() {
		EntityManager entityManager = entityManagerFactory.createEntityManager();
		List games = entityManager.createNamedQuery("findAllGames").getResultList();
		entityManager.close();
		return games;
	}

	@SuppressWarnings("unchecked")
	public List getGames(EntityManager entityManager) {
		return entityManager.createNamedQuery("findAllGames").getResultList();
	}

	@SuppressWarnings("unchecked")
	public List getNews() {
		EntityManager entityManager = entityManagerFactory.createEntityManager();
		List news = entityManager.createNamedQuery("findAllNews").getResultList();
		entityManager.close();
		return news;
	}
}

Das ist jetzt zugegebenermaßen nicht die schönste Lösung, aber so können wir erstmal testen, ob der Kram überhaupt funktioniert. Die nötigen Tabellen in der Datenbank werden übrigens automatisch erzeugt. In der persistence.xml gibt es eine Zeile , die beim Starten unserer Anwendung aus den bestehenden Annotationen ein Datenbankschema erstellt und beim Beenden alles wieder löscht. Ideal ist sowas für automatisierte Tests, da so immer wieder auf einer frischen Datenbank gearbeitet wird, womit die Ergebnisse reproduzierbar bleiben.

Das scheinbar willkürliche Erstellen von EntityManager und Starten von EntityTransaction wollen wir nun, nachdem wir wissen, dass unsere Applikation funktioniert, etwas schicker gestalten. Optimal wäre es, wenn wir uns nicht darum kümmern müssten, wann ein neuer Manager benötigt oder eine neue Transaktion gestartet werden muss. Die Hibernate-Dokumentation beschreibt ein Open Session in View Pattern, bei dem für jeden Request ein neuer Manager samt Transaktion gestartet wird, die am Ende des Requests wieder geschlossen werden. Das bietet sich für Webanwendungen natürlich an.

Allerdings können wir das Beispiel, wie es in der Dokumentation angegeben ist, nicht eins zu eins übernehmen, da wir mit JPA arbeiten und nicht direkt mit Session oder SessionFactory von Hibernate. Außerdem wollen wir auch keinen ServletFilter nutzen, sondern direkt in dem von uns benutzten Web-Framework ansetzen. Bei Wicket ist die ideale Stelle dafür der WebRequestCycle. Für jede Anfrage wird ein neues solches Objekt erzeugt und es hat Methoden, die angesprochen werden, wenn die Anfrage beginnt (onBeginRequest) und wenn sie aufhört (onEndRequest).

package net.rattlab.wicket;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

import org.apache.wicket.Page;
import org.apache.wicket.Response;
import org.apache.wicket.protocol.http.WebApplication;
import org.apache.wicket.protocol.http.WebRequest;
import org.apache.wicket.protocol.http.WebRequestCycle;

import persistence.JpaUtil;

public class JpaRequestCycle extends WebRequestCycle {

	public JpaRequestCycle(WebApplication application, WebRequest request, Response response) {
		super(application, request, response);
	}

	@Override
	protected void onBeginRequest() {
		super.onBeginRequest();
		EntityManager manager = JpaUtil.getEntityManagerFactory().createEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		transaction.begin();
		JpaUtil.setCurrentEntityManager(manager);
	}

	@Override
	protected void onEndRequest() {
		super.onEndRequest();
		EntityManager manager = JpaUtil.getCurrentEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		if (transaction.isActive()) {
			transaction.commit();
		}
		if (manager.isOpen()) {
			manager.close();
		}
	}

	@Override
	public Page onRuntimeException(Page page, RuntimeException e) {
		EntityManager manager = JpaUtil.getCurrentEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		if (transaction.isActive()) {
			transaction.rollback();
		}
		if (manager.isOpen()) {
			manager.close();
		}
		return super.onRuntimeException(page, e);
	}
}

Wir nutzen hierbei eine von uns geschriebene Klasse JpaUtil, über die wir später auf den EntityManager zugreifen. Dieser muss für die Dauer des Requests irgendwo gespeichert werden und dabei müssen wir noch eines beachten: Parallelität. EntityManager ist nicht threadsicher, darf also nur von einem Thread zur gleichen Zeit benutzt werden, was auch überhaupt der Grund ist, wieso wir das Open Session in View Pattern einsetzen wollen. Dafür nutzen wir im JpaUtil eine Variable, die lokal für jeden Thread engelegt wird, ThreadLocal. Darin speichern wir unseren Manager und nun hat jeder Thread seinen eigenen und somit auch jeder Request, denn ein Request wird von genau einem Thread ausgeführt (und jeder Thread hat zu einem Zeitpunkt maximal einen Request).

package net.rattlab.persistence;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JpaUtil {

	private static final EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("feed");
	private static final ThreadLocal entityManager = new ThreadLocal();

	public static EntityManagerFactory getEntityManagerFactory() {
		return entityManagerFactory;
	}

	public static EntityManager getCurrentEntityManager() {
		return entityManager.get();
	}

	public static void setCurrentEntityManager(EntityManager manager) {
		entityManager.set(manager);
	}
}

Schließlich müssen wir noch unsere WicketApplication dahingehend umbauen, dass unser neuer RequestCycle auch tatsächlich benutzt wird und dass wir uns den EntityManager vom JpaUtil holen. Außerdem müssen wir uns einmal außerhalb des Anfragezyklus einen Manager samt Transaktion besorgen, da das Füllen der Daten aus den Newsfeeds nicht während eines Requests passiert, sondern beim Starten des Servers.

package net.rattlab.wicket;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

import net.rattlab.model.Game;
import net.rattlab.model.News;

import org.apache.wicket.Application;
import org.apache.wicket.Request;
import org.apache.wicket.RequestCycle;
import org.apache.wicket.Response;
import org.apache.wicket.protocol.http.WebApplication;
import org.apache.wicket.protocol.http.WebRequest;

import persistence.JpaUtil;

import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.FeedException;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

/**
 * Application object for your web application. If you want to run this application without deploying, run the Start class.
 *
 * @see net.rattlab.wicket.Start#main(String[])
 */
public class WicketApplication extends WebApplication {

	/**
	 * Constructor
	 */
	public WicketApplication() {
		try {
			EntityManager manager = JpaUtil.getEntityManagerFactory().createEntityManager();
			EntityTransaction transaction = manager.getTransaction();
			transaction.begin();
			JpaUtil.setCurrentEntityManager(manager);

			createGames();
			createNews();

			transaction.commit();
		} catch (RuntimeException exc) {
			JpaUtil.getCurrentEntityManager().getTransaction().rollback();
			throw exc;
		} finally {
			JpaUtil.getCurrentEntityManager().close();
		}
	}

	/**
	 * Creates the games and news feeds.
	 */
	protected void createGames() {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();

		Game starcraft2 = new Game("StarCraft 2");
		Game diablo3 = new Game("Diablo 3");

		starcraft2.addFeed("inStarCraft", "http://starcraft2.ingame.de/feed.php?type=RSS1.0&section=345");
		starcraft2.addFeed("StarCraft 2 Mecca", "http://forum.gamersunity.de/external.php?type=rss2&forumids=195");
		diablo3.addFeed("inDiablo", "http://diablo3.ingame.de/feed.php?type=RSS1.0");
		diablo3.addFeed("Diablo 3 Source", "http://diablo3.4players.de/rss_feed.xml");

		entityManager.persist(starcraft2);
		entityManager.persist(diablo3);
	}

	/**
	 * Creates the news from the news feeds.
	 */
	protected void createNews() {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();
		SyndFeedInput input = new SyndFeedInput();
		for (Game game : getGames()) {
			Map feeds = game.getFeeds();
			for (String page : feeds.keySet()) {
				String feedUrl = feeds.get(page);
				try {
					URL url = new URL(feedUrl);
					SyndFeed feed = input.build(new XmlReader(url));
					for (Object o : feed.getEntries()) {
						// rome 0.9 does not support generics
						SyndEntry entry = (SyndEntry) o;
						entityManager.persist(new News(game, page, entry.getLink(), entry.getTitle(),
								entry.getDescription().getValue(), entry.getPublishedDate()));
					}
				}
				catch (MalformedURLException exc) {}
				catch (IllegalArgumentException e) {}
				catch (FeedException e) {}
				catch (IOException e) {}
			}
		}
	}

	@Override
	protected void init() {
		super.init();
		getMarkupSettings().setStripWicketTags(true);
	}

	public static WicketApplication get() {
		return (WicketApplication) Application.get();
	}

	/**
	 * @see org.apache.wicket.Application#getHomePage()
	 */
	public Class getHomePage() {
		return HomePage.class;
	}

	@Override
	public RequestCycle newRequestCycle(Request request, Response response) {
		return new JpaRequestCycle(this, (WebRequest) request, response);
	}

	@SuppressWarnings("unchecked")
	public List getGames() {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();
		return entityManager.createNamedQuery("findAllGames").getResultList();
	}

	@SuppressWarnings("unchecked")
	public List getNews() {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();
		return entityManager.createNamedQuery("findAllNews").getResultList();
	}
}

Speicher schonen

Noch sind wir aber nicht an unserem Ziel angelangt. Aktuell werden nämlich alle News zusammen mit der (letzten Version der) Seite in der Session gespeichert – das hängt damit zusammen, dass Wicket, da unsere Applikation zustandsorientiert ist, den aktuellen Status speichert. Das wollen wir aber nicht, da das in diesem Fall einen recht sinnfreien Ressourcenverbrauch darstellt. Dafür kann man ein LoadableDetachableModel nutzen, das am Ende eines Requests sein Objekt abkoppelt und es bei der nächsten Anfrage wieder lädt, so dass die Session nicht damit belastet wird.

Die simple Nutzung eines LoadableDetachableModels allein würde uns bei einem anderen Problem aber nicht helfen. Es würden nämlich alle News auf einmal geladen, obwohl nur eine bestimmte Anzahl pro Seite angezeigt werden – sinnvoller wäre es, wenn nur genau die News aus der Datenbank geholt würden, die auch angezeigt werden sollen. Dafür gibt es eine Komponente DataView, der ein IDataProvider statt eines Models übergeben wird. Dieser holt bestimmte Datensätze und verpackt sie in Models. Da die Daten dann bereits im Speicher vorhanden sind, bringt uns auch ein LoadableDetachableModel nur bedingt etwas, denn das würde das Objekt anhand der ID nochmal laden, weshalb wir uns ein eigenes Model bauen.

Werfen wir zuerst einen Blick auf den NewsDataProvider. An der Methode iterator(int first, int count) ist zu erkennen, dass tatsächlich nur eine bestimmte Anzahl von News angefordert werden. Sie gibt einen Iterator zurück, den die DataView nutzt, um die einzelnen News zu holen. Damit wird dann die Methode model(News news) aufgerufen, die jede News in ein eigenes Model steckt.

public class NewsDataProvider implements IDataProvider {

	@Override
	@SuppressWarnings("unchecked")
	public Iterator iterator(int first, int count) {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();
		return entityManager.createNamedQuery("findAllNews")
				.setFirstResult(first)
				.setMaxResults(count)
				.getResultList()
				.iterator();
	}

	@Override
	public IModel model(News news) {
		return new NewsModel(news);
	}

	@Override
	public int size() {
		EntityManager entityManager = JpaUtil.getCurrentEntityManager();
		return ((Long) entityManager.createNamedQuery("countNews").getSingleResult()).intValue();
	}

	@Override
	public void detach() {}
}

Das NewsModel ist nicht von LoadableDetachableModel abgeleitet, da wir keinen schreibenden Zugriff auf das zu speichernde Objekt hätten, sondern dieses immer über load() geladen werden müsste. Dennoch ist die Model-Klasse recht einfach und übersichtlich. Es speichert die ID und die News selbst, beim Speichern in der Session wird die News aber nicht serialisiert. Werden die Daten wieder aus der Session geholt (z.B. durch ein Neu Laden der Seite), so wird die News anhand der ID erneut aus der Datenbank geladen. Eine allgemein gehaltenere Version eines solchen Models beschreibt Igor Vaynberg, einer der Wicket-Mitentwickler, im Blogeintrag “Building a smart EntityModel”.

public class NewsModel implements IModel {

	private Long id;
	private transient News news;

	public NewsModel(News news) {
		this.id = news.getId();
		this.news = news;
	}

	@Override
	public News getObject() {
		if (null == news && null != id) {
			EntityManager manager = JpaUtil.getCurrentEntityManager();
			news = manager.find(News.class, id);
		}
		return news;
	}

	@Override
	public void setObject(News object) {
		throw new UnsupportedOperationException("Model " + getClass() +
				" does not support setObject(Object)");
	}

	@Override
	public void detach() {
		news = null;
	}
}

Im Konstruktor der NewsList-Komponente stehen auch noch einige Veränderungen aus. Zum einen soll eine DataView verwendet werden, zum anderen aber sind dort noch zwei Stolpersteine aus dem Weg zu räumen, die dafür sorgen, dass die News dennoch in der Session serialisiert abgespeichert werden. Das Problem war, dass die News als final deklariert war und von zwei Models referenziert wurde – das umgehen wir, indem wir über das Model auf die News zugreifen.

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

		DataView newsList = new DataView("news", new NewsDataProvider(), 15) {
			@Override
			protected void populateItem(final Item item) {
				News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return item.getModelObject().getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()).setEscapeModelStrings(false));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));

				MultiLineLabel description = new MultiLineLabel("description", news.getDescription());
				description.setEscapeModelStrings(false);
				item.add(description);
				item.add(new ChangeVisibilityLink("expand", description));

				item.add(new DateTimeLabel("date", new PropertyModel(item.getModel(), "date")));
			}
		};
		newsList.setItemReuseStrategy(new ReuseIfModelsEqualStrategy());
		newsList.add(new ToggleTextBehavior("ul.newslist > li a.expand", "[+]", "[-]"));
		add(newsList);
		add(new PagingNavigator("pagenavigation", newsList));
	}

Wir ersetzen außerdem den Aufruf von newsList.setReuseItems(true);, da es diese Methode bei DataView nicht gibt, durch newsList.setItemReuseStrategy(new ReuseIfModelsEqualStrategy());, was uns im Grunde das selbe Verhalten gibt. Damit das funktioniert, musste unser NewsModel die equals-Methode überschreiben, damit ein sinnvoller Vergleich zustande kommt. Ist ein neues Model gleich dem bestehenden alten, so wird das alte Item wiederverwendet, was für die Funktionalität des Aufklappens der Beschreibung ohne JavaScript notwendig ist. Da wir direkt mit der ID vergleichen, muss die News des alten Models (die ja losgelöst wurde) auch nicht extra aus der Datenbank geladen werden.

Zu guter Letzt muss nun nur noch das Erstellen der NewsList in HomePage angepasst werden, denn dort ist es nicht mehr nötig, die Liste mit News zu übergeben. Nun wird auch eigentlich getNews() in WicketApplication nicht mehr benötigt. Wie üblich könnt ihr euch den kompletten Sourcecode herunterladen.

Fazit

Mit einer Menge Aufwand wurde die kleine Anwendung nun auf eine Datenbank aufgesetzt. Das hat mich weit mehr Zeit gekostet, als die vorangegangenen Tutorials, da ich mich recht frisch in die Thematik eingearbeitet habe und einige Stolpersteine aus dem Weg räumen musste. Dafür bin ich jetzt um einige Erfahrungen reicher. Perfekt ist das Projekt aber noch immer nicht, denn es wäre z.B. auch schön, wenn die News dauerhaft in der Datenbank bleiben und sie regelmäßig aktualisiert werden würden, z.B. mittels Timer und TimerTask. Das darf sich aber jeder selber überlegen, sonst kommt dieser Beitrag nie zu einem Ende.

Dynamik für den Feedreader

Peter — Mon, 29 Sep 2008 19:24:59 +0000

Im letzten Teil haben wir eine Wicket-Komponente entwickelt, die Newsfeeds schick anzeigt. Die nötigen Daten haben wir mittels Rome aus echten Feeds erhalten. Heute wollen wir unsere Newsansicht optimieren, denn diese ist noch reichlich unübersichtlich. Dabei bringen wir auch Dynamik mittels JavaScript und Third-Party-Libraries, in unserem Fall jQuery, ins Spiel.

Mehrseitigkeit

Doch bevor es dynamisch wird, sorgen wir ersteinmal dafür, dass nicht alle News auf einer Seite stehen. Für solche Zwecke verwenden wir eine PageableListView in Verbindung mit einem PageNavigator. Damit nun also immer maximal 15 News auf einmal angezeigt werden, passen wir unsere Komponente entsprechend an:

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		PageableListView newsList = new PageableListView("news", news, 15) {
			@Override
			protected void populateItem(ListItem item) {
				final News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return news.getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()).setEscapeModelStrings(false));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));
				item.add(new MultiLineLabel("description", news.getDescription()).setEscapeModelStrings(false));
				item.add(new DateTimeLabel("date", new PropertyModel(news, "date")));
			}
		};
		add(newsList);
		add(new PagingNavigator("pagenavigation", newsList));
	}
}

Die Änderung am Markup ist recht trivial:




	





	
		
			01.01.1970
			Seite: 
			Beschreibung

Ajax

Ein nächster störender Punkt sind die unterschiedlichen Beschreibungstexte. Während es in manchen Feeds nur kurze Beschreibungen gibt, findet sich in anderen der komplette Newstext mit Bildern und allem drum und dran wieder. Dadurch geht viel Übersicht verloren, da die Abstände zwischen den News sehr uneinheitlich sind und zumeist will man sowieso nur wissen, wo es etwas Neues gibt und dann dem Link folgen, um den Text auf der Ursprungsseite zu lesen.

Im einfachsten Fall also könnte man die Beschreibung einfach wegfallen lassen, aber der ein oder andere will sich ja vielleicht doch ein Bild machen, um festzustellen, ob er die News lesen will oder sie vielleicht sogar schon kennt. An dieser Stelle bietet es sich an, die Beschreibung optional einblenden zu lassen. Um mal ein Gefühl dafür zu kriegen, wie man Wicket und Ajax verbindet, werden wir erstmal Ajax verwenden. Klar, unsere News braucht also erstmal einen Link (ich habe die HTML-Datei mal auf das wesentliche gekürzt, da wir sie eben schon gesehen haben):

		
			01.01.1970
			[+]
			Seite: 
			Beschreibung

Im Java-Code gibt es nun einige Neuerungen, die ich gleich erklären werde.

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		PageableListView newsList = new PageableListView("news", news, 15) {
			@Override
			protected void populateItem(ListItem item) {
				final News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return news.getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()).setEscapeModelStrings(false));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));

				MultiLineLabel description = new MultiLineLabel("description", news.getDescription());
				description.setEscapeModelStrings(false);
				description.setOutputMarkupPlaceholderTag(true);
				description.setVisible(false);
				item.add(description);
				item.add(new ChangeVisibilityLink("expand", description));

				item.add(new DateTimeLabel("date", new PropertyModel(news, "date")));
			}
		};
		newsList.setReuseItems(true);
		add(newsList);
		add(new PagingNavigator("pagenavigation", newsList));
	}

	class ChangeVisibilityLink extends AjaxFallbackLink {

		private Component component;

		public ChangeVisibilityLink(String id, Component component) {
			super(id);
			this.component = component;
		}

		@Override
		public void onClick(AjaxRequestTarget target) {
			component.setVisible(!component.isVisible());
			if (null != target) {
				target.addComponent(component);
			}
		}
	}
}

Das MultiLineLabel, das die Beschreibung darstellt, erhält jetzt etwas mehr Aufmerksamkeit. Der erste neue Aufruf ist setOutputMarkupPlaceholderTag(true), der dafür sorgt, dass ein Platzhalter im Code gelassen wird, wenn das Element nicht sichtbar ist. In der nächsten Zeile wird die Beschreibung unsichtbar gemacht, was normalerweise bedeutet, dass das gesamte HTML-Element in der gerenderten Seite gar nicht mehr vorkommt. Dann wüsste das JavaScript aber nicht, wo es den Beschreibungstext hinschreiben sollte, wenn der Link angeklickt wird – deswegen brauchen wir den Platzhalter, der dann einfach ersetzt wird.

Schließlich wird noch der neue Link hinzugefügt, der fürs Ändern der Sichtbarkeit der Beschreibung zuständig ist. Diesen finden wir als innere Klasse in unserer Komponente und abgeleitet ist sie von AjaxFallbackLink, wodurch gewährleistet ist, dass die Funktionalität sowohl mit, als auch ohne JavaScript gegeben ist. Im Konstruktor speichern wir das Element, dessen Sichtbarkeit geändert werden soll. Wichtig ist die Methode onClick(), die wir überschreiben müssen. Dort notieren wir die Anweisungen, die beim Klicken des Links ausgeführt werden sollen, wir Ändern also die Sichtbarkeit. Außerdem wird ein AjaxRequestTarget übergeben, das null ist, wenn es sich um keinen Ajax-Request handelt. Diesem Target werden die Elemente übergeben, die neu geladen werden sollen, in unserem Fall ist das also einfach nur die Beschreibung.

Ich hatte anfangs das Problem, dass zwar die Ajax-Funktionalität wunderbar lief, aber wenn ich JavaScript deaktivierte, dann geschah nix weiter, als dass die Seite neu geladen wurde. Beschreibungen wurden nicht sichtbar. Eine ganze Weile musste ich herumrätseln, bis ich auf die Lösung stieß: Bei jedem Request erneuert sich die Liste von selbst, da sich ja Listenelemente geändert haben könnten. Dabei wird auch populateItem() von neuem aufgerufen und unter anderem ein völlig neues MultiLineLabel erstellt – die Sichtbarkeitsänderung bezieht sich also auf ein Element, dass es beim erneuten Rendern gar nicht mehr gibt. Deswegen findet sich noch der Aufruf von newsList.setReuseItems(true); in unserer Komponente, denn die verhindert, dass sich die ListView neu erstellt.

Mehr Dynamik

Eigentlich sieht jetzt alles toll aus. Die Beschreibungen sind eingeklappt und per Ajax können wir sie ausklappen. Allerdings dauert das unter Umständen eine Weile, wenn wir nicht lokal arbeiten, sondern übers Internet. Da wäre es doch sinnvoller, die Beschreibung gleich zu laden und dann nur mit normalem JavaScript die Sichtbarkeit zu ändern. Das ist auch mein Ziel für heute – der Ajax-Kram war eher mal Neugierde, weil ich das auch mal probieren wollte.

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		PageableListView newsList = new PageableListView("news", news, 15) {
			@Override
			protected void populateItem(ListItem item) {
				final News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return news.getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()).setEscapeModelStrings(false));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));

				MultiLineLabel description = new MultiLineLabel("description", news.getDescription());
				description.setEscapeModelStrings(false);
				item.add(description);
				item.add(new ChangeVisibilityLink("expand", description));

				item.add(new DateTimeLabel("date", new PropertyModel(news, "date")));
			}
		};
		newsList.setReuseItems(true);
		add(newsList);
		add(new PagingNavigator("pagenavigation", newsList));
	}

	class ChangeVisibilityLink extends Link {

		private Component component;
		private AttributeModifier visibilityModifier;
		private boolean visible;

		public ChangeVisibilityLink(String id, Component component) {
			super(id);
			this.component = component;
			visibilityModifier = new AttributeModifier("style", true, new Model("display:none;"));
			visible = false;

			component.add(visibilityModifier);
			add(new ChangeVisibilityBehavior(component));
		}

		@Override
		public void onClick() {
			if (visible) {
				component.add(visibilityModifier);
				visible = false;
			} else {
				component.remove(visibilityModifier);
				visible = true;
			}
		}
	}

	class ChangeVisibilityBehavior extends AbstractBehavior {

		private Component component;

		public ChangeVisibilityBehavior(Component component) {
			this.component = component;
			component.setOutputMarkupId(true);
		}

		@Override
		public void onComponentTag(Component component, ComponentTag tag) {
			super.onComponentTag(component, tag);
			String action = "var n = document.getElementById('" + this.component.getMarkupId() + "'); ";
			action += "var d = n.style.display; n.style.display = d == 'block' ? 'none' : 'block'; return false;";
			tag.put("onclick", action);
		}
	}
}

Wieder wurden zahlreiche Änderungen durchgeführt. Zuersteinmal wird die Beschreibung nicht unsichtbar gemacht, denn schließlich soll das MultiLineLabel mitsamt des Beschreibungstextes gerendert werden. Den Aufruf von setOutputMarkupPlaceholderTag(true) können wir uns auch sparen, da das Element ja auf jeden Fall komplett angezeigt wird.

Der Link zum Ändern der Sichtbarkeit erbt nicht mehr von AjaxFallbackLink, sondern ist nur noch ein ganz normaler Link, der im Falle von deaktiviertem JavaScript immer noch seinen Dienst tun soll. Deshalb erhält die Komponente einen AttributeModifier, der das nötige style-Attribut an Ort und Stelle bringt. Wird der Link betätigt, so wird die onClick()-Methode ausgeführt (wie bisher auch) und dort wird je nach dem, ob die Komponente sichtbar ist, der Modifikator hinzugefügt oder entfernt. Mit isVisible() und setVisible() können wir hier ja nicht arbeiten, da wie bereits erwähnt das gesamte Element immer im HTML-Code erscheinen soll.

Doch das eigentliche Ziel war es ja, die Funktionalität ohne Request an den Server umzusetzen. Dafür machen wir uns eine Behavior zunutze, mit der man allerlei Dinge anstellen kann. Im einfachsten Fall wird damit ein Attribut zum HTML-Element hinzugefügt, ähnlich wie beim AttributeModifier, aber die Möglichkeiten sind vielfältig. So wäre es auch möglich, das Tag auf noch ganz andere Arten zu verändern oder Anweisungen in den Kopf der HTML-Datei zu schreiben. Wir aber beschränken uns darauf, etwas JavaScript ins onclick-Attribut zu geben. Das sieht auf den ersten Blick zugegebenermaßen nicht besonders schick aus, aber es erfüllt seinen Zweck. Die letzte JavaScript-Anweisung, return false;, sorgt dafür, dass das Klicken auf den Link keinen Request an den Server zur Folge hat – sonst würde die Seite anschließend neu geladen werden.

Die Funktionalität ist jetzt gegeben, aber ganz zufrieden bin ich noch nicht. Der selbstgeschriebene JavaScript-Code ist nicht besonders schick und das Auf- bzw. Zuklappen ist irgendwie langweilig. Eine JavaScript-Bibliothek soll dabei beide Fliegen mit einer Klappe schlagen. Ich habe mich für jQuery entschieden – einfach, weil es irgendwie einen sympathischen Eindruck auf mich gemacht hat. Auch gut finde ich die Möglichkeit, mittels CSS-Selektoren auf mehrere HTML-Elemente zugreifen zu können, auch wenn ich das heute nicht nutzen will.

Wir müssen nur unsere Behavior anpassen, um zum gewünschten Erfolg zu kommen:

	class ChangeVisibilityBehavior extends AbstractBehavior {

		private Component component;

		public ChangeVisibilityBehavior(Component component) {
			this.component = component;
			component.setOutputMarkupId(true);
		}

		@Override
		public void renderHead(IHeaderResponse response) {
			super.renderHead(response);
			response.renderJavascriptReference(new ResourceReference(NewsList.class, "jquery-1.2.6.min.js"));
		}

		@Override
		public void onComponentTag(Component component, ComponentTag tag) {
			super.onComponentTag(component, tag);
			tag.put("onclick", "$('#" + this.component.getMarkupId() + "').slideToggle(200);return false;");
		}
	}

In der Methode renderHead sorgen wir dafür, dass die JavaScript-Bibliothek verwendet wird. Diese habe ich einfach in das selbe Verzeichnis kopiert, in dem auch die Klassen und HTML-Dateien liegen. Wir müssen uns keine Sorgen machen, dass sie nun 15 mal eingebunden wird – Wicket kümmert sich darum, dass es nur einmal gemacht wird. In onComponentTag wird nun mittels eines Befehls ein Slide-Effekt ausgelöst und der Code sieht schon viel aufgeräumter auf.

Mit jQuery kann man auch auf andere Art und Weise Events an Elemente koppeln und auf diese Elemente kann man per Selektoren, wie man sie aus CSS kennt, zugreifen. Das probiere ich aus, indem ich das Plus vom Aufklapp-Link durch ein Minus ersetze, wenn geklickt wird. Dazu schreibe ich eine neue Behavior:

	class ToggleTextBehavior extends AbstractBehavior {

		private String cssSelector;
		private String text;
		private String otherText;

		public ToggleTextBehavior(String cssSelector, String text, String otherText) {
			this.cssSelector = cssSelector;
			this.text = text;
			this.otherText = otherText;
		}

		public void renderHead(IHeaderResponse response) {
			super.renderHead(response);
			response.renderJavascriptReference(new ResourceReference(NewsList.class, "jquery-1.2.6.min.js"));
			StringBuilder javascript = new StringBuilder();
			javascript.append("$(document).ready(function() {\n");
			javascript.append("  $('" + cssSelector + "').toggle(function() {\n");
			javascript.append("    $(this).empty().append('" + otherText + "');\n");
			javascript.append("  }, function() {\n");
			javascript.append("    $(this).empty().append('" + text + "');\n");
			javascript.append("  })\n");
			javascript.append("});");
			response.renderJavascript(javascript, null);
		}
	}

An welches Element sie gehangen wird, ist unerheblich, da hier nur der Header verändert wird. Man könnte es an die ListView hängen, aber auch direkt an den ChangeVisibilityLink und natürlich muss man sich auch hier keine Sorgen machen, dass der Code evtl. mehrmals angezeigt wird.

newsList.add(new ToggleTextBehavior("ul.newslist > li a.expand", "[+]", "[-]"));

Damit dieser hier verwendete Selektor funktioniert, braucht der Aufklapp-Link noch eine CSS-Klasse namens “expand”. Abgesehen davon spart man sich viele verschiedene IDs an den Tags – auch den Aufklapp-Effekt der Beschreibung hätten wir auf diese Art umsetzen können. Wer nicht zig Behaviors selber schreiben will, der kann sich mal Wickext ansehen. Das ist ein Projekt, das versucht, Wicket und jQuery zusammenzuführen, so dass der Anwender dann keinen eigenen JavaScript-Code mehr schreiben muss.

Fazit

Damit haben wir heute schon etwas erreicht. Die News sind wesentlich übersichtlicher und werden aufs Nötigste reduziert – Titel, Link und Zeitpunkt. Optional kann man sich mit einem Klick die Beschreibung anzeigen lassen, die stylish aufklappt oder, falls JavaScript deaktiviert ist, über einen normalen Request abläuft, damit niemand außen vor gelassen wird. Außerdem haben wir gesehen, wie einfach es ist, ein wenig Ajax in die Anwendung zu bringen, auch wenn wir diesen Ansatz dann wieder verworfen haben. Das gesamte Projekt könnt ihr euch natürlich herunterladen.

Was kommt als nächstes? Abgesehen davon, dass der Code nicht kommentiert ist und manche der inneren Klassen durchaus in eigene ausgelagert werden könnten, gibt es auch noch immer funktionale Schwachstellen. Der Feed wird immer beim Start des Servers geladen und dann nie wieder aktualisiert. Alle News werden zusammen mit der WebPage serialisiert und in der Session hinterlegt, was unnützer Verbrauch von Ressourcen ist. Es gibt also noch jede Menge zu tun.

Der dritte Teil geht das Problem mit JPA und Hibernate an: Persistenz für den Feedreader.

Wicket Feedreader

Peter — Sun, 21 Sep 2008 09:58:55 +0000

Nachdem ich mich vor einiger Zeit mit Maven beschäftigt und schließlich ein kleines Wicket-Projekt angelegt habe, möchte ich nun endlich etwas tiefer in die Materie eindringen. Heute entwickeln wir eine Wicket-Komponente, die News anzeigt. Die nötigen News bekommen wir aus Newsfeeds verschiedener Spiele-Fanseiten, so dass ich nicht erst zig Seiten nach Neuigkeiten abklappern muss. Ja, ich weiß, dass es Feedreader gibt, aber ich fand das eine gute Idee, um mal etwas zu basteln.

Den Grundstein legen

Zuerst legen wir ein neues Wicket-Projekt an. Da erst die Version 1.4 von Wicket auch Generics unterstützt, möchte ich diese (noch nicht finale) Version nutzen. Im Formular der Quickstart-Anleitung wählen wir uns deshalb die Version 1.4-m3 aus, das ist der dritte (und derzeit aktuellste) Milestone. Außerdem passen wir noch ArtifactID und GroupId an unsere Bedürfnisse an. Wir wechseln in unser Projekt-Verzeichnis, kopieren den Code aus dem Formular in die Shell und führen ihn aus. Ich probiere bei dieser Gelegenheit auch gleich Cygwin aus – das Einfügen des vorher kopierten Codes geschieht hier mittels Rechtsklick.

$ cd /cygdrive/c/myprojects
$ mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=1.4-m3 -DgroupId=net.rattlab.wicket -DartifactId=wicket
[...]
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating OldArchetype: wicket-archetype-quickstart:1.4-m3
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: net.rattlab.wicket
[INFO] Parameter: packageName, Value: net.rattlab.wicket
[INFO] Parameter: package, Value: net.rattlab.wicket
[INFO] Parameter: artifactId, Value: wicket
[INFO] Parameter: basedir, Value: c:\myprojects
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] ********************* End of debug info from resources from generated POM ***********************
[INFO] OldArchetype created in dir: c:\myprojects\wicket
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4 seconds
[INFO] Finished at: Thu Sep 18 19:21:18 CEST 2008
[INFO] Final Memory: 7M/14M
[INFO] ------------------------------------------------------------------------

Da ich mit Eclipse arbeite, bereite ich nun den Import vor. Ich wechsle ins Projektverzeichnis und rufe das Eclipse-Plugin mit einem zusätzlichen Parametern auf, damit der Quellcode der Projekte heruntergeladen wird, die als Abhängigkeiten deklariert sind.

$ cd wicket
$ mvn eclipse:eclipse -DdownloadSources=true

Nach dem Starten von Eclipse importieren wir das Projekt über File > Import > General > Existing Projects into Workspace und dort wählen wir das Projektverzeichnis aus. Ganz so, wie im Screencast von Alastair Maw. Da das Projekt dann noch viele Fehler aufweist, gehen wir in Window > Preferences > Java > Build Path > Classpath Variables, legt dort per New eine neue Variable ein namens M2_REPO an und geben den Pfad auf das lokale Maven Repository ein, in meinem Fall wäre das C:/Users/ex-ratt/.m2/repository.

Nun gibt es in meinem Fall immer noch Fehler. Von Milestone zwei zu Milestone drei wurde die Verwendung von Generics geändert, aber scheinbar wurde der Quickstart-Archetype nicht daran angepasst. Alle Stellen, die noch als Fehler angezeigt werden, müssen also angepasst werden, indem die Typbeschreibung mit den spitzen Klammern entfernt wird. Das sind erstmal nur zwei in der Klasse HomePage, nämlich in Zeile 10 und in Zeile 25.

Um zu testen, ob das jetzt auch wirklich geht, führen wir die Klasse Start aus, die im Test-Verzeichnis zu finden ist. Sie startet eine Jetty-Instanz und über die URL http://localhost:8080/ oder http://127.0.0.1:8080/ sieht man die übliche Nachricht “If you see this message wicket is properly configured and running”. Nachdem das geklärt ist, kann es ja endlich losgehen.

Zuerst brauchen wir zwei Model-Klassen, die lediglich die Daten halten. Die eine wird die Daten einer News speichern und die andere stellt ein Spiel dar. Auf die Darstellung der Getter und Setter verzichte ich, die wird sich jeder dazudenken können, hoffe ich.

public class Game {
	private String name;
}

public class News {
	private Game game;
	private String page;
	private String url;
	private String title;
	private String description;
	private Date date;
}

Unsere Komponente nennt sich NewsList, da sie eine Liste von News darstellt, die aus verschiedenen Feeds kommt. Aus diesem Grund speichert jede News auch den Namen der Seite, von der sie kommt. Der HTML-Code unserer Komponente ist jedenfalls recht übersichtlich:




	
		
			01.01.1970
			Seite: 
			Beschreibung

Hier wird deutlich, dass die HTML-Dateien tatsächlich keinerlei Logik enthalten. Viele Template-Engines hätten an irgendeiner Stelle eine Schleife, die dafür sorgt, dass ein bestimmter Teil mehrmals wiederholt wird – nämlich so oft, wie es News gibt. Bei Wicket aber wird derartiges komplett im Java-Code gemacht. Das wicket:panel-Tag grenzt hier das Panel ein. Alles, was im inneren des Tags ist, gehört zum Panel und wird dort angezeigt, wo es eingebunden wird, alles andere fällt weg. So ist es möglich, zu Vorschauzwecken HTML-Konstrukte darum zu bauen, um zu sehen, wie die Komponente aussähe, ohne die ganze Applikation starten zu müssen. Die Texte innerhalb von Labels, wie z.B. die Beschreibung, werden im laufenden Betrieb durch den eigentlichen Inhalt ersetzt und dienen hier auch nur der Vorschau – man könnte sie also auch weglassen.

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		add(new ListView("news", news) {
			@Override
			protected void populateItem(ListItem item) {
				News news = item.getModelObject();
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));
				item.add(new Label("description", news.getDescription()));
				item.add(new Label("date", new PropertyModel(news, "date")));
			}
		});
	}
}

ListView ist genauso wie Label und ExternalLink eine Komponente, die Wicket von sich aus mitbringt. Dabei muss man immer eine ID angeben, die der im HTML-Code angegebenen wicket:id entsprechen muss. Die ListView ist dabei insofern besonders, als dass sie das entsprechende Tag mitsamt den Kindelementen wiederholt – hier taucht also die Schleife auf.

Die Methode populateItem() wird für jede News aufgerufen, die sich in der Liste befindet, die dem Konstruktor übergeben wurde. Jedem ListItem werden dann wiederum verschiedene Komponenten hinzugefügt. Wieder hat jede eine ID und außerdem wird ein Model benötigt, dass den darzustellenden Text enthält. In den meisten Fällen übergeben wir hier einfach einen String und die Komponente baut sich selber ein einfaches Model drumrum, aber im Falle des Datums machen wir das selber. So wird automatisch ein Converter aufgerufen, der das Datum so darstellt, wie es für unsere Region typisch ist. Würden wir das Datum pur angeben, würde es direkt per toString umgewandelt werden.

Weiterhin fällt der Aufruf von setRenderBodyOnly() bei dem Label, das den Namen der Seite enthält, auf. Das sorgt dafür, dass das span-Tag im HTML-Code nicht dargestellt wird, sondern nur der Name der Seite. Dazu können wir uns hinterher mal den erzeugten Quellcode ansehen.

Die Komponente sollte soweit funktionieren, jetzt müssen wir sie nur noch verwenden und mit Daten füttern. Dazu ändern wir die bereits bestehende HomePage.java an unsere Bedürfnisse an:

public class HomePage extends WebPage {

	private static final long serialVersionUID = 1L;

	/**
	 * Constructor that is invoked when page is invoked without a session.
	 *
	 * @param parameters
	 *            Page parameters
	 */
	public HomePage(final PageParameters parameters) {

		Game game = new Game("Spiel 1");
		List news = new LinkedList();
		News news1 = new News();
		news1.setGame(game);
		news1.setPage("Seite1");
		news1.setTitle("Erste News");
		news1.setUrl("http://www.asdf.com/erste-news/");
		news1.setDescription("Lorem ipsum bla");
		news1.setDate(new Date());
		news.add(news1);
		News news2 = new News();
		news2.setGame(game);
		news2.setPage("Seite1");
		news2.setTitle("Zweite News");
		news2.setUrl("http://www.asdf.com/zweite-news/");
		news2.setDescription("Lorem ipsum bla");
		news2.setDate(new Date());
		news.add(news2);

		add(new NewsList("news", news).setRenderBodyOnly(true));
	}
}

Hier basteln wir kurz ein paar Testdaten zusammen und fügen unsere NewsList einfach der Seite hinzu. Außerdem sorgen wir auch hier dafür, dass das Tag, das wir im Markup der Seite nutzen, nicht erscheint. Der zur Seite gehörende HTML-Code (HomePage.html) muss natürlich auch angepasst werden:


    
        News Feed Reader

Das wars auch schon. Für diejenigen aber, die mit Hilfe von Maven kompilieren, bleibt noch etwas zu tun, denn ein Test schlägt fehl. Dazu müssen wir in der TestHomePage.java, diese liegt im Test-Verzeichnis, die Zeile 27 auskommentieren oder löschen, denn dort wird der Inhalt eines Labels geprüft, das es in unserer Version nicht mehr gibt. Eine Einführung zum Testen gebe ich evtl. ein anderes Mal.

Würden wir jetzt unsere Anwendung starten, die Seite aufrufen und den Quelltext betrachten, so würden wir feststellen, dass dort noch die wicket:id-Attribute, sowie die -Tags enthalten wären. Während der Entwicklung ist das noch hilfreich, in einer späteren Produktivumgebung aber will man das vielleicht nicht mehr drin haben. Um das zu erreichen, konfigurieren wir es in unserer WicketApplication. Der wesentliche Code ist rot dargestellt:

public class WicketApplication extends WebApplication {

	/**
	 * Constructor
	 */
	public WicketApplication() {}

	@Override
	protected void init() {
		super.init();
		getMarkupSettings().setStripWicketTags(true);
	}

	/**
	 * @see wicket.Application#getHomePage()
	 */
	public Class getHomePage() {
		return HomePage.class;
	}

}

Nachdem wir den Server gestartet haben und nun die Seite betrachtet, sehen wir folgenden erzeugten HTML-Code:


    
        News Feed Reader
    
    

	
		
			19.09.08
			Seite1: Erste News
			Lorem ipsum bla
		

			19.09.08
			Seite1: Zweite News
			Lorem ipsum bla

Das ist nun weder besonders schick, noch handelt es sich um einen richtigen Feedreader, also ist noch etwas Arbeit vonnöten. Schauen wir uns also erstmal an, wie wir echte Newsfeeds einlesen können.

Echte Newsfeeds mit Rome

Feeds sind Daten in XML-Form, die sich aber je nach Art des Feeds (Atom oder RSS) und der Version etwas voneinander unterscheiden. Aber zum Glück gibt es dafür bereits Bibliotheken, die uns die Arbeit des Parsens abnehmen, wie das Projekt Rome. Die Version 0.9 liegt im zentralen Maven-Repository, so dass wir uns um den Download keine Gedanken machen müssen. Wir tragen einfach eine weitere Dependency in die pom.xml ein und lassen Maven den Rest erledigen.


	rome
	rome
	0.9

Nur woher weiß man, welche Projekte im Maven-Repository liegen und wie kommt man an groupId und artifactId? Entweder, diese Informationen findet man auf der Seite des Projekts (wie es bei Wicket der Fall ist) oder man sucht auf www.mvnrepository.com, so habe ich es in diesem Fall gemacht. Jetzt wechseln wir wieder per Kommandozeile in das Verzeichnis unseres Projektes, wenn wir da nicht ohnehin sind und führen mvn install aus, damit die neuen Abhängigkeiten heruntergeladen werden.

$ cd /cygdrive/c/myprojects/wicket
$ mvn install

Spätestens jetzt wird uns Maven einen Fehler um die Ohren hauen, wenn wir vorher nicht die TestHomePage.java wie oben angegeben geändert haben. Das stört aber nicht weiter, da die neuen Abhängigkeiten vor dem Ausführen der Tests heruntergeladen wurden. Die Eclipse Settings müssen nun natürlich noch auf den aktuellen Stand gebracht werden:

$ mvn eclipse:eclipse -DdownloadSources=true

Anschließend reicht ein Neu Laden des Projektes, damit die neue Bibliothek auch in Eclipse erkannt wird. Die News aus den Feeds wollen wir nun nur einmal beim Starten des Servers laden, damit der Zugriff auf eine Seite weiterhin schnell bleibt. Dafür bietet sich unsere WicketApplication Klasse an, denn diese wird nur ein einziges Mal beim Starten des Servers instanziiert. Wir fügen eine ganze Menge neues Zeug hinzu. Diesmal der Vollständigkeit halber mit allen Imports:

package net.rattlab.wicket;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import net.rattlab.model.Game;
import net.rattlab.model.News;

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

import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.FeedException;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

/**
 * Application object for your web application. If you want to run this application without deploying, run the Start class.
 *
 * @see net.rattlab.wicket.Start#main(String[])
 */
public class WicketApplication extends WebApplication {

	private List games;
	private List news;

	/**
	 * Constructor
	 */
	public WicketApplication() {
		games = new LinkedList();
		news = new LinkedList();

		createGames();
		createNews();
	}

	/**
	 * Creates the games and news feeds.
	 */
	protected void createGames() {
		Game starcraft2 = new Game("StarCraft 2");
		Game diablo3 = new Game("Diablo 3");

		starcraft2.addFeed("inStarCraft", "http://starcraft2.ingame.de/feed.php?type=RSS1.0&section=345");
		starcraft2.addFeed("StarCraft 2 Mecca", "http://forum.gamersunity.de/external.php?type=rss2&forumids=195");
		diablo3.addFeed("inDiablo", "http://diablo3.ingame.de/feed.php?type=RSS1.0");
		diablo3.addFeed("Diablo 3 Source", "http://diablo3.4players.de/rss_feed.xml");

		games.add(starcraft2);
		games.add(diablo3);
	}

	/**
	 * Creates the news from the news feeds.
	 */
	protected void createNews() {
		SyndFeedInput input = new SyndFeedInput();
		for (Game game : games) {
			Map feeds = game.getFeeds();
			for (String page : feeds.keySet()) {
				String feedUrl = feeds.get(page);
				try {
					URL url = new URL(feedUrl);
					SyndFeed feed = input.build(new XmlReader(url));
					for (Object o : feed.getEntries()) {
						// rome 0.9 does not support generics
						SyndEntry entry = (SyndEntry) o;
						news.add(new News(game, page, entry.getLink(), entry.getTitle(),
								entry.getDescription().getValue(), entry.getPublishedDate()));
					}
				}
				catch (MalformedURLException exc) {}
				catch (IllegalArgumentException e) {}
				catch (FeedException e) {}
				catch (IOException e) {}
			}
		}
		// sort news by date in descending order
		Collections.sort(news, new Comparator() {
			public int compare(News news, News otherNews) {
				if (null == news.getDate() && null == otherNews.getDate()) {
					return 0;
				}
				if (null == news.getDate()) {
					return 1;
				}
				if (null == otherNews.getDate()) {
					return -1;
				}
				return -1 * news.getDate().compareTo(otherNews.getDate());
			}
		});
	}

	@Override
	protected void init() {
		super.init();
		getMarkupSettings().setStripWicketTags(true);
	}

	public static WicketApplication get() {
		return (WicketApplication) Application.get();
	}

	/**
	 * @see org.apache.wicket.Application#getHomePage()
	 */
	public Class getHomePage() {
		return HomePage.class;
	}

	public List getNews() {
		return news;
	}

}

Neu sind zuerst einmal die zwei Listen. Eine davon speichert die Spiele, die andere die noch zu generierenden News. Im Konstruktor erzeugen wir die Spiele und fügen jedem beispielhaft zwei Newsfeeds hinzu mit dem Namen der Seite, von der sie kommen. Anschließend werden die News aus den Feeds geholt. Zuviel will ich dazu nicht erklären – wer mehr wissen will, kann sich die Rome Tutorials anschauen. Dass ich die Exceptions einfach ignoriere, ist nicht besonders vorbildlich, aber darum soll es hier nicht primär gehen.

Schließlich wird die Liste mit den News noch sortiert, so dass die aktuellsten Nachrichten ganz oben stehen. Da es nicht garantiert ist, dass die Daten nicht null sind, muss hier diese doch recht hässliche Abfrage erfolgen.

Schließlich gibt es noch zwei weitere neue Methoden. Die eine davon gibt einfach nur die Liste der News zurück, die andere das WicketApplication-Objekt selber. Das brauchen wir, um von unserer Komponente aus auf die News zugreifen zu können.

Wie zu sehen ist, hat auch Game ein paar neue Methoden spendiert bekommen, addFeed() und getFeeds. Hier also die überarbeitete Klasse, diesmal mit Getter und Setter:

public class Game {

	private String name;
	private Map feeds;

	public Game(String name) {
		setName(name);
		feeds = new HashMap();
	}

	public void addFeed(String page, String url) {
		feeds.put(page, url);
	}

	public Map getFeeds() {
		return feeds;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

Nachdem insbesondere in der WicketApplication so viel neuer Code hinzugekommen ist, wurde er bei HomePage weniger, denn dort haben wir vorher unsere Daten erzeugt. Der Konstruktor ist jetzt auf eine Zeile geschrumpft, sonst hat sich nichts geändert:

public class HomePage extends WebPage {

	private static final long serialVersionUID = 1L;

	/**
	 * Constructor that is invoked when page is invoked without a session.
	 *
	 * @param parameters
	 *            Page parameters
	 */
	public HomePage(final PageParameters parameters) {
	    add(new NewsList("news", WicketApplication.get().getNews()).setRenderBodyOnly(true));
	}
}

Jetzt haben wir “echte” Daten und können das gleich nochmal ausprobieren. Die Liste der News ist jetzt recht lang, sie ist unübersichtlich und hässlich, aber hey, daran kann man ja noch arbeiten.

Das Styling

Auch wenn man sich das eigentlich für den Schluss aufheben könnte, so finde ich es doch wesentlich angenehmer, wenn man mit etwas halbwegs ansehnlichem arbeiten kann. Deswegen habe ich ein paar Zeilen CSS-Code geschrieben und diesen ins selbe Package gelegt, in dem auch schon NewsList.java und NewsList.html liegen. Hier ist also die newslist.css, die ich nicht näher ausführen werde, da ich nicht zu sehr abschweifen will, aber kompliziert ist es ohnehin nicht:

ul.newslist {
	margin: 0;
	padding: 0;
	list-style: none;
	max-width: 800px;
	font-family: Arial, sans-serif;
	font-size: 13px;
}

ul.newslist > li {
	margin: 10px 0;
	padding: 5px;
	border: 1px solid #999;
	background-color: #ccc;
	color: #000;
}

ul.newslist li.starcraft-2 {
	border-color: #69f;
	background-color: #adf;
}

ul.newslist li.diablo-3 {
	border-color: #c63;
	background-color: #fab;
}

ul.newslist li span.date {
	float: right;
}

ul.newslist li div.description {
	margin: 5px -5px -5px;
	padding: 0 5px;
	border-top: 1px solid #999;
}

ul.newslist li div.description p {
	margin: 5px 0;
}

ul.newslist li.starcraft-2 div.description {
	border-color: #69f;
}

ul.newslist li.diablo-3 div.description {
	border-color: #c63;
}

ul.newslist li a {
	color: #666;
	text-decoration: none;
	font-weight: bold;
}

ul.newslist li a:hover {
	text-decoration: underline;
}

Damit diese Styles auch angewendet werden, müssen wir zweierlei Dinge tun. Zum einen müssen wir unseren Tags die CSS-Klassen zuweisen, das machen wir natürlich direkt im Markup. Außerdem muss die CSS-Datei auch eingebunden werden. Auch das können wir direkt in der HTML-Datei der Komponente machen:




	





	class="newslist">
		
			class="date">
			: 
			class="description">

Hier kommen zwei neue Wicket-Tags zum Einsatz, und . Ersteres wird verwendet, wenn Tags in den Head der HTML-Datei sollen. Jede Komponente kann so eigene Header-Angaben einbringen. Zweiteres löst automatisch den Link auf, der zur CSS-Datei führt – das klappt z.B. auch mit a- und img-Tags und ist nicht auf den Header beschränkt. Es ist auch möglich, die CSS-Datei z.B. ins WEB-INF-Verzeichnis zu schieben und auf andere Weise einzubinden (direkt per Java), aber für uns genügt das erstmal zur Demonstration. Abgesehen davon ist es sowieso fraglich, ob es Sinn macht, Designinformationen wie Farben direkt einer Komponente zuzuordnen, da diese auf verschiedenen Seiten sehr unpassend wirken könnten.

In der CSS-Datei konnte man sehen, dass für News zu StarCraft 2 eine andere Farbe verwendet wird, als für News zu Diablo 3. Im HTML-Code unserer Komponente aber hat das li-Tag gar kein class-Attribut. Wie kommt das also da dran? Viele Varianten gibt es ja nicht – es wird im Java-Code gemacht, und zwar in unserer Komponente:

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		add(new ListView("news", news) {
			@Override
			protected void populateItem(ListItem item) {
				final News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return news.getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));
				item.add(new Label("description", news.getDescription()));
				item.add(new Label("date", new PropertyModel(news, "date")));
			}
		});
	}
}

Mit dem AttributeModifier können wir jedes erdenkliche Attribut ändern. In diesem Fall fügen wir ein class-Attribut hinzu, das true im Konstruktor sorgt dafür, dass es angelegt wird, wenn es noch nicht da ist. Wie so oft beim Einsatz von Wicket wird auch hier ein Model übergeben. Da die Eigenschaft nicht verändert wird, probieren wir mal ein Read-Only-Model aus. Darin holen wir uns den Namen des Spiels, wandeln diesen in Kleinbuchstaben um und ändern alle Leerzeichen in Bindestriche. Wenn damit zu rechnen wäre, dass noch andere Sonderzeichen, wie z.B. Doppelpunkte, in Spielenamen vorkommen, so sollte man sie auch in Bindestriche umwandeln oder ganz rausfallen lassen.

Wenn wir die Anwendung jetzt neustarten und unsere News im Browser aufrufen, so sehen sie schon wesentlich schicker aus, als vorher. Aber halt, was ist das? Scheinbar wurde der HTML-Code, der in manchen Feeds aufgetaucht ist, maskiert, so dass jetzt unschöne Tags im Text auftauchen. Außerdem reicht uns das Datum nicht mehr aus, wie wollen auch die Uhrzeit wissen.

Die Maskierung bekommen wir recht einfach weg. Dafür gibt es ein Flag vom Label, das wir setzen müssen. Bei näherer Betrachtung des Quellcodes unserer erzeugten Newsansicht fällt mir aber noch etwas anderes auf. So scheint es im Feed Zeilenumbrüche zu geben, die aber vom Browser ignoriert werden. Wenn man sich die News mal ansieht, nachdem man die Maskierung entfernt hat, sieht man das auch, denn es ist immer noch sehr unübersichtlich, da eben diese Zeilenumbrüche fehlen. Für solche Zwecke gibt es das MultiLineLabel, das einfache Zeilenumbrüche in ein und doppelte in

verwandelt. Außerdem wird der gesamte Text des Labels noch in p-Tags gefasst, so dass es am Ende auch alles passt. Wir ändern unsere Komponente also:

public class NewsList extends Panel {

	public NewsList(String id, List news) {
		super(id);

		add(new ListView("news", news) {
			@Override
			protected void populateItem(ListItem item) {
				final News news = item.getModelObject();
				item.add(new AttributeModifier("class", true, new AbstractReadOnlyModel() {
					@Override
					public String getObject() {
						return news.getGame().getName().toLowerCase().replace(' ', '-');
					}
				}));
				item.add(new ExternalLink("link", news.getUrl(), news.getTitle()).setEscapeModelStrings(false));
				item.add(new Label("page", news.getPage()).setRenderBodyOnly(true));
				item.add(new MultiLineLabel("description", news.getDescription()).setEscapeModelStrings(false));
				item.add(new DateTimeLabel("date", new PropertyModel(news, "date")));
			}
		});
	}
}

Da auch in den Titeln der News mitunter maskiertes HTML vorkommt (wie Anführungszeichen) und diese dargestellt werden sollen, haben wir auch bei den Linktexten die zusätzliche Maskierung entfernt. Außerdem benutzen wir hier ein DateTimeLabel – das es aber noch nicht gibt. Es ist aber im Nu erstellt. Um Objekte, die kein String sind, in einem Label darzustellen, wird ein Converter aufgerufen, der die Konvertierung vornimmt. Wir müssen also nur einen neuen Converter erzeugen, der die Ausgabe mit Datum und Zeit versieht.

/**
 * Label, that displays Date objects with date and time.
 *
 * @author ex-ratt
 */
public class DateTimeLabel extends Label {

	public DateTimeLabel(String id, IModel model) {
		super(id, model);
	}

	@SuppressWarnings("unchecked")
	@Override
	public  IConverter getConverter(Class type) {
		return (IConverter) new DateConverter() {
			@Override
			public DateFormat getDateFormat(Locale locale) {
				if (locale == null){
					locale = Locale.getDefault();
				}
				return DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, locale);
			}
		};
	}
}

Jetzt sehen die News schon sehr viel übersichtlicher aus. Aber hier ist Vorsicht geboten: Sollte in einer der News mal schädlicher JavaScript-Code stehen, so landet dieser jetzt auch in unserer Übersicht. Außerdem werden z.T. auch direkt Farben im Code definiert, die mitunter in unserer Seite absolut unpassend aussehen oder sich kaum lesen lassen. Zu Demonstrationszwecken ist die abgeschaltete Maskierung also tauglich, im Produktiveinsatz sollte man sich da vielleicht eine eigene Komponente schreiben, die das MultiLineLabel ersetzt – vielleicht tu ich das irgendwann einmal.

Den bisher erzeugten Quellcode könnt ihr euch herunterladen. Mit mvn install werden dann die Abhängigkeiten heruntergeladen, falls das noch nicht geschehen ist, und der Code kompiliert. Wie ihr das Projekt nach Eclipse importiert und ausführt, wurde bereits beschrieben. Für IntelliJ Idea müsst ihr mvn idea:idea ausführen, im Falle von Netbeans reicht es, nur die pom.xml zu öffnen.

Ausblick

Auch wenn unser Feedreader jetzt schon schick aussieht, so gibt es doch noch einiges an Optimierungspotential. Die Seite wird recht lang und die einzelnen Feeds sind recht unterschiedlich – so stehen in manchen nur kurze Beschreibungen, während in anderen die komplette News zu finden ist. Das kostet etwas Übersicht, wenn man nur die Links haben will, weil man die News ohnehin auf seiner Lieblingsseite lesen will. Dagegen werden wir im nächsten Teil etwas tun und dann kommt auch endlich etwas Dynamik ins Spiel. Ich freue mich schon darauf, etwas mit JavaScript und Ajax experimentieren zu können.

Den zweiten Teil gibt es jetzt: Dynamik für den Feedreader.

Cygwin

Peter — Sun, 07 Sep 2008 13:58:43 +0000

Es gibt immer wieder Momente, da denke ich, dass es ganz angenehm wäre, wenn ich unter Linux entwickeln würde und nicht unter Windows. Einer dieser Momente ist es, wenn ich mit der Kommandozeile von Windows arbeiten muss, da die Vervollständigung von Pfadnamen per Tab recht bescheiden ist, mir die Linux-Befehle etwas geläufiger sind und weil unter Windows kaum sinnvolle Tools wie Subversion oder ähnliches vorinstalliert sind. Allerdings kenne ich jetzt eine Alternative zur parallelen Linux-Installation.

Kennengelernt habe ich dieses praktische Stück Software diese Woche in meinem Praktikum. Cygwin heißt das gute Stück und es stellt eine Bash dar, die direkt unter Windows ausgeführt werden kann. Dabei emuliert Cygwin die Unix-API, was es ermöglicht, nach Windows portierte Unix-Anwendungen zu benutzen.

Um das Programm zu installieren, muss zuerst die recht kleine setup.exe heruntergeladen werden. Ein Ausführen dieser Datei startet erwartungsgemäß die Installation. In dieser wählt man dann aus, ob man direkt installieren oder die benötigten Dateien nur herunterladen will, um sie später zu installieren (recht praktisch, wenn man Cygwin auf mehreren Rechnern installieren will, die teilweise auch nicht ans Internet angeschlossen sind). Für eine einzelne Installation aber reicht es auch aus, direkt zu installieren.

Im nächsten Schritt wird abgefragt, wohin Cygwin installiert werden soll, ob es für alle Nutzer verfügbar sein soll und welches Format Textdateien haben sollen. Hier lasse ich alles auf den Voreinstellungen. Daraufhin wird das Verzeichnis erfragt, in dem die Installationsdateien hinterlegt werden sollen. Darauf kann man für spätere Installationen wieder zurückgreifen.

Zuletzt muss man noch angeben, ob eine direkte Internetverbindung besteht oder ein Proxy nötig ist, bevor man schließlich noch einen Mirror auswählt. Dabei kann es sicher nicht schaden, einen Server zu wählen, der in der Nähe ist. Wenn das geschehen ist, sieht man eine Baumansicht aus verfügbaren Modulen. Dort finden sich viele nützliche Programme, wie das anfangs erwähnte Subversion oder der Kommandozeilen-Editor vi. Dann beginnt der Download und ggf. die Installation.

Man kann seine Installation relativ einfach updaten, indem man die setup.exe ein weiteres Mal ausführt. Die bereits installierten Pakete sind dann schon angewählt und man kann weitere hinzufügen. Nach dem Start von Cygwin wird man darauf hingewiesen, wo man .bashrc und co. finden kann, nämlich unterhalb von /home/username. Die drei nach dem Start genannten Dateien werden nicht vom Programm überschrieben und können, wie unter jedem Linux-System, für persönliche Einstellungen genutzt werden. Die eigenen Partitionen bzw. Festplatten findet man übrigens unter /cygdrive/laufwerksbuchstabe.

Eine Empfehlung meinerseits: Wenn ihr Cygwin geöffnet habt, dann macht mal einen Rechtsklick auf die Titelleiste und wählt “Eigenschaften” bzw. “Properties” aus. Dort könnt ihr im ersten Reiter “Options” den “Quick Edit Mode” anwählen, durch den es möglich wird, mit der Maus Bereiche zu markieren, um sie z.B. in die Zwischenablage zu kopieren. Unter dem Reiter “Layout” könnt ihr dann noch die Größe des Fensters verändern und, was möglicherweise wichtiger ist, es lässt sich die Anzahl der gespeicherten Zeilen erhöhen, falls man mal weit zurückscrollen muss. Bei mir steht der Wert auf 9999. Diese Einstellungen kann man übrigens auch auf die normale Windows-Kommandozeile anwenden.

Ein gutes Tutorial beschreibt die Installation etwas ausführlicher mit Bildern und geht anschließend auf die Konfiguration von X Windows ein. So ist es möglich, Unix-Programme mit GUI unter Windows auszuführen. Zu guter Letzt wird noch beschrieben, wie man sich per SSH bzw. Telnet mit einem anderen Rechner verbindet.

Abschließend möchte ich nochmal die Vorzüge von Cygwin zusammenfassen:

Eine vernünftige Kommandozeile
Unix-Kommandos
Shell-Scripte
Herunterladen von Tools über Cygwin, ohne nach Downloads suchen zu müssen
Ein wenig Linux-Flair, ohne Linux tatsächlich installieren zu müssen

Wicket-Projekt mit Maven

Peter — Fri, 29 Aug 2008 11:55:23 +0000

Es gibt einige Technologien und Frameworks aus dem Java-Umfeld, mit denen ich mich immer mal beschäftigen wollte, wozu ich aber aus Zeitgründen oder mangels Ziel, auf das ich hinarbeiten konnte, nie kam. Und da ich, bevor ich mit meine Diplomarbeit anfange, noch ein wenig Zeit habe, werde ich die Gelegenheit beim Schopfe packen und mich mit Maven, Wicket, Hibernate und anderen Dingen auseinandersetzen.

Einführung in Maven

Anfangen möchte ich erstmal mit Maven, weil alles andere mehr oder weniger darauf aufbauen wird. Zwar ist es natürlich möglich, Frameworks wie Wicket auch ohne Maven auszuprobieren, aber ich will das gleich miteinander verbinden. Am Ende dieses Artikels werden wir ein Grundgerüst für eine auf Wicket basierende Webanwendung haben.

Maven ist ein Werkzeug, das viele Prozesse vereinfacht. Es lassen sich recht einfach Abhängigkeiten zu anderen Projekten und Frameworks verwalten, es unterstützt automatisiertes Testen und vieles mehr, doch stürzen wir uns direkt ins Getümmel und probieren es aus. Ich setze hier voraus, dass ein halbwegs aktuelles JDK installiert und konfiguriert ist und außerdem Java-Kenntnisse vorhanden sind.

Auf der Maven Download-Seite finden wir die aktuellste Version, in meinem Fall ist das die 2.0.9. Das erhaltene Zip entpacken wir z.B. in das Verzeichnis für Programme, in meinem Fall wäre das C:\Program Files\Maven. Nun müssen wir noch zwei Systemvariablen setzen, zum einen M2_HOME, in der das Installationsverzeichnis eingetragen wird (bei mir wie oben erwähnt C:\Program Files\Maven) und zum anderen muss das bin-Verzeichnis von Maven noch zur PATH-Variable hinzugefügt werden (bei mir C:\Program Files\Maven\bin bzw. %M2_HOME%\bin).

Anschließend können wir die Kommandozeile aufrufen und die Version von Maven mit einem einfachen Kommando erfragen, wenn alles richtig gemacht wurde:

$ mvn -v
Maven version: 2.0.9
Java version: 1.6.0_06
OS name: "windows vista" version: "6.0" arch: "x86" Family: "windows"

Wenn das geklappt hat, kann es weitergehen, wenn nicht, dann müssen die ersten Schritte nochmal überprüft werden. Als nächstes legen wir ein neues Maven-Projekt an – das ginge sowohl per Hand, als auch per Archetype-Plugin. Wie wir noch sehen werden, ist Maven selbst eine Art Container, bei dem die Funktionalität durch viele Plugins zustande kommt. Wir wechseln per Kommandozeile in das hoffentlich bereits erstellte Verzeichnis, das unser kleines Testprojekt beinhalten soll und erstellen es:

$ cd myprojects
$ mvn archetype:create -DgroupId=net.rattlab.test -DartifactId=test -DpackageName=net.rattlab.test
[...]
[INFO] OldArchetype created in dir: C:\myproject\test
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 secons
[INFO] Finished at: Sun Aug 17 22:01:02 CEST 2008
[INFO] Final Memory: 7M/14M
[INFO] ------------------------------------------------------------------------

Mit diesem Kommando wird ein sogenanntes Goal aufgerufen, in diesem Fall “create” vom PlugIn “Archetype”. Dieses erstellt das Grundgerüst für ein neues Projekt und lädt ggf. benötigte Maven-PlugIns herunter (in diesem Fall das angesprochene Archetype-PlugIn) – darum müssen wir uns nicht selber kümmern. Die übergebenen Parameter sind im Falle von groupId und artifactId Bezeichner, um das Projekt eindeutig identifizieren zu können und ein Package-Name für die zu erzeugende Java-Klasse, die nichts weiter tut, als “Hello World” auszugeben.

Doch schauen wir uns erstmal an, was im Projekt-Verzeichnis zu finden ist. Dort gibt es neben einem Verzeichnis für die Source-Code eine Datei namens pom.xml, in der die Konfiguration des Projekts zu finden ist. Diese Datei und die Verzeichnisstruktur hätte man auch selber per Hand erstellen können – das Archetype-Plugin also nimmt uns nur etwas Arbeit ab, wirklich nötig wäre es in diesem Fall aber nicht. Doch zurück zur pom.xml:


  4.0.0
  net.rattlab.test
  test
  jar
  1.0-SNAPSHOT
  test
  http://maven.apache.org
  
    
      junit
      junit
      3.8.1
      test

Hier tauchen die als Argument übergebenen artifactId und groupId wieder auf, begleitet von einer Version – diese drei Parameter identifizieren den konkreten Stand eines Projekts. Weiterhin interessant ist der Teil, der die Abhängigkeiten (Dependencies) definiert – in diesem Falle ist standardmäßig JUnit, ein Testing-Framework, integriert. Mehr ist hier nicht nötig, da die weitere Verzeichnisstruktur dem Maven-Standard entspricht und damit nicht konfiguriert werden muss. Möchte man diese aber ändern, so sind natürlich auch mehr Zeilen in der pom.xml nötig.

Jetzt wollen wir das Projekt aber noch hübsch in ein JAR verpacken und anschließend ausführen. Dazu wechseln wir ins Projekt-Verzeichnis und führen eine nächste Anweisung aus, die diesmal aber nicht nur ein Goal enthält, sondern einen Lifecycle anstößt – dabei werden mehrere Goals ausgeführt und, falls nötig, die als Abhängigkeiten definierten JARs runtergeladen und im lokalen Repository gespeichert.

cd test
$ mvn install
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building test
[INFO]    task-segment: [install]
[INFO] ------------------------------------------------------------------------
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Compiling 1 source file to C:\myprojects\test\target\classes
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Compiling 1 source file to C:\myprojects\test\target\test-classes
[INFO] [surefire:test]
[INFO] Surefire report directory: C:\myprojects\test\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running net.rattlab.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.016 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] [jar:jar]
[INFO] Building jar: C:\myprojects\test\target\test-1.0-SNAPSHOT.jar
[INFO] [install:install]
[INFO] Installing C:\myprojects\test\target\test-1.0-SNAPSHOT.jar to
C:\Users\ex-ratt\.m2\repository\net\rattlab\test\test\1.0-SNAPSHOT\test-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sun Aug 17 22:32:15 CEST 2008
[INFO] Final Memory: 8M/16M
[INFO] ------------------------------------------------------------------------

Das Log verrät uns, dass automatisch Tests ausgeführt wurden, der Quellcode kompiliert, ein JAR erstellt und anschließend ins lokale Maven-Repository kopiert wurde – und das alles nur mit einem Befehl. Jetzt schließen wir noch einen kleinen Funktionstest an:

$ java -cp target/test-1.0-SNAPSHOT.jar net.rattlab.test.App
Hello World!

Das sollte jetzt nur als klitzekleiner Einstieg in Maven dienen, da ich nun damit arbeiten werde. Weitergehende Informationen zu diesem nützlichen Werkzeug finden sich in Sonatypes Maven: The Definitive Guide, mit dem ich selber den Einstieg vollzogen habe – meinem kleinen Beispiel sieht man das auch an, wenn man es mit dem ersten Beispiel des Buches vergleicht. Allerdings handelt es sich dabei eben auch um das typische Einstiegsbeispiel, auch auf der Webseite von Maven wird es im Guide Maven in 5 Minutes behandelt.

Ein erstes Wicket-Projekt

Jetzt erstellen wir ein weiteres kleines Projekt, das ebenfalls nur eine kleine Meldung ausgiebt, diesmal aber im Browser. Wie anfangs erwähnt wollen wir damit unsere ersten kleinen Schritte mit dem Web-Framework Wicket wagen. Auf der Webseite von Apache Wicket gibt es eine QuickStart-Anleitung, in der praktischerweise schon das Maven-Kommando steht, das wir an unsere Bedürfnisse anpassen:

$ mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=1.3.4 -DgroupId=net.rattlab -DartifactId=wickettest
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO]    task-segment: [archetype:create] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'.
[INFO] Setting property: velocimacro.messages.on => 'false'.
[INFO] Setting property: resource.loader => 'classpath'.
[INFO] Setting property: resource.manager.logwhenfound => 'false'.
[INFO] [archetype:create] [WARNING] This goal is deprecated. Please use mvn archetype:generate instead
[INFO] Defaulting package to group ID: net.rattlab
Downloading: http://repo1.maven.org/maven2/org/apache/wicket/wicket-archetype-quickstart/1.3.4/wicket-archetype-quickstart-1.3.4.jar
4/12K
7/12K
11/12K
12/12K
12K downloaded
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating OldArchetype: wicket-archetype-quickstart:1.3.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: net.rattlab
[INFO] Parameter: packageName, Value: net.rattlab
[INFO] Parameter: package, Value: net.rattlab
[INFO] Parameter: artifactId, Value: wickettest
[INFO] Parameter: basedir, Value: C:\myprojects
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] ********************* End of debug info from resources from generated POM ***********************
[INFO] OldArchetype created in dir: C:\myprojects\wickettest
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Mon Aug 18 16:32:00 CEST 2008
[INFO] Final Memory: 7M/14M
[INFO] ------------------------------------------------------------------------

Hier geben wir zusätzlich einen konkreten Archetype an, anhand dessen dann das Projekt erstellt wird. Dieser Archetype wird, genauso wie andere Projekte, ebenfalls mittels einer GroupId und einer ArtifactId identifiziert. Abseits davon, dass hier der Wicket-Archetype geladen und das Projekt erstellt wurde, fällt mir jetzt erst auf, dass archetype:create offenbar veraltet ist und stattdessen archetype:generate benutzt werden soll. Das sollte ich wohl demnächst mal ausprobieren.

Die pom.xml unseres Wicket-Testprojekts ist jetzt schon um einiges größer, als die unseres ersten Beispiels. Hinzugekommen sind jede Menge Abhängigkeiten, unter anderem natürlich zu Wicket, aber auch zu zwei Loggern und Jetty, einem Servlet-Container, den wir gleich auch noch nutzen werden.



	4.0.0
	net.rattlab
	wickettest
	war
	1.0-SNAPSHOT
	
	quickstart
	

	

	
		
			The Apache Software License, Version 2.0
			http://www.apache.org/licenses/LICENSE-2.0.txt
			repo
		
	

	
		

		
			org.apache.wicket
			wicket
			${wicket.version}
		
		

		

		
			org.slf4j
			slf4j-log4j12
			1.4.2
		
		
			log4j
			log4j
			1.2.14
		

		
		 
				 junit
				 junit
				 3.8.2
				 test
		 

		

		
			org.mortbay.jetty
			jetty
			${jetty.version}
			provided
		
		
			org.mortbay.jetty
			jetty-util
			${jetty.version}
			provided
		
		
			org.mortbay.jetty
			jetty-management
			${jetty.version}
			provided
		
	

	
		
			
				false
				src/main/resources
			
			
				false
				src/main/java
				
					**
				
				
					**/*.java
				
			
		
		
			
				false
				src/test/java
				
					**
				
				
					**/*.java
				
			
		
		
			
				org.mortbay.jetty
				maven-jetty-plugin
			
			
				org.apache.maven.plugins
				maven-eclipse-plugin
				
					true
				
			
		
	

	
		1.3.4
		6.1.4

Weiterhin fällt auf, dass die Versionen von Wicket und Jetty ausgelagert wurden. Ganz unten in der Datei sieht man die Abschnitt “properties” und das ist in diesem Fall deswegen nützlich, weil die gleichen Versionsnummern mehrmals gebraucht werden. Außerdem werden noch weitere Dinge konfiguriert, auf die ich aktuell nicht eingehen möchte – Einzelheiten zur pom.xml findet man im weiter oben verlinkten Buch.

Wir wollen uns jetzt mit dem aus meiner Sicht interessanterem Teil beschäftigen, nämlich der eben erstellten Wicket-Anwendung. Im Verzeichnis C:\myprojects\wickettest\src\main\net\rattlab (mag bei euch anders lauten) liegen drei Dateien, zwei Java-Dateien und eine im HTML-Format. Letztere beinhält eine einfache Webseite:


    
        Wicket Quickstart Archetype Homepage
    
    
        Wicket Quickstart Archetype Homepage
        


        message will be here

Das sieht erstmal recht normal aus, nur das Attribut wicket:id wird dem HTML-Kenner neu sein. Über dieses Attribut spricht Wicket bestimmte Elemente im Code an, wie wir in der zu dieser Seite gehörenden Java-Klasse HomePage.java sehen:

package net.rattlab;

import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.WebPage;

/**
 * Homepage
 */
public class HomePage extends WebPage {

	private static final long serialVersionUID = 1L;

	// TODO Add any page properties or variables here

    /**
	 * Constructor that is invoked when page is invoked without a session.
	 *
	 * @param parameters
	 *            Page parameters 	 */
    public HomePage(final PageParameters parameters) {

        // Add the simplest type of label
        add(new Label("message", "If you see this message wicket is properly configured and running"));

        // TODO Add your page's components here
    }
}

Dieser Webseite wird dein Label mit dem Text “If you see this message wicket is properly configured and running” zugewiesen. Dieses Label hat eine id namens “message”, die dem Wert des wicket:id Attributs im HTML-Code gleicht. Wie wir gleich im Browser sehen werden, wird der Text im span-Element durch den des Labels ersetzt.

Die letzte Datei schließlich ist die WicketApplication.java, in der die Webanwendung konfiguriert wird. In unserem einfachen Beispiel wird nur die Einstiegsseite angegeben, die aufgerufen werden soll, wenn kein spezieller Pfad in der Adresszeile angegeben wird:

package net.rattlab;

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

/**
 * Application object for your web application. If you want to run this application without deploying, run the Start class.
 *
 * @see wicket.myproject.Start#main(String[])
 */
public class WicketApplication extends WebApplication
{
    /**
     * Constructor
     */
	public WicketApplication()
	{
	}

	/**
	 * @see wicket.Application#getHomePage()
	 */
	public Class getHomePage()
	{
		return HomePage.class;
	}

}

Nun wollen wir den Kram aber auch mal ausprobieren. Dafür nutzen wir das Jetty-PlugIn, das bereits in der pom.xml konfiguriert wurde, wechseln ins Projektverzeichnis und führen es aus:

$ cd wickettest
$ mvn jetty:run
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'jetty'.
[INFO] ------------------------------------------------------------------------
[INFO] Building quickstart
[INFO]    task-segment: [jetty:run]
[INFO] ------------------------------------------------------------------------
[INFO] Preparing jetty:run
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [jetty:run]
[INFO] Configuring Jetty for project: quickstart
[INFO] Webapp source directory = C:\myprojects\wickettest\src\main\webapp
[INFO] web.xml file = C:\myprojects\wickettest\src\main\webapp\WEB-INF\web.xml
[INFO] Classes = C:\myprojects\wickettest\target\classes
[INFO] Context path = /wickettest
[INFO] Tmp directory =  determined at runtime
[INFO] Web defaults = org/mortbay/jetty/webapp/webdefault.xml
[INFO] Web overrides =  none
[INFO] Webapp directory = C:\myprojects\wickettest\src\main\webapp
[INFO] Starting jetty 6.1.12rc1 ...
INFO  - Application                - [WicketApplication] init: Wicket core library initializer
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IBehaviorListener, method=public abstract void org.apache.wicket.behavior.IBehaviorListener.onRequest()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IBehaviorListener, method=public abstract void org.apache.wicket.behavior.IBehaviorListener.onRequest()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IFormSubmitListener, method=public abstract void org.apache.wicket.markup.html.form.IFormSubmitListener.onFormSubmitted()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IFormSubmitListener, method=public abstract void org.apache.wicket.markup.html.form.IFormSubmitListener.onFormSubmitted()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=ILinkListener, method=public abstract void org.apache.wicket.markup.html.link.ILinkListener.onLinkClicked()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=ILinkListener, method=public abstract void org.apache.wicket.markup.html.link.ILinkListener.onLinkClicked()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IOnChangeListener, method=public abstract void org.apache.wicket.markup.html.form.IOnChangeListener.onSelectionChanged()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IOnChangeListener, method=public abstract void org.apache.wicket.markup.html.form.IOnChangeListener.onSelectionChanged()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IRedirectListener, method=public abstract void org.apache.wicket.IRedirectListener.onRedirect()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IRedirectListener, method=public abstract void org.apache.wicket.IRedirectListener.onRedirect()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IResourceListener, method=public abstract void org.apache.wicket.IResourceListener.onResourceRequested()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IResourceListener, method=public abstract void org.apache.wicket.IResourceListener.onResourceRequested()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IActivePageBehaviorListener, method=public abstract void org.apache.wicket.behavior.IBehaviorListener.onRequest()]
INFO  - RequestListenerInterface   - registered listener interface [RequestListenerInterface name=IActivePageBehaviorListener, method=public abstract void org.apache.wicket.behavior.IBehaviorListener.onRequest()]
INFO  - WebApplication             - [WicketApplication] Started Wicket version 1.3.4 in development mode
[INFO] Started Jetty Server

Die hier gezeigt Ausgabe wird vermutlich nicht alles sein, da Wicket in unserem Fall die Konsole gleichzeitig für das eigene Log nutzt und unter anderem davor warnt, dass es im Entwicklungs-Modus läuft. Jetzt können wir jedenfalls einen Browser unserer Wahl aufrufen und in die Adressezeile http://localhost:8080/wickettest/ eingeben und wenn alles funktioniert hat, dann erscheint dort jetzt die einfache Seite mit dem Label-Text. Um den Server zu beenden, drücken wir im Eingabefenster STRG+C, dann fährt er sich herunter.

Der Vollständigkeit halber wollen wir uns kurz noch die web.xml ansehen. In dieser Datei wird dem Servlet-Container, in unserem Fall Jetty, mitgeteilt, bei welchem Pfad welches Servlet aufzurufen ist. Ein Servlet ist die ursprüngliche Art und Weise, mit Java eine Webanwendung zu schreiben und darauf basieren auch alle Web-Frameworks, in Berührung damit kommen wir aber kaum. So also sieht die c:\myprojects\wickettest\src\main\webapp\WEB-INF\web.xml (mein lokaler Pfad) aus:




	wickettest

	 

	
		wicket.wickettest
 		org.apache.wicket.protocol.http.WicketFilter
		
			applicationClassName
			net.rattlab.WicketApplication
 		
 	

 
  wicket.wickettest
	/*

Ganz unten sehen wir das filter-mapping, dort werden URLs anhand eines Musters (englisch Pattern) einem bestimmten Servlet zugewiesen, das unter filter konfiguriert wird. Jetzt haben wir also ein Grundgerüst, mit dem wir Wicket nach Belieben ausprobieren können.

Ergänzende Informationen

Es gibt einen Wicket Quickstart Screencast von Alastair Maw, in dem nochmal die wesentlichen Dinge gezeigt werden, die auch in diesem Artikel stehen. Außerdem zeigt er, wie man das Projekt nach Eclipse importiert, um anschließend daran zu arbeiten.

Wer sich mehr Details zum Grundkonzept von Wicket wünscht, der kann sich mal das Probekapitel 1 vom Buch Wicket in Action herunterladen. Das Buch ist fast erschienen (befindet sich im Druck, als eBook ist es bereits erhältlich) und wurde von zwei Wicket-Entwicklern geschrieben. Neben Kapitel 1 und 8 findet man dort auch ein Bonuskapitel 15, in dem erklärt wird, wie man sein Wicket-Projekt aufsetzen kann. Dabei wird unter anderem auch auf Ant und Maven eingegangen und da es von Hand entwickelt wird, findet man dort auch mehr Erklärungen zu den Elementen der pom.xml und web.xml, als hier bei mir. Lesen lohnt sich also.

Ein weiteres Buch ist “Enjoying Web Development with Wicket”, von dem man sich die ersten drei Kapitel herunterladen kann. Abgesehen davon findet man auf der Seite von Apache Wicket und auf wicket-library.com noch weitere Beispiele und Dokumentationen.

Ich werde meinen Eindruck von Wicket demnächst jedenfalls noch vertiefen und eine erste kleine Beispielanwendung schreiben, die ich hier in Form eines Tutorials veröffentlichen werde.