Eclipse Helios, WTP, JSF und Maven

Dieser Artikel beschreibt, wie mit Eclipse Helios, der Web Tools Platform und Maven eine JavaServer Faces 2.0 Web-Applikation erstellt werden kann.

Voraussetzungen

Info 2011-05-21: m2eclipse 0.12 und Eclipse Helios arbeiten nicht so wirklich zusammen. Es gibt Probleme beim Download der Repository-Indizes. Deswegen sollte ein Milestone-Release von m2eclipse 0.13 von der Eclipse-Homepage (http://www.eclipse.org/m2e/) verwendet werden!

Die Eclipse JEE Edition bringt die Web Tools Platform mit. Diese Plugins unterstützen die Entwicklung von JavaEE  Anwendungen. Für Web Applikation gibt es verschiedene Konfigurationen, die unterschiedliche Features “freischalten”. Bei Verwendung der JavaServer Faces Konfiguration gibt es z.B. einen speziellen Editor, mit dem die XML-Datei der JSF-Konfiguration bearbeitet werden kann. Außerdem können verschiedene Target Runtimes angelegt werden. Dadurch werden automatisch die Bibliotheken dieser Laufzeitumgebung im Classpath des Projektes aufgenommen.

Projekt anlegen

In Eclipse wird in der Java EE Perspektive ein neues “Dynamic Web Project” mit den folgenden Einstellungen angelegt.

Seite 1 (Dynamic Web Project): Auf der ersten Seite werden die grundlegenden Einstellungen vorgenommen. Neben Name und Speicherort wird hier eingestellt, für welche Zielumgebung die Web Applikation entwickelt wird. Die Version des Web Modul bestimmt, welche JEE Spezifikationen verwendet werden können. Die Konfiguration bestimmt, welche Features zusätzlich aktiviert werden. Als letztes kann noch angegeben werden, ob das Projekt Teil einer Enterprise Application (EAR) werden soll.

  • Target runtime: Apache Tomcat v7.0
  • Dynamic web module version: 3.0
  • Configuration: JavaServer Faces v2.0 Project

Für dieses Projekt verwenden wir eine aktuelle Version von Tomcat 7, Version 3.0 des Web Module, da erst diese Version JSF 2.0 unterstützt.

Seite 2 (Java): Im zweiten Schritt werden die Verzeichnisse für die Java-Sourcen und die kompilierten Klassen festgelegt.

  • Source folders on build path: src entfernen, src/main/java anlegen
  • Default output folder: target/classes eintragen

Da wir Maven verwenden wollen, werden die Verzeichnisse entsprechend dem offiziellen Standard-Layout angepasst.

Seite 3 (Web Module): Die Daten für die Web Applikation werden auf Seite drei eingegeben. Der Context root wird beim Ausführen in Eclipse verwendet. Im Content directory liegen alle Dateien der Website (Seiten, Bilder, CSS, usw.) und die Konfigurationsdateien, z.B. die web.xml. Diese kann auch gleich mit den benötigten Einträgen erstellt werden.

  • Content directory: src/main/webapp
  • Generate web.xml deployment descriptor: aktivieren

Für unser Projekt passen wir das Verzeichnis ebenfalls dem Maven Standard an und lassen den Deployment Descriptor gleich mit den Einträgen für JSF erstellen. Angepasst wird er später.

Seite 4 (JSF Capabilities): Zum Schluss werden die benötigen Angaben zu den JavaServer Faces abgefragt. Mit der JSF Implementation Library wird WTP mitgeteilt, wo die JSF-jars liegen. Außerdem wird die JSF-Konfiguration festgelegt.

  • Type: Disable Library Configuration
  • URL Mapping Patterns: /faces/* entfernen, *.xhtml hinzufügen

Da wir Maven verwenden, deaktivieren wir die JSF-Bibliotheken. Diese kommen später als Dependencies hinzu. Da wir Facelets verwenden werden, stellen wir das Mapping um. Das ist aber nicht zwingend nötig und könnte auch unverändert übernommen werden.

Maven aktivieren

Das m2eclipse-Plugin übernimmt die Verwaltung des Classpath’ in Eclipse. Alle Dependencies werden automatisch aufgenommen, sobald die pom.xml geändert wird. Außerdem bringt es noch eine Erweiterung für WTP mit, so dass im Projekt-Explorer ein zusätzlicher Eintrag im Baum (“Web Resources” ) erscheint.

Rechtsklick auf das Projekt und Maven/Enable Dependency Management auswählen

Seite 1 (Maven2 POM): Auf der ersten Seite werden die allgemeinen Mavendaten des Projekts erfasst. Group Id und Artifact Id dienen der eindeutigen Identifizierung des Produkts. Versionsnummern mit “-SNAPSHOT” kennzeichnen Projekte in der Entwicklung. Beim Deploy in ein MAven Repository wird die Endung durch den aktuellen Timestamp ersetzt. Packaging gibt an, wie das Produkt verpackt werden soll (jar, war, …). Name und Description liefern den Anwendern nährere Infos zum Produkt.

  • Group Id anpassen (net.bohni.sample)
  • Artifact Id anpassen (sample-war)
  • Packaging: war

Für unser Beispiel passen wir Group und Artifact Id an und setzten Packaging auf “war”, da wir eine Web Applikation erstellen werden.

Seite 2 (Select additional dependencies): Die Abhängigkeiten werden auf der zweite Seite erfasst.

  • org.slf4j slf4j-api 1.6.1
  • ch.qos.logback logback-classic 0.9.26

Da die aktuellen JSF Bibliotheken nicht im offiziellen Maven Repository sind, können wir an dieser Stelle die jars noch nicht hinzufügen. Dazu erweitern wir später den POM um das passende Repository von java.net. An dieser Stelle fügen wir die Bibliotheken fürs logging hinzu.

Projekt konfgurieren

Durch das Aktivieren von Maven gibt es nun Fehler im Projekt. Zum einen wird eine falsche JRE System Library im build Path gesetzt, zum anderen müssen die Maven Dependencies aufgenommen werden, damit diese später auch in WEB-INF/lib landen. Um diese Fehler zu beheben werden die Properties des Projekts geöffnet und folgende Einstellungen geändert:

  • Java Build Path: Libraries: JRE System Library […] ->JRE System Library [JavaSE-1.6]
  • Deployment Assembly: Hinzufügen von Java Build Path Entries/Maven Dependencies

Maven verwendet standardmäßig Java 1.4, deswegen muss noch das Compiler-Plugin konfiguriert werden, das geschieht in der Datei pom.xml. Es ist folgender Abschnitt einzufügen:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.3.2</version>
      <configuration>
        <source>1.6</source>
        <target>1.6</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Anschließend muss das java.net Maven2 Repository im pom.xml aufgenommen werden, damit die aktuelle JavaServer Faces Version als Dependency aufgenommen werden kann. Entweder mit dem POM-Editor ein neues Repository anlegen, oder im Source die folgenden Zeilen einfügen:

<repositories>
  <repository>
    <id>maven2-repository.dev.java.net</id>
    <name>Java.net Repository for Maven</name>
    <url>http://download.java.net/maven/2/</url>
    <layout>default</layout>
  </repository>
</repositories>

Nun können die aktuellen JSF-Bibliotheken als Dependencies hinzugefügt werden (im POM-Editor oder über Rechtsklick auf Projekt/Maven/Add Dependency:

  • javax.facers jsf-api 2.0
  • com.sun.faces jsf-impl 2.0.3

Webapplikation erstellen

Unsere Wep Applikation wird eine einfache Hello World Anwendung. Es gibt eine Seite, auf der ein String angezeigt wird, welcher aus einer ManagedBean kommt.

Managed Bean

Dazu erzeugen wir die ManagedBean, indem wir mit dem Faces-Config-Editor die Bean in der faces-config.xml eintragen (da der auszugebende String nur auf der einen Seite zur Anzeige benötigt wird, gibt es eine Bean mit dem Scope request):

Seite 1 (Java Class Selection): Hier kann gewählt werden, ob die ManagedBean eine bestehende oder eine neue Klasse ist.

  • Create a new Java class

Wir haben noch keine Klasse, also legen wir eine neue an.

Seite 2 (Java Class): Hier wird mit dem Standarddialog aus Eclipse die Klasse angelegt.

  • Package angeben (net.bohni.sample.beans)
  • Name angeben (MyBean)

Wir benötigen eine ganz normale public POJO-Klasse. Also passen wir nur package und Name an. Supperclass und Interfaces werden nicht benötigt.

Seite 3 (Managed Bean Configuration): Auf der vorletzten Seite wird der Name und der Scope, sowie eine Beschreibung angegeben.

  • Name angeben (myBean)
  • Scope auswählen (request)

Für unser Beispiel übernehmen wir die vorgeschlagenen Werte.

Seite 4 (Wizard Summarys): Die letzte Seite zeigt noch einmal die Angaben. Mit Klick auf Finish wird der Klassenrumpf erzeugt.

Anschließend programmieren wir die benötigte Methode, die den String liefert.

package net.bohni.sample.bean;

public class MyBean
{
  public String getName()
  {
    return "Hello world";
  }
}

HTML-Seite

Neue HTML-Datei /src/main/webapp/index.xhtml erstellen

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <title>Homepage</title>
</head>
<body>
  <h1>Homepage</h1>
  <p>Hier geht es los...</p>
  <p>#{myBean.name}</p>
</body>
</html>

Deployment Descriptor web.xml

Zum Schluss passen wir noch die welcome-file-list im Deployment Descriptor src/main/webapp/WEB-INF/web.xml an:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>sample-war</display-name>
  <welcome-file-list>
    <welcome-file>index.xhtml</welcome-file>
  </welcome-file-list>
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
</web-app>
This entry was posted in Eclipse, JavaServer Faces, Maven, Software and tagged , , . Bookmark the permalink.

One Response to Eclipse Helios, WTP, JSF und Maven

  1. Stefan Bohn says:

    Hab den Artikel etwas überarbeitet. Mit ein paar zusätzlichen Infos zu den Einstellungen

Comments are closed.