Webentwicklung mit Spring 3, Maven und Eclipse

Posted by Jesco Freund at Aug. 27, 2010 4:24 p.m.

Derzeit befasse ich mich (mal wieder) mit Java, genauer mit der Entwicklung einer Webanwendung in Java (und keine Sorge, ich bin nicht auf einmal durchgedreht – ich mache das eigentlich nur, um meine negative Grundhaltung gegenüber Java ab und an zu bestätigen ). Zum Einsatz kommt dabei Spring – genauer gesagt das Spring Web MVC framework. Und wie es sich bei einem richtigen™ Java-Projekt gehört, erfolgt die Entwicklung mit Eclipse.

Nun ist es aber leider so, dass ausgerechnet für die aktuelle Eclipse-Version (3.6 „Helios“) die automagischen Tools von SpringSource noch immer nicht verfügbar sind (mal abgesehen davon, dass man mittlerweile ohne Registrierung nicht mehr an die Downloads rankommt). Hinzu kommt, dass mit Spring schnell mal ein paar größere Abhängigkeitsbäume entstehen – nervig, wenn man da beim Deployment auf dem Servlet Container immer drauf aufpassen muss (ich verwende Tomcat).

Zum Glück gibt es da ein kleines Helferlein, das trotzdem die komfortable Arbeit mit Spring und Eclipse ermöglicht und nebenbei über alle Abhängigkeiten wacht, so dass die erzeugten .war-Dateien hinterher schmerzfrei deployed werden können. Die Rede ist von Maven. Leider gibt es für Maven (noch) keinen ArcheType für ein Spring 3.0 Projekt – mit ein bisschen Handarbeit hat man sich aber schnell ein funktionierendes Grundgerüst zusammengezimmert. Wie das genau vonstatten geht, wird in diesem Artikel beschrieben.

Zunächst muss natürlich die benötigte Software her. Ich verwende Eclipse und Maven aus dem Paket-Repository meiner Linux-Distribution. Tomcat habe ich jedoch von Hand installiert, da es noch keine Pakete für die aktuelle Version 7 gibt.

Um Eclipse sinnvoll nutzen zu können, benötigt man noch einige Plugins:

• m2eclipse – integriert Maven-Unterstützung in Eclipse
• Eclipse Web Tools (wst und jst)
• JBoss Tools (optional)

Alles vorhanden? Dann kann's ja jetzt losgehen. Zunächst wird ein neues Maven-Projekt erzeugt:

Im nächsten Dialog kann der Haken bei „Create a simple project (skip archetype selection)“ ruhig gesetzt werden – wir benötigen ohnehin nur das leere Skelett für den weiteren Verlauf. Im darauf folgenden Dialog des Assistenten muss man allerdings darauf achten, dass unter „Packaging“ war ausgewählt ist:

Geschafft! Damit ist erst mal der Rumpf eines Maven-Projekts erzeugt.

Nur leider erzeugt m2eclipse derzeit noch Projekte für J2SE-1.4. Für die Entwicklung mit Spring 3 sollte man aber auf die aktuelle Version 1.6 Umstellen. Dazu im Package Explorer auf das eben erzeuge Projekt rechtsklicken und „Properties“ aus dem Kontext-Menü wählen. Links in der Liste der Eigenschaften den Punkt „Java Build Path“ auswählen und auf der rechten Seite dann zum Reiter „Libraries“ wechseln. Dort den Eintrag „JRE System Library [J2SE-1.4]“ auswählen und auf „Edit“ klicken. Im nun erscheinenden Dialog kann man die aktuelle Version 1.6 auswählen („JavaSE-1.6“).

Hinweis: Manchmal benimmt sich Eclipse etwas merkwürdig, wenn man die Java-Version umstellt. In drei von vier Fällen geht alles glatt, aber es kann passieren, dass Eclipse das Projekt einfach schließt – ob die Version dann umgestellt ist, scheint vom Zufall abzuhängen. Zur Not die Prozedur einfach wiederholen; spätestens beim zweiten Anlauf hat es bei mir bisher immer geklappt.

Maven erzeugt fast die komplette Ordnerstruktur, die für eine Webanwendung benötigt werden – aber eben nur fast. Zwei Ordner müssen von Hand angelegt werden, und zwar src/main/webapp/WEB-INF sowie src/main/webapp/WEB-INF/jsp. Ist das erledigt, sollte das Projekt folgende Struktur aufweisen:

Nun gilt es, die Abhängigkeiten für den Einsatz von Spring in das Projekt einzufügen. Hier kommt uns Maven zur Hilfe. Mit einem Doppelklick auf pom.xml wird die Datei im Maven POM Editor geöffnet. Wechseln Sie zum Reiter „Dependencies“ und fügen sie die Abhängigkeiten ein:

Als nächstes benötigt das Projekt natürlich einen Web Deskriptor. Dieser gehört in das Verzeichnis src/main/webapp/WEB-INF. Sind die JBoss Tools installiert, können Sie den Deskriptor über File → New → Other… → JBoss Tools Web → Web Descriptor erzeugen. Geben Sie dem Deskriptor den Namen web. Mit dem JBoss Tools XML Editor lässt sich die Datei recht flott bearbeiten:

Die Datei soll dabei folgenden Inhalt bekommen:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name>helloworld</display-name>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>/src/main/webapp/redirect.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Drei weitere XML-Dateien müssen im Ordner src/main/webapp/WEB-INF noch angelegt werden. Zunächst einmal applicationContext.xml:

<?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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <!-- ADD PERSISTENCE SUPPORT HERE (jpa, hibernate, etc) -->

</beans>

Als nächstes dispatcher-servlet.xml:

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean
        class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping" />

    <!-- Most controllers will use the ControllerClassNameHandlerMapping above,
         but for the index controller we are using ParameterizableViewController,
         so we must define an explicit mapping for it. -->
    <bean id="urlMapping"
        class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="index.html">indexController</prop>
            </props>
        </property>
    </bean>

    <bean id="viewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver"
        p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />

    <!-- The index controller. -->
    <bean name="indexController"
        class="org.springframework.web.servlet.mvc.ParameterizableViewController"
        p:viewName="index" />

</beans>

Und zu guter letzt beans.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
</beans>

Nun fehlen nur noch zwei JSP-Dateien. Zunächst src/main/webapp/redirect.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<% response.sendRedirect("index.html"); %>

Etwas umfangreicher darf dann src/main/webapp/WEB-INF/jsp/index.jsp ausfallen:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Hello Spring World</title>
</head>
<body>
    <h1>Hello World!</h1>
    <p>This is powered by Spring.</p>
</body>
</html>

Nachdem nun alle notwendigen Dateien angelegt wurden, kann das Projekt übersetzt und packetiert werden. Hierzu im Package Explorer auf das Projekt rechtsklicken und Run as → Maven package auswählen. Im targets Verzeichnis müsste sich danach eine .war-Datei befinden. Diese kann nun auf einem entsprechenden Servlet Container wie z. B. Tomcat deployed werden. Zum Vergleich hier noch mal der vollständige Verzeichnisbaum des Projekts:

Das gesamte Hello World Projekt habe ich übrigens auch als Archiv zum Download bereit gestellt: sme_helloworld.tar.bz2. Einfach entpacken und in Eclipse importieren. Viel Spaß beim Experimentieren!

No comments | Defined tags for this entry: development, Eclipse, Java, Maven, MVC, Spring

Comments

No comments