JavaServerFaces – benutzerdefinierte Fehlerseiten

Wenn man Webanwendungen entwickelt muss man immer beachten das Serverseitige Fehler dem Benutzer der Anwendung verständlich dargestellt werden. Die Applicationserver bzw. Webcontainer stellen eine Exception für Entwickler lesbar dar, jedoch die Anwender können in der Regel mit den Informationen nichts anfangen.

Apache Tomcat 7 - HTTP500 Fehlermeldung
Apache Tomcat 7 – HTTP500 Fehlermeldung

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 8Eclipse Oxygen und Apache Tomcat 7. Wenn du die Pakete heruntergeladen und installiert bzw. entpackt hast können wir loslegen.

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.

Eclipse -Reiter "Server"
Eclipse -Reiter „Server“

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).

Eclipse - einrichten eines Servers - Schritt 1
Eclipse – einrichten eines Servers

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 >“.

Eclipse - einrichten eines Servers, einrichten der Pfade und es JREs
Eclipse – einrichten eines Servers, einrichten der Pfade und es JREs

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“.

Eclipse - einrichten eines Servers - Schritt 3
Eclipse – einrichten eines Servers – Schritt 3 – fertigstellen und starten

Ablegen der JSF Resourcen 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.

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).

Eclipse - erstellen eines Dynamischen Webprojektes - Schritt 1
Eclipse – erstellen eines Dynamischen Webprojektes – Schritt 1

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 deutrlich zuviel und unser Tomcat kann damit sowieso nichts anfangen).

Eclipse - erstellen eines Dynamischen Webprojektes - Schritt 2
Eclipse – erstellen eines Dynamischen Webprojektes – Schritt 2

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“.

Eclipse - JavaServer Faces , setzen der Runtime
Eclipse – JavaServer Faces , setzen der Runtime

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.

Projektstruktur, "Dynamisches Webprojekt"
Projektstruktur, „Dynamisches Webprojekt“

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.

Webseite mit Aktionen zum ausführen einer Exception
Webseite mit Aktionen zum ausführen einer Exception

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 wiefolgt 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 das 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).

Anzeige einer benutzerdefinierten Fehlerseite
Anzeige einer benutzerdefinierten Fehlerseite

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.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.