Wenn man Webanwendungen entwickelt muss man immer beachten das Serverseitige Fehler dem Benutzer der Anwendung verständlich dargestellt werden. Die Applikationsserver bzw. Webcontainer stellen eine Exception für Entwickler lesbar dar, jedoch die Anwender können in der Regel mit den Informationen nichts anfangen.
Und genau darum soll es sich in diesem Beitrag handeln, wir wollen verschiedene Exceptions generieren und jeweils mit bestimmten Seiten darstellen. Für dieses Tutorial verwende ich Oracle Java JDK 8, Eclipse Oxygen und Apache Tomcat 7. Wenn du die Pakete heruntergeladen und installiert bzw. entpackt hast können wir loslegen.
Inhaltsverzeichnis
- Apache Tomcat in Eclipse einrichten
- Ablegen der JSF Ressourcen in Tomcat
- Erstellen eines „Dynamischen WebProjektes“ in Eclipse
- Erstellen der Startseite
- Erstellen der Bean für die Exceptions
- Ausblick
Apache Tomcat in Eclipse einrichten
Damit wir unser späteres Projekt im Apache Tomcat deployen können, müssen wir diesen Webcontainer in Eclipse als ServerRuntime einbinden. Dieses machen wir, indem wir in dem Reiter „Server“ auf den Hyperlink „No servers are available. Click this link to create a new server…“ klicken.
Es wird nun ein Wizard gestartet welcher einen durch die Einrichtung eines Servers leitet. Zunächst einmal wählen wir aus dem Baum den Eintrag „Tomcat v7.0 Server“ (1) aus (ggf. muss der Knoten „Apache“ geöffnet werden) und bestätigen die Auswahl mit der Schaltfläche „Next >“ (2).
Im nächsten Schritt wählen wir den Pfad von der Festplatte aus (1) (alternativ könnte man auch eine Version aus dem Internet laden „Download and Install…“) und wählt eine Java Runtime Environment (2) aus. Auch diese Auswahl bestätigen wir mit der Schaltfläche „Next >“.
im letzten Schritt könnten wir nun ein bereits bestehendes Projekt dem Apache Tomcat zuweisen und starten, da wir dieses erst erstellen wollen bestätigen wir dieses Fenster mit der Schaltfläche „Finish“.
Ablegen der JSF Ressourcen in Tomcat
Damit wir das spätere JSF2.2 Projekt in Apache Tomcat 7 ausführen können, müssen wir die Bibliotheken zu JavaServerFaces 2.2 herunterladen.
- https://repo1.maven.org/maven2/com/sun/faces/jsf-api/2.2.18/jsf-api-2.2.18.jar
- https://repo1.maven.org/maven2/com/sun/faces/jsf-impl/2.2.18/jsf-impl-2.2.18.jar
Diese beiden Dateien müssen nun nach „\apache-tomcat-7.0.90\lib“ kopiert werden.
Erstellen eines „Dynamischen WebProjektes“ in Eclipse
Für unsere spätere kleine Webanwendung erstellen wir uns nun ein neues „Dynamisches Webprojekt“, dazu navigieren wir über das Hauptmenü „File“ > „Project…“. Im nun geöffneten Fenster wählen wir den Knoten „Web“ (1) aus und dort den ersten Eintrag „Dynamic Web Project“ (2), diese Auswahl bestätigen wir mit der Schaltfläche „Next >“ (3).
Im nächsten Schritt wird ein Name für das Projekt vergeben (1) sowie die „Configuration“ auf „JavaServer Faces v2.2 Project“ gesetzt (2). Es ist darauf zu achten das der Haken bei „EAR membership“ entfernt wird. (Für dieses einfache Projekt wäre ein EAR Projekt deutlich zu viel und unser Tomcat kann damit sowieso nichts anfangen).
Damit wir die JSF Resourcen aus dem Apache Tomcat verwenden können, müssen wir diese in den Einstellungen zu JavaServerFaces setzen, dazu klicken wir auf die Schaltfläche „Modify…“ (3) und wählen im neuen Dialog den Eintrag „JavaServer Faces“ (1) aus, rechts im Fensterbereich finden wir den Reiter „Runtimes“ hier sollten wir unseren zuvor eingerichteten „Apache Tomcat v7.0“ finden, welchen wir mit einem Haken markieren (2). Diese Einstellung speichern wir mit der Schaltfläche „OK“.
Und kehren nun auf den vorherigen Dialog zurück, welchen wir nun mit der Schaltfläche „Finish“ schließen können.
Es sollte nun folgende Projektstruktur existieren.
Erstellen der Startseite
Nachdem das Projekt eingerichtet ist, können wir nun die Startseite mit zwei Schaltflächen erstellen von welcher wir jeweils eine Exception „werfen“.
Zunächst einmal müssen wir die Datei „web.xml“ um den Tag „welcome-file-list“ wie folgt erweitern:
<welcome-file-list> <welcome-file>index.xhtml</welcome-file> </welcome-file-list>
Und die Dateierweiterung „xhtml“ dem Faces Servlet zuweisen (ansonsten werden die Faces Tags nicht gerendert / dargestellt).
<servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.xhtml</url-pattern> </servlet-mapping>
Nun können wir unter dem Ordner „WebContent“ die Datei „index.xhtml“ anlegen.
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>SamplejsfErrorPage</title>
</h:head>
<h:body>
<h:form>
<h:commandLink action="#{helloBean.actionNullPointerException}" value="NullPointerException" />
<br/>
<h:commandLink action="#{helloBean.actionCustomException}" value="Custom Exception" />
</h:form>
</h:body>
</html>
Wir haben hier nun zwei Hyperlinks erzeugt welche eine Aktion in einer Bean ausführen.
Erstellen der Bean für die Exceptions
Für das Ausführen einer Aktion benötigen wir eine Bean (anders als bei JSP können wir in JSF kein Java Code in die Seite implementieren, „Gott sei Dank!“).
Unsere Bean könnte nun wie folgt aussehen:
import java.io.Serializable;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
@ManagedBean
@RequestScoped
public class HelloBean implements Serializable {
private static final long serialVersionUID = 1L;
public void actionNullPointerException() {
throw new NullPointerException();
}
public void actionCustomException() {
throw new MyCustomException();
}
}
Die „logik“ ist wirklich sehr einfach, denn wir „werfen“ hier nur zwei Exceptions welche von JSF zunächst an die Oberfläche weitergeleitet werden. Da dieses wie am Anfang erwähnt für Benutzer unschön ist, wollen wir diese umleiten und gesondert behandeln. Für diese Umleitung erweitern wir die Datei „web.xml“ wie folgt:
<error-page> <exception-type>java.lang.Exception</exception-type> <location>/faces/error.xhtml</location> </error-page>
Wenn also eine java.lang.Exception geworfen wird, wird auf die Seite „error.xhtml“ weitergeleitet.
Wir könnten aber auch schreiben:
<error-page> <error-code>500</error-code> <location>/faces/500.xhtml</location> </error-page>
So wird bei jedem HTTP500 Serverstatus auf die Seite 500.xhtml weitergeleitet. Zu beachten ist, dass hier der Tag „error-code“ anstatt „exception-type“ verwendet wird. Wir könnten also auch auf spezielle Codes reagieren (eine Liste von HTTP Serverstatus Codes findest du hier).
Ausblick
In diesem Tutorial habe ich einen Weg gezeigt, wie man eine Exception weiterleiten kann, es gibt jedoch einen besseren Weg über einen ExceptionHandler, welcher einem viel mehr Möglichkeiten bietet. Diesen ExceptionHandler schaue ich mir in einem weiteren Tutorial etwas näher an.