Im letzten Artikel haben wir ein initiales Setup einer Wicket-Applikation für die Google App Engine vorgenommen. Die Applikation ist nach wie vor hier erreichbar.
In diesem Artikel wollen wir die Applikation springifizieren, d.h. wir wollen das Springframework integrieren.
Zunächst definieren wir folgende pom im Unterverzeichnis „dependencies/spring“.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.effective</groupId>
<artifactId>spring-dependencies</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<name>spring-dependencies</name>
<description>spring dependencies</description>
<properties>
<spring.version>3.1.1.RELEASE</spring.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
</project>
Spring definiert mittlerweile sehr viele Projekte, diese pom kann einfach importiert werden und theoretisch auch in anderen Projekten importiert werden.
Folgendes Fragment importiert die Spring-Abhängigkeiten (definiert in der ui-pom).
<dependency>
<groupId>de.effective</groupId>
<artifactId>spring-dependencies</artifactId>
<version>1.0-SNAPSHOT</version>
<type>pom</type>
</dependency>
Wichtig ist hier das <type>pom</type>-Tag, denn hierdurch werden die in der spring-pom definierten Abhängigkeiten so aufgelöst als wären sie hier direkt in der pom definiert.
Zusätzlich deklarieren wir das Spring-Dependencies-pom im Application-Reactor-Pom:
<modules>
<!--adding-->
<module>wicketstuff/jdk-1.6-parent/gae-initializer-parent/gae-initializer</module>
<module>dependencies/spring</module>
<module>ui</module>
</modules>
Um zu testen, ob die Spring-Integration funktioniert wollen wir jetzt einfach die Erzeugung der Wicket-Application-Instanz über Spring steuern.
Hierfür müssen wir die web.xml des Projektes anpassen. In dieser ist aktuell folgendes definiert.
<filter>
<filter-name>wicket.effectivetrainings.de</filter-name>
<filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
<init-param>
<param-name>applicationClassName</param-name>
<param-value>de.effective.EffectiveApplication</param-value>
</init-param>
</filter>
Das muss abgeändert werden in:
<filter>
<filter-name>wicket.effectivetrainings.de</filter-name>
<filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
<init-param>
<param-name>applicationFactoryClassName</param-name>
<param-value>org.apache.wicket.spring.SpringWebApplicationFactory</param-value>
</init-param>
</filter>
Wir registrieren also nicht die Applikation selbst, sondern eine Factory, die die Applikation über Spring auflöst. (Das ist eigentlich der Standardweg um damit zu arbeiten).
Zusätzlich müssen wir sicherstellen, dass der spring-context beim Starten der Applikation geladen wird.
Das kann auch in der web.xml passieren und zwar über den Standardmechnismus eines ContextLoaderListeners.
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
Damit Spring weiß, wo es seinen Kontext findet, muss noch folgender Parameter definiert werden.
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-context.xml</param-value>
</context-param>
Als nächstes definieren wir uns einen sehr einfachen Spring-Context:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<context:component-scan base-package="de.effective"/>
</beans>
Spring sucht im Package de.effective und allen Unterverzeichnissen nach Annotierten Spring-Beans.
Zuletzt definieren wir unsere Wicket-Applikation als SpringBean.
@Component
public class EffectiveApplication extends WebApplication
{
...
}
Wir deployen die Applikation und greifen darauf zu.
Das Projekt ist weiterhin auf github gehostet. Der Commit der diese Anforderung implementiert ist hier zu finden. Das Projekt als Zip gibt es hier.
https://github.com/dilgerma/effectivetrainings/commit/3dc99d3c88cf343cfbfbcf5ad7b88069c036d4ad
Softwareentwicklung und Agiles Arbeiten 