5. JavaServer Faces (JSF)

5. JavaServer Faces (JSF)
•
•
•
•
•
•
•
•
Grundlagen
Nutzung von JSF-Annotationen
Validierung von Eingaben
Ausgabe von Fehlermeldungen
Auswahl darzustellender Elemente
typische elementare Software-Architektur
JSF + JPA
Visualisierungskomponenten
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
207
Literatur
• M. Marinschek, M. Kurz, G. Müllan, JavaServer Faces 2.0,
dpunkt, Heidelberg, 2010 (im Wesentlich auch:
http://tutorials.irian.at/jsf/semistatic/introduction.html)
• K. Ka Iok Tong, Beginning JSF 2 APIs and JBoss Seam, Apress,
Berkeley, USA, 2009
• Standard: Sun, JSR 314: JavaServer Faces 2.0,
http://www.jcp.org/en/jsr/detail?id=314
• Sun, JEE6 Tutorial,
http://java.sun.com/javaee/6/docs/tutorial/doc
• Bücher fixieren teilweise auf Eclipse und JBoss; nicht
notwendig, funktioniert fast alles mit Netbeans und
Glassfish / Apache
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
208
Generelle Ziele
verschiedene Ziele
• Software, die Web als zusätzlichen Nutzen hat (z. B. WebPräsenz, Kataloge, Bestellmöglichkeiten)
• verteilte Softwaresysteme, die Netz als
Komponentenverbindung nutzen (z. B. B2B)
• Arbeitsplatzsoftware, die auch das Web nutzt (nahtlose
Integration, Web ist „unsichtbar“)
• letztes Ziel gewinnt immer mehr Bedeutung für andere Ziele
• Aber: Nicht immer ist Web-fähige Software gewünscht!
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
209
Technische Herausforderungen (1/2)
auf welchem Rechner läuft welche Software
• zentraler Server oder peer-to-peer
• Client-Server, wer ist thin, wer ist fat
Browser-fähig oder standalone
• welcher Browser, welche Sicherheitseinstellungen, welche
Plugins, welches HTML
• Wie bekommt Kunde Software zum Laufen, wie
funktionieren Updates
• darf man, muss man offline arbeiten können
• Usability
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
210
Technische Herausforderungen (2/2)
Sicherheit
• wie Daten sicher verschicken, wem gehört Internet, wer
muss zuhören dürfen
Performance und Stabilität
• schnelle Antworten auch bei Last
• saubere, reproduzierbare Transaktionen
• was passiert bei Netzausfall
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
211
Typische Entwicklungsplattformen (Ausschnitt)
.Net / Microsoft
• ASP.Net (Active Server Pages, gute Abstraktion, zunächst zu
wenig Web-Server (IIS))
• Silverlight (Browser-PlugIn) für RIA, mittlerweile auch lokal
• Oberflächen basierend auf WPF (Windows Presentation
Forum, vektorbasiert, anfänglich zu langsam)
Java
• Servlets, JSP, JSF [später genauer], angegeben mit
steigenden Abstraktionsgrad ser weit verbreitet
• verschiedene neue Frameworks (z. B. Apache Wicket)
• GWT (Google Widget Toolset), SW einmal in Java schreiben,
dann individuell für Browser in Javascript übersetzen
• JavaFX , eigene Sprache nutzt im Browser JRE
• Meinung: Silverlight und JavaFX gegenüber Flash(Nachfolger) immer im Nachteil
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
212
Konzept eines Seitenaufrufs
HTTPHTTP-Request
WebWeb-Server
Client
HTTPHTTP-Response
mit
HTMLHTML-Datei im Body
Server
• HTML (Hypertext Markup Language)
– Auszeichnungssprache mit festgelegten tags zum Aufbau
der Ausgabe
• Ebene 3/4 typisch TCP/IP, Session Ebene 5: HHTP,
Darstellungsebene 6: HTML, Programmebene 7: JVM
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
213
HTTP-Ablauf
• Client: Request
– get, post, head, put, ... URL HTTP1.x
– Header Info: Accept, Cookie, ...
– Body: Post-Parameter
• Server: Response
– Statusmeldung: HTTP1.x 200 OK, oder 404 Error
– Header Info: Content-type, set-cookie, ...
– Body: Dokument
• Verbindungsabbau
• Protokoll ist zustandslos/gedächtnislos; Client wird bei
erneutem Request ohne Trick nicht als Bekannter erkannt
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
214
Web-Server mit Container nutzen
• Servlet: Wortkreation aus
den Begriffen „Server“
und „Applet“,
(serverseitiges Applet)
• Web-Server leitet HTTPRequest an Servlet weiter
• Servlet kann Antwort
(HTML-Code) berechnen
• Servlet kann AnfrageInformationen und
Serverumgebung nutzen
• Servlet kann mit anderen
Servlets kommunizieren
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
Container
215
Motivation für JSF
• Die Widerverwendbarkeit von Servlets ist gering
• Innerhalb jeder JSP bzw. jedes Servlets müssen ähnliche
Schritte ausgeführt werden
• Nur ein Teil der Applikationslogik kann in Tag-Bibliotheken
gekapselt werden
• Workflow ist in der Applikationslogik versteckt, dadurch
schwer nachvollzierbar
• ab JSF 2.0 sehr flexible Gestaltungsmöglichkeiten, u. a. AJAXEinbettung
• Hinweis: wir betrachten nur Grundkonzepte (-> mehr evtl.
Semesteraufgabe)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
216
Web-Server mit JSF- (und EJB-) Unterstützung
• Beispiele:
– Apache + Tomcat
– BEA WebLogic Server
– IBM WebSphere (Apache Geronimo)
– JBoss
– Oracle WebLogic
– Sun Glassfish Enterprise Server (Glassfish)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
217
Konzeptübersicht
Web-Seite in XHTML
Input-Komponente
beschrieben in
XHTML
event
Web-Seite in XHTML
leitet auf
Folgeseite
Output-Komponente
beschrieben in
XHTML
liest
Modell
...
...
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
Java-Programm
im Container
im Server
218
XHTML
•
•
•
•
Idee: HTML nicht XML-konform und zu viele Freiheiten
XHTML in fast allen Elementen wie HTML
XHTML basierend auf XML-Schema leichter zu verarbeiten
Unterschiede zu HTML (Ausschnitt)
– Tags und Attribute müssen klein geschrieben werden
– Attributwerte immer in Anführungsstrichen boarder="7"
– korrekte XML-Syntax: <br/>
br/> nicht <br>
br>
– generell saubere Terminierung <input ... />
• XHTML2 wegen HTML5 zurückgestellt
http://www.w3.org/2009/06/xhtml-faq.html
• Standard: http://www.w3.org/TR/xhtml1/
• Literatur: U. Ogbuji, XHTML step-by-step,
http://www.ibm.com/developerworks/edu/x-dw-x-xhtml-i.html
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
219
Web-GUI-Komponenten
• JSF bietet alle klassischen GUI-Komponenten zur Darstellung
und Bearbeitung an
• Grundidee: Komponenten schicken bei Veränderungen Events
• Nutzung von MVC2
• Komponenten als XHTML eingebettet
<h:inputText id="imname
id="imname"
imname" value="#{modul.name
value="#{modul.name}
modul.name}“
required="true"/>
<h:outputText id=
id="omname"
omname" value="#{modul.name}"/>
value="#{modul.name}"/>
• Kontakt zum Java-Programm über Methodenaufrufe (lesend
und aufrufend, z. B. modul.setName(...),
modul.setName(...), modul.getName()
modul.getName()
• große Komponenten können aus kleineren komponiert
werden
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
220
Nulltes JSF-Beispiel (1/11)
• Aufgabe: Modul (Name + Nummer) eingeben und auf
zweiter Seite wieder ausgeben
• Beispiel zeigt:
– Konzept der XHTML-Nutzung
– erste JSF-Befehle
– Seitenmanövrierung durch JSF
• 0. Beispiel zeigt nicht:
– ordentliche Softwarearchitektur (Controller und Model
trennen)
– Validierungsmöglichkeiten für Eingaben
– Layoutgestaltung
– viele coole Dinge
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
221
Nulltes JSF-Beispiel (2/11) - Start index.xhtml
<?xml
<?xml version='1.0' encoding='UTFencoding='UTF-8' ?>
<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Transitional//EN"
Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1"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">
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
h:head>
<title>Moduleingabe</title>
title>Moduleingabe</title>
</h:head
</h:head>
h:head>
<h:body>
h:body>
<h:form>
h:form>
<h:outputText value="Modulname "/>
<h:inputText id="mname"
id="mname" value="#{modul.name}"
value="#{modul.name}"
required="true"/><br/>
required="true"/><br/>
<h:outputText value="Modulnummer "/>
<h:inputText id="mnr"
id="mnr" value="#{modul.nr}"
value="#{modul.nr}"
required="true"/><br/>
required="true"/><br/>
<h:commandButton value="Abschicken"
value="Abschicken"
action="#{modul.uebernehmen}"/>
action="#{modul.uebernehmen}"/>
</h:form
</h:form>
h:form>
</h:body
</h:body>
h:body>
</html
</html>
html>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
222
Nulltes JSF-Beispiel (3/11) - Analyse der Startseite
• Einbinden der JSF-Bibliotheken
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f ="http://java.sun.com/jsf/core
="http://java.sun.com/jsf/core"
http://java.sun.com/jsf/core" >
• Nutzung von Standard XHTML (vereinfacht, da so als
Standardnamensraum gesetzt)
• enge Verwandtschaft HTML zu XHTML (<h:form>)
• für value="#{modul.name}"
value="#{modul.name}" offene Fragen:
– was ist modul? ( -> Managed Bean)
– warum #? (Trennung von ausführbaren Elementen)
– was passiert bei modul.name? (set/get abhängig von
in/out)
• Ausblick: action="#{modul.uebernehmen}"
action="#{modul.uebernehmen}", echtes EventHandling (Methodenaufruf)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
223
Nulltes JSF-Beispiel (4/11) - Ausgabe ausgabe.xhtml
<?xml
<?xml version='1.0' encoding='UTFencoding='UTF-8' ?>
<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Transitional//EN"
Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1"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">
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
h:head>
<title>Modulausgabe</title>
title>Modulausgabe</title>
</h:head
</h:head>
h:head>
<h:body>
h:body>
<h:form>
h:form>
<h:outputText value="Modulname:
value="Modulname: "/>
<h:outputText id="mname"
id="mname" value="#{modul.name}"/>
value="#{modul.name}"/> <br
<br/>
br/>
<h:outputText value="Modulnummer:
value="Modulnummer: "/>
<h:outputText id="mnr"
id="mnr" value="#{modul.nr}"/><br/>
value="#{modul.nr}"/><br/>
<h:commandButton value="Zur Eingabe"
action="#{modul.eingeben}"/>
action="#{modul.eingeben}"/>
</h:form
</h:form>
h:form>
</h:body
</h:body>
h:body>
</html
</html>
html>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
224
Nulltes JSF-Beispiel (5/11) - Managed Bean [1/3]
package entities;
entities;
import java.io.Serializable
java.io.Serializable;
;
import javax.faces.bean.ManagedBean;
javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
javax.faces.bean.RequestScoped;
@ManagedBean(name="modul")
ManagedBean(name="modul")
@RequestScoped
public class Modul implements Serializable {
private static final long serialVersionUID = 1L;
private int nr;
nr;
private String name;
name;
public Modul(){}
public Modul(int nr,
nr, String name)
name) {
this.nr = nr;
nr;
this.name = name;
name;
}
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
225
Nulltes JSF-Beispiel (6/11) - Managed Bean [2/3]
public String uebernehmen(){
uebernehmen(){
return "./ausgabe.xhtml
"./ausgabe.xhtml";
ausgabe.xhtml";
}
public String eingeben(){
return "./index.xhtml
"./index.xhtml";
index.xhtml";
}
//Manö
//Manövrieren
public String getName()
getName() {
return name;
name;
}
public void setName(String name)
name) {
this.name = name;
name;
}
public int getNr()
getNr() {
return nr;
nr;
}
public void setNr(int nr)
nr) {
this.nr = nr;
nr;
}
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
226
Nulltes JSF-Beispiel (7/11) - Managed Bean [3/3]
@Override
public boolean equals(Object object)
object) {
if (object==null || !(object
!(object instanceof Modul))
return false;
false;
Modul other = (Modul) object;
object;
if (this.nr != other.nr || !this.name.equals(other.name
!this.name.equals(other.name))
this.name.equals(other.name))
return false;
false;
return true;
true;
}
@Override // generieren lassen
public int hashCode()
hashCode() {
int hash = 5;
hash = 47 * hash + this.nr;
this.nr;
hash = 47 * hash
+ (this.name
(this.name != null ? this.name.hashCode()
this.name.hashCode() : 0);
return hash;
hash;
}
@Override
public String toString()
toString() {return
{return name+"("+nr+")";}
name+"("+nr+")";}
Komponentenbasierte
Software}
Entwicklung
Prof. Dr.
Stephan Kleuker
227
Nulltes JSF-Beispiel (8/11) - web.xml [1/2]
• Konfigurationsdatei für Servlets (hier benötigt)
• sun-web.xml ist Glassfish-spezifische Konfiguratonsdatei
<?xml
<?xml version="1.0" encoding="UTFencoding="UTF-8"?>
<webweb-app version="3.0"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchemaxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/webhttp://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<contextcontext-param>
param>
<paramparam-name>javax.faces.PROJECT_STAGE</paramname>javax.faces.PROJECT_STAGE</param-name>
name>
<paramparam-value>Development</paramvalue>Development</param-value>
value>
</context
</contextcontext-param>
param>
<servlet>
servlet>
<servletservlet-name>Faces Servlet</servletServlet</servlet-name>
name>
<servletservlet-class>javax.faces.webapp.FacesServlet
</servlet
</servletservlet-class>
class>
<load<load-onon-startup>1</loadstartup>1</load-onon-startup>
</servlet
</servlet>
servlet>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
228
Nulltes JSF-Beispiel (9/11) - web.xml [2/2]
<servletservlet-mapping>
mapping>
<servletservlet-name>Faces Servlet</servletServlet</servlet-name>
name>
<urlurl-pattern>/faces/*</urlpattern>/faces/*</url-pattern>
pattern>
</servlet
</servletservlet-mapping>
mapping>
<sessionsession-config>
config>
<sessionsession-timeout>
timeout>
30
</session
</sessionsession-timeout>
timeout>
</session
</sessionsession-config>
config>
<welcomewelcome-filefile-list>
list>
<welcomewelcome-file>faces/index.xhtml</welcomefile>faces/index.xhtml</welcome-file>
file>
</welcome
</welcomewelcome-filefile-list>
list>
</web
</webweb-app>
app>
in sun-web.xml steht u. a.
<context<context-root>/JSFSpielerei2</contextroot>/JSFSpielerei2</context-root>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
229
Nulltes JSF-Beispiel (10/11) - Projektstruktur
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
230
Nulltes JSF-Beispiel (11/11) - Ergebnis
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
231
Basisprinzip der Applikationssteuerung
• Im Controller: Auftruf einer Methode ohne Parameter vom
Rückgabetyp String
<h:commandButton value="Abschicken"
value="Abschicken"
action="#{modul.uebernehmen}"/>
action="#{modul.uebernehmen}"/>
• Im Modell:
public String uebernehmen(){
uebernehmen(){
return "./ausgabe.xhtml
"./ausgabe.xhtml";
ausgabe.xhtml";
}
• Methode kann natürlich abhängig von Variablen
unterschiedliche Seiten liefern
• Beachten: Navigation kann in den Tiefen des Codes
verschwinden ( -> Konstanten nutzen, Architektur)
• Hinweis: wir werden noch Varianten kennenlernen
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
232
Lebensdauer von Informationen (scope)
None
Request
Session
Application
nur
nur für einen
aktuelle Aufruf
Seite
(auch für
Weiterleitung)
für eine
NutzerSitzung
solange Zeit
aktuelles
Deployment
läuft
• Anmerkung: Obwohl es verlockend ist, viele Informationen in
Session oder Application zu legen, ist dies wg Performance
verboten (wird gespeichert, evtl. passiviert, hat wilde
Referenzen, Zugriff muss ggfls. synchronisiert werden)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
233
Scope-Beispiel (1/5) - Bean-Klasse
//@ManagedBean(name
//@ManagedBean(name = "modul
"modul")
modul")
//@RequestScoped
Modul als einfache Klasse
//@RequestScoped
public class Modul implements Serializable { ...// wie vorher
"moduln
moduln")
@ManagedBean(name = "
moduln
")
@NoneScoped
public class ModulNone extends Modul{}
Modul{}
@ManagedBean(name = "modulr
"modulr")
modulr")
@RequestScoped
public class ModulRequest extends Modul{}
Modul{}
@ManagedBean(name = "moduls
"moduls")
moduls")
@SessionScoped
public class ModulSession extends Modul{}
Modul{}
@ManagedBean(name = "modula
"modula")
modula")
@ApplicationScoped
public class ModulApplication extends Modul{}
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
234
Scope-Beispiel (2/5) - Ausschnitt index.xhtml
<h:form>
h:form>
<h:panelGrid columns="3" >
<h:outputLabel for="mnamen"
for="mnamen" value="Modulname "/>
<h:inputText id="mnamen"
id="mnamen" value="#{moduln.name}"/>
value="#{moduln.name}"/>
<h:message for="mnamen"
for="mnamen" />
<h:outputLabel for="mnrn"
for="mnrn" value="Modulnummer "/>
<h:inputText id="mnrn"
id="mnrn" value="#{moduln.nr}"/>
value="#{moduln.nr}"/>
<h:message for="mnrn"
for="mnrn" />
<h:outputLabel for="mnamer"
for="mnamer" value="Modulname "/>
<h:inputText id="mnamer"
id="mnamer" value="#{modulr.name}"/>
value="#{modulr.name}"/>
<h:message for="mnamer"
for="mnamer" />
<h:outputLabel for="mnrr"
for="mnrr" value="Modulnummer "/>
<h:inputText id="mnrr"
id="mnrr" value="#{modulr.nr}"/>
value="#{modulr.nr}"/>
<h:message for="mnrr"
for="mnrr" />
<!-<!-- auch moduls und modula -->
-->
<h:commandButton value="Abschicken"
value="Abschicken"
action="#{modulr.uebernehmen}"/>
action="#{modulr.uebernehmen}"/>
</h:panelGrid
</h:panelGrid>
h:panelGrid>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
235
Scope-Beispiel (3/5) - Ausschnitt ausgabe.xhtml
<h:form>
h:form>
<h:messages globalOnly="true"/>
globalOnly="true"/>
<h:outputText value="Modulname n: "/>
<h:outputText id="mnamen"
id="mnamen" value="#{moduln.name}"/>
value="#{moduln.name}"/> <br
<br/>
br/>
<h:outputText value="Modulnummer n: "/>
<h:outputText id="mnrn"
id="mnrn" value="#{moduln.nr}"/><br/>
value="#{moduln.nr}"/><br/>
<h:outputText value="Modulname r: "/>
<h:outputText id="mnamer"
id="mnamer" value="#{modulr.name}"/>
value="#{modulr.name}"/> <br
<br/>
br/>
<h:outputText value="Modulnummer r: "/>
<h:outputText id="mnrr"
id="mnrr" value="#{modulr.nr}"/><br/>
value="#{modulr.nr}"/><br/>
<h:commandButton value="Zur Eingabe"
action="#{modulr.eingeben}"/><br/>
action="#{modulr.eingeben}"/><br/>
<!-<!-- auch moduls und modula -->
-->
<h:commandButton value="Ausgabe wiederholen"
action="#{modulr.uebernehmen}"/>
action="#{modulr.uebernehmen}"/>
</h:form
</h:form>
h:form>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
236
Scope-Beispiel (4/5) - Ein Nutzer, zwei Klicks
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
237
Nutzer 2
Nutzer 1
Scope-Beispiel (5/5) - Zwei Nutzer
Zeit
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
238
Manövrieren vor JSF 2.0
• Grundidee: Automat mit Seiten als Knoten (Zustände),
Übergang findet durch String-Konstanten statt
• String-Konstanten sind Ergebnisse von (Action-) Methoden
(oder stehen direkt in action="EINGEBEN"
action="EINGEBEN")
index.xhtml
ausgabe.xhtml
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
239
Manövrieren vor JSF 2.0 - faces-config.xml 1/2
<?xml
<?xml version='1.0' encoding='UTFencoding='UTF-8'?>
<facesfaces-config version="1.2"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchemaxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/webhttp://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
<navigationnavigation-rule>
rule>
<fromfrom-viewview-id>/index.xhtml</fromid>/index.xhtml</from-viewview-id>
id>
<navigationnavigation-case>
case>
<fromfrom-outcome>ANZEIGEN</fromoutcome>ANZEIGEN</from-outcome>
outcome>
<toto-viewview-id>/ausgabe.xhtml</toid>/ausgabe.xhtml</to-viewview-id>
id>
</navigation
</navigationnavigation-case>
case>
</navigation
</navigationnavigation-rule>
rule>
<navigationnavigation-rule>
rule>
<fromfrom-viewview-id>/ausgabe.xhtml</fromid>/ausgabe.xhtml</from-viewview-id>
id>
<navigationnavigation-case>
case>
<fromfrom-outcome>EINGEBEN</fromoutcome>EINGEBEN</from-outcome>
outcome>
<toto-viewview-id>/
id>/ index.xhtml </to
</toto-viewview-id>
id>
</navigation
</navigationnavigation-case>
case>
</navigation
</navigationrule>
navigation-rule>
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
240
Manövrieren vor JSF 2.0 - Managed Bean
// statt durch Annotationen kö
können Beans auch in facesfaces// config.xml angelegt werden
public class Modul implements Serializable {
private static final long serialVersionUID = 1L;
private int nr;
nr;
private String name;
name;
// fehlt: getget- und setset-Methoden für Exemplarvariablen
public Modul(){}
public String uebernehmen(){
//Actionuebernehmen(){
//Action-Methode
// Zugriff auf Exemplarvariablen mö
möglich
return "ANZEIGEN";
}
public String eingeben(){
// Zugriff auf Exemplarvariablen mö
möglich
return "EINGEBEN";
}
...
Komponentenbasierte Software}
Entwicklung
Prof. Dr.
Stephan Kleuker
241
Manövrieren vor JSF 2.0 - faces-config.xml 2/2
<managedmanaged-bean>
bean>
<managedmanaged-beanbean-name>modul</managedname>modul</managed-beanbean-name>
name>
<managedmanaged-beanbean-class>entities.Modul</managedclass>entities.Modul</managed-beanbean-class>
class>
<managedmanaged-beanbean-scope>request</managedscope>request</managed-beanbean-scope>
scope>
</managed
</managedbean>
managed-bean>
</faces
</facesfaces-config>
config>
Vorteil der klassischen Navigation:
• Es gibt zentrale Stelle, an der es einen Überblick über
mögliche Abläufe gibt
Nachteile:
• JSF 2.0 bietet flexiblere Ablaufsteuerung
• XML ist schwer nachvollziehbar
• Konfigurationsdatei facesfaces-config.xml bleibt trotzdem wichtig
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
242
Erinnerung: Konstanten in Programmen
• schlecht return "ANZEIGEN";
• besser: Konstanten getrennt deklarieren
public class Modul implements Serializable{
Serializable{
private final static string ANZEIGEN = "ANZEIGEN";
...
return ANZEIGEN;
• Alternativ: Klasse mit Konstanten
package konstanten;
public class Navigation{
public final static string ANZEIGEN = "ANZEIGEN";
...
return konstanten.Navigation.ANZEIGEN;
konstanten.Navigation.ANZEIGEN;
– Entwicklungsumgebungen erlauben dann einfache Suche
und Änderung (Refactoring)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
243