JavaServer Faces
Werbung
Java Server Faces (JSF) Seminararbeit WS2009/10 Von Mohamed Sabbar Email: [email protected] Hochschule Rhein-Main Studiengang: Medieninformatik Betreuender Professor: Prof. Dr. Karl-Otto Linn Wiesbaden, 25.02.2010 JavaServer Faces 25. Februar 2010 Inhaltsverzeichnis 0 Abbildungs- und Tabellenverzeichnis ........................................................................................ 3 1 Vorwort ...................................................................................................................................... 4 2 JavaServer Faces Einführung ...................................................................................................... 4 2.1 Kurzgeschichte der Web-Entwicklung ................................................................................ 5 2.2 Einführung in Java Service Pages (JSP) ................................................................................ 6 3 Model View Controller (MVC) .................................................................................................... 7 4 Die Java Server Faces Technologie............................................................................................. 8 4.1 Die Strukturen von JSF Anwendungen ............................................................................. 10 5 Lebenszyklus einer JSF Anwendung ......................................................................................... 11 5.1 Erzeugung/Wiederherstellung des Komponentenbaums ................................................ 11 5.2 Übernahme der Anfragewerte.......................................................................................... 11 5.3 Validierung/Konvertierung ............................................................................................... 12 5.4 Aktualisierung der Modellobjekte .................................................................................... 12 5.5 Aufruf der Anwendungslogik ............................................................................................ 12 5.6 Rendern der Antwort ........................................................................................................ 12 6 Java Server Faces Komponenten ............................................................................................. 13 6.1 Java Server Faces Tag Libraries ......................................................................................... 13 6.2 Validation .......................................................................................................................... 15 7 Fazit .......................................................................................................................................... 16 8 Literaturverzeichnis ................................................................................................................. 17 9 Online Quellen ......................................................................................................................... 17 Seite 2 JavaServer Faces 25. Februar 2010 0 Abbildungs- und Tabellenverzeichnis Abb.1: Servlet mit Get-Methode Abb.2: Beispiel für JSP Abb.3: Web-Framework mit verschiedenen Zuständigkeitsbereichen Abb.4: Das Model-Prinzip basiert auf JSF Abb.5: Die Konfigurationsdatei facex-config.xml Abb.6: Lebenszyklus einer JSF Anfrage Abb.7: Beispiel einer JSF Seite mit Tag Libraries Abb.8: Komponenten und ihre Darstellung Abb.9: Validate_longrange Tag im Beispiel Seite 3 JavaServer Faces 25. Februar 2010 1 Vorwort Die Technologie Java Server Faces ist ein modernes Framework zur Entwicklung von Benutzeroberflächen für webbasierte Anwendungen. Die Möglichkeiten, die diese Technologie bietet, sind sehr umfangreich und können daher im Rahmen dieser Ausarbeitung nicht bis ins Detail erläutert werden. Die Arbeit soll vielmehr eine Einführung in das Framework Java Server Faces geben. Insbesondere sollen auch die Konzepte hinter dieser Technologie beleuchtet werden. Weiterhin werden die Funktionalitäten und die wichtigsten Elemente vorgestellt. In diesem Zusammenhang erhält der Leser zusätzlich einen Überblick über die geschichtliche Entwicklung der Web-Technologien bis hin zur Einführung und Umsetzung von Web-Anwendungen. 2 JavaServer Faces Einführung Java Server Faces (JSF) ist eine Technologie zur Entwicklung von modernen WebAnwendungen. JSF basiert auf Servlets und der JSP-Technologie, die beide zu den Webtechnologien der Java Plattform Enterprice Edition (Java EE) gehören. Mithilfe des Frameworks (JSF) kann der Entwickler in einer einfachen Art und Weise Komponenten für die Benutzerschnittstellen in der Web-Anwendung implementieren, wobei es allerding dutzende Frameworks gibt, die der Entwicklung von Web- Anwendungen dienen. Die Vielfalt der aktuell auf dem Markt existierenden Frameworks ist enorm. Dabei gibt es allein im Java Bereich schon viele verschiedene Frameworks wie z.B. Apache Struts oder Apache Coccon. Bereits Mitte der 90er Jahre wurden Technologien zur Entwicklung von dynamischen Web Anwendungen bereitgestellt. Beispiele dafür sind etwa JSP- und Servlet Technologien. Im nächsten Kapitel soll ein kurzer Überblick über die geschichtliche Entwicklung der Web-Programmierung gegeben werden. Dabei wird unter anderem aufgezeigt werden, weshalb die Notwendigkeit für die Spezifikation der Java Server Faces-Technologie bestand. Seite 4 JavaServer Faces 25. Februar 2010 2.1 Kurzgeschichte der Web-Entwicklung Der IBM Gründer Thomas J. Watson stellte zu Beginn des Computerzeitalters einmal die Behauptung auf: „I think there is a world market for maybe five computers“. Damals eine mutige Schätzung - heute aber weiß man, dass diese Prognose ein großer Irrtum war. Die Nutzer können heute zu jedem Zeitpunkt und an jedem Ort mit InternetZugang auf Web Anwendungen zugreifen und die eigenen Bedürfnisse im World Wide Web abdecken. Ganze Geschäftsprozesse werden im World Wide Web abgebildet. Heute finden wir in fast jedem Haushalt Computer, die mit Millionen anderer Computer vernetzt sind und mittlerweile eine Selbstverständlichkeit im Alltag darstellen. Die Entwicklung zeigt, wie die Netzwerklandschaft zum globalen Dorf zusammen wächst. Die Entwicklung begann im Jahr 1991 mit der Übertragung der ersten Seite in Hypertext Markup Language (HTML). Zur damaligen Zeit waren nur die Wenigsten in dem Glauben, dass das World Wide Web eine große Zukunft haben würde. Anfangs konnte man einfache Webseiten mit HTML generieren, die hauptsächlich der Informationsausgabe dienten. HTML wurde im Laufe des Jahres durch weitere Elemente und Funktionalitäten ergänzt und stetig weiter entwickelt. Für die Erstellung von dynamischen Elementen kam JavaScript als Client Lösung hinzu. Zur selben Zeit entstanden auch im Server Bereich verschiedene Sprachen für serverseitige Web-Entwicklung. Sprachen wie PHP, Python, Ruby oder auch Java waren am Markt zu finden. Da die Komplexität der Anwendung immer größer wurde, wurden im Laufe der Zeit immer mehr Sprachen und Technologien entwickelt. Die Kreativität in der Entwicklung kannte keine Grenzen und die Ansprüche und Bedürfnisse wurden immer größer. Im Java Bereich wurde im Jahr 1997 die Servlet-Technologie zur Generierung von dynamischen HTML Seiten am Server entwickelt. Ein Servlet ist eine Java Klasse, die aus den Befehlen HTML erzeugt. In Abbildung 1 sehen wir beispielhaft ein einfaches Servlet, das über die Get-Methode eine http-Anfrage behandelt. Seite 5 JavaServer Faces 25. Februar 2010 Abb.1: Servlet mit Get-Methode 2.2 Einführung in Java Service Pages (JSP) Die Servlets boten zwar einige Vorteile, waren jedoch anfangs noch mit mehreren Problemen behaftet. So wird ein Servlet bei komplexen Web-Anwendungen schnell zu unübersichtlich. Darüberhinaus liegt es nicht im Interesse des Entwicklers mittels Java Code die Ausgabe zu implementieren. Um den genannten Problemen entgegen zu wirken, wurde schließlich die JSP-Technologie entwickelt. In Abbildung 2 soll die JSP-Sprache anhand eines Beispiels erklärt werden. Im Zusammenhang mit JSP wird überwiegend HTML Tag genutzt. Im vorliegenden Beispiel wurde allerdings auf so genannte Skriptlets zurückgegriffen. Skriptlets werden verwendet, um Javacodes zu integrieren, und zwar an jeder Stelle der Ausgabe-Datei. Im Beispiel wird die Methode GetParameter aufgerufen. Dabei vermischen wir Darstellung (HTML) und Funktionalität (Java). Diese Kombination ist nicht im Sinne des Entwicklers. Seite 6 JavaServer Faces 25. Februar 2010 Abb.2: Beispiel für JSP Ein weiteres Problem neben der Vermischung von Darstellung und Funktionalität bei der Verwendung von JSP, stellte der eingebaute Quellcode da, der erst zum Zeitpunkt des Anwendungsstarts im Applikationsserver kompiliert wurde. Im Zuge dessen konnte man vorhandene Fehler im Quellcode erst bei Laufzeit des Programms erkennen. Diese Nachteile führten zur Entwicklung von Web-Frameworks. 3 Model View Controller (MVC) Um den im vorangegangenen Kapitel erläuterten Problemen entgegenzuwirken, hat man Web-Frameworks entwickelt, die große Teile einer Web-Anwendung in verschiedene Zuständigkeitsbereiche aufteilen. Man nehme an, das Layout einer Anwendung in einer Seitenbeschreibungssprache wie JSP (View) erzeugt werden soll. In diesem Fall gilt es, die Anwendungslogik dem Model zuzuordnen, um das Layout von den Funktionalitäten zu trennen. Es wird also zwischen Datenhaltung (Model), Ansicht (View) und Steuerungslogik (Controller) unterschieden um so die Trennung Zuständigkeitsbereichen zu ermöglichen. Seite 7 zwischen den verschiedenen JavaServer Faces 25. Februar 2010 Eine Übersicht über die drei Bereiche bietet Abbildung 3. Abb.3: Web-Framework mit verschiedenen Zuständigkeitsbereichen Quelle: http://jsfatwork.irian.at/semistatic/introduction.html 4 Die Java Server Faces Technologie Wie bereits erwähnt, ist die Java Server Faces Technologie (JSF) ein User Interface (UI) Framework, mit dem auch komplexe Web Anwendungen erstellt werden können, die in einem Servlet Container laufen. Die aktuelle JSF Version 2.0 wurde im Dezember 2009 auf der SUN Website zum Download bereitgestellt. Über die Tag–Bibliotheken werden Komponenten für die Oberfläche bereitgestellt oder erweitert, wodurch die Benutzerschnittstelle in einer höheren Abstraktionsebene Komponenten zusammensetzt. Die Stärke von JSF besteht dabei im Einsetzen von User-Interface-Komponenten. Die Vorteile, die diese Technologien mitbringen sind u.a.: Trennung zwischen Darstellung und Geschäftslogik Einfaches Erstellen eines UIs mittels vordefinierten UI Komponenten Datenaustausch zwischen Server und Client UI wird vereinfacht UI ausgelöste Events können einfach mit dem Server verknüpft werden UI Komponenten können einfacher umgetauscht werden. Seite 8 JavaServer Faces 25. Februar 2010 JSF verfolgt hierbei das Ziel der Trennung von Geschäftslogik und Darstellung. Der Programmierer entwickelt die Logik und die Steuerung der Anwendung, während der Designer sich auf die Darstellung konzentrieren kann. Diese Trennung ermöglicht u.a. paralleles Arbeiten, das durch die zielgerichtete Einsetzung der Kompetenzen von Entwickler und Designer erreicht wird und auf diesem Weg eine sofortige Projektintegration, ohne weitere Kenntnisse in dem jeweiligen Zuständigkeitsbereich, möglich macht. In Abbildung 4 ist zu sehen, wie der Client eine Anfrage schickt. Das Servlet nimmt die Anfrage entgegen, initialisiert im Model z.B. die eingegebenen Werte und steuert den Ablauf. Im Anschluss werden die Werte in der Datenbank eingetragen. Die View wird erzeugt, greift sich die aktuellen Daten aus dem Model heraus und generiert anschließend eine Antwort. Abb.4: Das Model Prinzip basiert auf JSF Quelle: http://jsfatwork.irian.at/semistatic/introduction.html Auch das Austauschen der Präsentationsschicht in ein anderes Ausgabeformat wird durch JFS ermöglicht. Zum Beispiel lassen sich eigene Komponenten erstellen um Tabellen oder andere Präsentationselemente zu ersetzen. Dabei stellt JSF nicht nur eine Vielzahl von Komponenten bereit, die über eigene Tags nutzbar sind, sondern auch Validatoren zur Kontrolle von Fehleingaben werden zur Verfügung gestellt. Seite 9 JavaServer Faces 25. Februar 2010 4.1 Die Strukturen von JSF Anwendungen Die View bildet die Basis und das zentrale Konzept von JavaServer Faces. Sie kann als eine Baumstruktur aus JSF-Komponenten beschrieben werden, die genau einmal beim Aufruf einer JSP vorkommt. Zu Beginn des JSF-Lebenszyklus wird die View direkt nach der Anfrage des Clients aufgebaut. In der letzten Phase des Lebenszyklus werden dann alle Komponenten rekursiv mit der Wurzel beginnend aufgerufen, wodurch das Erzeugen einer Antwort, beispielsweise einer HTML-Seite, möglich wird. Die Verknüpfung der einzelnen Views ist nicht statisch in der jeweiligen Seite unterzubringen. Die Verkettung erfolgt vielmehr über die Konfigurationsdatei (siehe zB.Abb.5: faces-config.xml). Es werden also Regeln erstellt, die innerhalb der Views verwendet werden. Demnach hat das Umdefinieren einer Regel Auswirkungen auf alle Seiten. Diese Eigenschaft ist interessant für Portalseiten, auf denen durch Navigationsregeln festgelegt wird, zu welcher Seite verwiesen werden soll, wenn eine bestimmte Aktion einen bestimmten Rückgabewert (Outcome) liefert. Abb.5: Die Konfigurationsdatei facex-config.xml Die Anbindung der JSPs geschieht per JavaBeans. JavaBeans sind Java Klassen, die zur Speicherung von Benutzer- oder Anwendungswerten verwendet werden. Die Verwaltung der Klassen, bzw. die Verwaltung der Objekte übernimmt JSF. In der JSP wurden diese JavaBeans in jeder Seite eingebunden, wobei Managed-Beans das Verfahren dieser (globalen) Bereitstellung, sprich die Verwaltung der Beans, bezeichnet. Die Inkarnation erfolgt nach dem Lazy loading Prinzip. Demnach also dann, wenn auf eine Bean zum ersten Mal zugegriffen wird. Dazu kann zentral über die Konfigurationsdatei gesteuert werden, welchen Gültigkeitsbereich die erzeugten Objekte haben. Seite 10 JavaServer Faces 25. Februar 2010 Über ValueBinding können diese JavaBeans mit Komponenten verknüpft werden, so dass eine Kopplung zwischen dem Modell und der Sicht entsteht. Die verknüpften Beans heißen dann Backing-Beans und gehören aus JSF-Sicht zur Schicht des Modells, aus diesem Grund auch Modellobjekte genannt. Sie besitzen Getter- und Setter-Methoden für ihre Propertyvariablen und können auch Aktions- sowie Validierungsmethoden bereitstellen. 5 Lebenszyklus einer JSF Anwendung Der Ablauf einer JSF Seite ist ähnlich zu dem einer JSP Seite. Der Client stellt eine Anfrage auf den Server, um die Seite zu erhalten. Dabei durchläuft jede JSF Anfrage sechs Bearbeitungsphasen bis die Ergebnisseite auf dem Browser erscheint. Die Bearbeitung der nächsten Phase ist vom erfolgreichen Abschluss der vorherigen Phase abhängig, da sie erst dann bearbeitet wird, wenn die vorherige Phase erfolgreich abgeschlossen ist. Bei Fehlereintritt werden die Phasen nicht weiter bearbeitet. 5.1 Erzeugung/Wiederherstellung des Komponentenbaums Um das bereits erwähnte Dialoggedächtnis zu realisieren, ist es notwendig, die (Formular)Zustände zu speichern und wiederherzustellen. Dabei werden zwei Fälle unterschieden: Beim erstmaligen Abruf einer Seite existiert noch kein View-Objekt. Daher muss eines erzeugt werden, in dem ein leerer Komponentenbaum angelegt und im FacesContext einhängt wird. Anschließend kann sofort zur Render ResponsePhase übergegangen werden, da keine Verarbeitung von übergebenen Werten etc. nötig ist. Sollte bereits ein Komponentenbaum im FacesContext existieren, so wird dieses View-Objekt geladen und mit Validatoren, Konvertern und Listenern verknüpft. 5.2 Übernahme der Anfragewerte In dieser Phase werden die übertragenen Werte des Requests (also die Daten des abgeschickten Formulars) in den Komponentenbaum übernommen, also in den entsprechenden Komponenten gesetzt. ActionEvents werden hier generiert, z.B, das Drücken des Buttons durch den der Request erzeugt wurde. Dabei ist zu erwähnen, dass hier noch keine Änderung des Modells erfolgt, sondern nur die String-Werte vorbereitet werden. Seite 11 JavaServer Faces 25. Februar 2010 5.3 Validierung/Konvertierung Anhand von Konvertern (aber auch Renderern) werden die gespeicherten Werte der vorherigen Phase in die Zielformate (Modelldatentypen) überführt. Anschließend werden alle Werte der Komponenten mittels registrierter Validatoren überprüft. Im Fehlerfall werden dabei üblicherweise komponentenbezogene Meldungen generiert und es wird mit der Render-Response-Phase fortgefahren. Dadurch wird dieselbe Seite gerendert, da ihr Komponentenbaum noch im FacesContext liegt. 5.4 Aktualisierung der Modellobjekte Wenn bis hierhin kein Fehler auftrat, so werden die überprüften Werte in das Modell übernommen. Dabei werden ValueChangeEvents generiert, falls sich ein Wert geändert hat. Nach dieser Phase werden die registrierten Listener über Wertänderungen informiert. 5.5 Aufruf der Anwendungslogik Alle Ereignisse der Anwendungsebene werden verarbeitet. So wird z.B. die nachfolgende Seite ermittelt und ihr Komponentenbaum im Kontext abgelegt. Nach dieser Phase werden alle registrierten ActionListener benachrichtigt. 5.6 Rendern der Antwort Der im Kontext befindliche Komponentenbaum wird ausgegeben. Dazu wird die Encode-Methode jeder Komponente ausgeführt. Wird also die Phase Invoke Application übersprungen so erfolgt das Rendern derselben Seite.Abbildung 6 verdeutlicht ergänzend den vollständigen Ablauf. Abb.6: Lebenszyklus einer JSF Anfrage Quelle: http://jsfatwork.irian.at/book_de/ajax.html Seite 12 JavaServer Faces 25. Februar 2010 6 Java Server Faces Komponenten 6.1 Java Server Faces Tag Libraries Für die JSF Entwicklung stellt die Spezifikation zwei Tag Libraries bereit. Die JSF Implementierung stellt zwei grundlegende Taglibrarys zur Verfügung. Die html_basic Taglibrary definiert Tags für gängige HTML UI Komponenten Die jsf-core Taglibrary definiert alle anderen Tags der JSF Für die Nutzung der Tags müssen die Libraries zu den entsprechenden Seiten hinzugefügt werden. Das Attribut „uri“ beinhaltet die Zieladresse der Tag Libraries. Mit dem Prefix „h“ und „f“ kann auf Komponenten zugegriffen werden. Abbildung 7 veranschaulicht die Nutzung der JSF Tags in der Praxis. Ergänzend ist anzumerken, dass Tags sowohl zum Einlesen des Namens als auch für die Ausgabe benutzt werden, wobei der Tag des Komponenten „h:inputText value=“#{customer.firstname}“ den vom Nutzer eingegebenen „firstname“ in die Bean „Customer“ einspeichert. Seite 13 JavaServer Faces 25. Februar 2010 Abb.7: Beispiel einer JSF Seite mit Tag Libraries Quelle: http://jsfatwork.irian.at/semistatic/introduction.html Abbildung 8 zeigt die Darstellung der Seite im Browser und den Zusammenhang zu den JSF-Komponenten in der XHTML-Datei. Abb.8: Komponenten und ihre Darstellung Quelle: http://jsfatwork.irian.at/semistatic/introduction.html Seite 14 JavaServer Faces 25. Februar 2010 6.2 Validation Die JSF API stellt dem Entwickler bereits vordefinierte Validatoren zu Verfügung. Die Aufgabe von Validatoren besteht in der Überprüfung der eingegebenen Werte der Komponente. Ist die Eingabe fehlgeschlagen, so wird eine Fehlermeldung an den Client gesendet. Vordefinierte Validatoren können z.B. das Datum, die email Adresse oder auch die BLZ überprüfen, wobei alle Validatoren den Interface Validator implementieren. Dadurch besteht auch die Möglichkeit eigene Validatoren zu implementieren, die wiederum den Interface Validator implementieren. Um eine Komponente mit einem Validatoren zu versehen, wird der entsprechende Validator Tag in die Komponente eingebaut. In Abbildung 9 wird z.B. die Eingabe überprüft: Bei einer Eingabe zwischen 0 und 5 wird diese akzeptiert, ansonsten tritt ein Hinweis auf. Abb.9: Validate_longrange Tag im Beispiel Seite 15 JavaServer Faces 25. Februar 2010 7 Fazit Schlussfolgend kann man sagen, dass die JavaServer Faces Technologie mit flexiblen Features, die der Entwicklung von Web Anwendungen dienen, viele Möglichkeiten bietet. Insgesamt hat sich JSF in der Breite zwar nicht festgesetzt, findet aber in vielen interessanten und komplexen Anwendungen Akzeptanz. Die Ziele der Spezifikation liegen hierbei in der Einfachheit und Flexibilität in der Entwicklung. JSF ist ein UIFramework um interaktive Web-Anwendungen zu entwickeln, womit auch das Wiederverwenden von UI-Komponenten auf diesem Weg erleichtert wird. Die Einfachheit der Datenbindung zwischen Logik(Beans) und UI-Komponenten stellt weiterhin ein positives Merkmal da, durch das sich JSF auszeichnet. Darüberhinaus ermöglicht die Technologie die Einstellung der Ablaufsteuerung in der XML Konfigurationsdatei. Zu erwähnen ist jedoch auch die nachteilige Eigenschaft von JSF, die in der großen Anzahl der Techniken, die eingesetzt werden, besteht. Zu diesen zählen u.a. HTML, CSS, JavaScript, XML, ein Applikationsserver, eine Expression Language und JavaServer Pages. Im Falle einer Änderung müssen zusätzlich mehrere Dateien in unterschiedlichen Verzeichnissen bearbeitet werden (XML-Konfiguration des ServletContainers, Navigationsregeln, JSP-Datei). Dieser Nachteil gibt Spielraum für konkurrierende Produkte. Als Beispiel für diese können u.a. die Frameworks Apache Wicket und Apache Tapestry angeführt werden. Seite 16 JavaServer Faces 25. Februar 2010 8 Literaturverzeichnis Marinschek, Martin (2007): JSF@WORK: JavaServer Faces und Apache MyFaces erfolgreich. (ISBN: 3-89864-401-4) Müller, Bernd (2006): JavaServer Faces - Ein Arbeitsbuch für die Praxis. (ISBN: 3-446-40677-8) McLaughlin, Brett (2006): Ajax von Kopf bis Fuß (ISBN: 3-89721-469-5) Jacobi, Jonas (2006): Pro JSF and Ajax – Building Rich Internet Components, Computer Bookshops, Februar, (ISBN: 1-590-59580-8) 9 Online Quellen - JavaServer Faces, Sun - http://java.sun.com/j2ee/javaserverfaces/ - http://java.sun.com/webapps/download/Display - www.sigs.de/publications/js/2004/04/beneken_JS_04_04.pdf - https://svn.assembla.com/svn/rolez/Others/JSF%20%20Integration%20in%20EJB/Source%20pdfs/JSF-Referat.pdf - http://www.gruntz.ch/courses/sem/ss03/JSF.pdf - Prof. Dr. Peter Barth, Web-basierte Anwendungen - Skriptteil: JavaServer Faces, FH Wiesbaden - Medieninformatik, März 2009 - Torben Brodt, Ajax und Google Web Toolkit, Seminararbeit, - FH Wiesbaden - Medieninformatik, Februar 2008 - Stefan Berntheisel, JSF und Ajax, Seminararbeit, - FH Wiesbaden - Medieninformatik, Februar 2008 Seite 17
