In diesem Teil des Tutorials möchte ich das Konzept der Managed-Beans vorstellen. Es ist eines der Grundprinzipien von JSF und damit auch von IceFaces. Aber zuerst möchte ich die Frage klären:
Was sind Managed-Beans?
Managed-Beans basieren auf Java-Beans. Dies sind Javaklassen, die folgende Bedingungen erfüllen:
1. Ein Standardkonstruktor
2. Datenzugriffsmethoden (Getter und Setter)
Managed-Beans sind Java-Beans, bei denen es noch Vorschriften für die Datenzugriffsmethoden gibt, so dass sie von IceFaces verwendet werden können. Sie müssen folgenden Bedingungen gehorchen, die
Java-Entwicklern allerdings bekannt sein sollten:
1. Die Getter müssen mit
get beginnen, dann folgt beginnend mit einem Großbuchstaben der Name des Attributs.
2. Die Setter müssen mit
set beginnen, dann folgt beginnend mit einem Großbuchstaben der Names des Attributs.
3. Bei boolean-Variablen können die Getter auch mit
is beginnen, dann der Name des Attributs mit einem Großbuchstaben beginnend.
Im Folgenden sehen Sie eine Beispielbean BookBean.java. Sie ist die Grundlage für die Anwendung, welche wir im Laufe dieses Tutorials entwickeln wollen.
package de.myOpac.beans;
public class BookBean {
private String title;
private String author;
private int pages;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPages() {
return pages;
}
public void setPages(int pages) {
this.pages = pages;
}
}
Die Klasse hat drei Attribute und für jedes Attribut jeweils eine get- und eine set-Methode. Damit kann diese Bean bereits für IceFaces verwendet werden. Was bedeutet das: Die Bean kann in IceFaces
verwendet werden?
Die Beans werden von IceFaces verwaltet. Dies bedeutet eine erhebliche Arbeitserleichterung für den Entwickler. Dabei werden die Beans in der Anwendungsdeklarationsdatei hinterlegt, so dass von
allen Seiten aus auf sie zugegriffen werden kann. Die Beans müssen nicht mehr speziell durch eine separate Angabe eingebunden werden wie bei herkömmlicher JSP-Programmierung. Sobald die Beans in
der Anwendungskonfigurationsdatei definiert sind, stehen sie auf jeder Seite zur Verfügung und sie werden von IceFaces verwaltet.
Am deutlichsten wird dieses Konzept wahrscheinlich an einem simplen Beispiel.
Die Anwendungskonfigurationsdatei
Die Datei faces-config.xml ist die sogenannte Anwendungskonfigurationsdatei, in der - wie der Name schon sagt - unsere Anwendung konfiguriert wird. Wir werden die Möglichkeiten dieser Datei in
den nächsten Kapiteln näher unter die Lupe nehmen. In diesem Kapitel betrachten wie die Definition der Managed-Beans, die ebenfalls in der faces-config.xml erfolgt.
Diese Datei wird im Verzeichnis /WEB-INF gespeichert, also in dem Ordner, in dem sich auch die web.xml befindet. Folgendermaßen sieht das Grundgerüst einer faces-config.xml aus:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC
"-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
"http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
</faces-config>
In dem faces-config-Tag werden nun die anderen Angaben eingetragen, wie zum Beispiel die Definition der Managed-Beans. Nun wollen wir unsere BookBean einmal definieren und in der restlichen
Anwendung zur Verfügung stellen.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC
"-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
"http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
<managed-bean>
<managed-bean-name>bookBean</managed-bean-name>
<managed-bean-class>de.myOpac.beans.BookBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
</faces-config>
Zuerst geben Sie der Bean einen Namen, über den sie in der Anwendung angesprochen werden soll. Es gelten die üblichen Regeln für Variablennamen. Üblicherweise wird als Bean-Name der Klassenname
beginnend mit einem Kleinbuchstaben angegeben.
<managed-bean-name>bookBean</managed-bean-name>
Dann müssen Sie angeben, von welcher Klasse die Bean stammt. Der Klassenname zusammen mit seinem Package angegeben werden.
<managed-bean-class>de.myOpac.beans.BookBean</managed-bean-class>
Und schließlich geben Sie einen Gültigkeitsbereich an.
<managed-bean-scope>session</managed-bean-scope>
Als scope können angegeben werden:
- request: Der kleinstmögliche Bereich. Die Beans existieren nur während der Request-Verarbeitung im Server und werden anschließend sofort gelöscht.
- session: Die häufigste Variante. Die Bean bleibt während einer Arbeitssitzung, also einer Session erhalten. Wenn die Session geschlossen wird, wird die Bean gelöscht.
- application: Der größtmögliche Bereich. Die Bean ist während der gesamten Laufzeit des Servers gültig und wird erst gelöscht, wenn der Server beendet wird. Die Beans sind also global gültig
und nicht mehr für den einzelnen Benutzer.
- none: Die Beans werden überhaupt nicht dauerhaft gespeichert. Dies ist sinnvoll, wenn sie nur Grundlage für eine einzige Berechnung sein sollen.
Einer Bean können auch Initialisierungswerte mitgegeben werden. Dabei werden der Name der Eigenschaft und der Wert angegeben. Der Entwickler ist dafür verantwortlich, dass der angegebene Wert zu
dem Datentyp der Eigenschaft passt und dass die Getter- und Setter-Methoden korrekt sind. Über diese greift IceFaces nämlich auf die Werte zu.
Schauen wir uns mal einige Initalisierungswerte für unsere BookBean an:
<faces-config>
<managed-bean>
<managed-bean-name>bookBean</managed-bean-name>
<managed-bean-class>de.myOpac.beans.BookBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
<managed-property>
<property-name>title</property-name>
<value>Momo</value>
</managed-property>
<managed-property>
<property-name>author</property-name>
<value>Michael Ende</value>
</managed-property>
<managed-property>
<property-name>pages</property-name>
<value>304</value>
</managed-property>
</managed-bean>
</faces-config>
Definiert werden Initialisierungswerte mit Hilfe von <managed-properties>. Mit <properties-name> wird der Name des Attributs angegeben, mit <value> der Wert. Bei Fehlern wird eine
Laufzeit-Exception ausgeworfen, zum Beispiel:
javax.servlet.jsp.JspException: javax.faces.el.EvaluationException: javax.faces.FacesException: javax.faces.FacesException: Eigenschaft für verwaltete Bean kann nicht gesetzt werden: 'titel'.
Dieser Fehler ist schnell behoben: Einfach den Namen der Property in der faces-config.xml korrigieren.
Wenn an der Anwendungskonfigurationsdatei Änderungen vorgenommen werden, werden diese erst nach einem Neustart des Servers wirksam, weil die Datei nur beim Start geladen wird.
Verwenden einer Managed-Bean
Nun wollen wir uns einmal ansehen, wie die Managed-Beans an einen einfachen Beispiel in einer JSF-Seite verwendet werden können. Im folgenden Beispiel sollen einfach nur Titel, Autor und
Seitenanzahl auf dem Bildschirm angezeigt werden. Dabei werden erst einmal nur die Initialisierungswerte angezeigt.
<?xml version="1.0" encoding="ISO-8859-1" ?>
<jsp:root version="1.2"
xmlns:jsp="http://java.sun.com/JSP/Page"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:ice="http://www.icesoft.com/icefaces/component">
<jsp:directive.page contentType="text/html;charset=ISO-8859-1" pageEncoding="ISO-8859-1"/>
<f:view>
<ice:outputDeclaration doctypeRoot="HTML" doctypePublic="-//W3C//DTD HTML 4.01 Transitional//EN" doctypeSystem="http://www.w3.org/TR/html4/loose.dtd"/>
<html>
<head>
<title><ice:outputText value="Beispiel zum Managed-Beans" /></title>
</head>
<body>
<ice:form partialSubmit="true" >
<ice:outputText value="#{bookBean.title}" />
<br/>
<ice:outputText value="#{bookBean.author}" />
<br/>
<ice:outputText value="#{bookBean.pages}" />
<ice:messages />
</ice:form>
</body>
</html>
</f:view>
</jsp:root>
Wir haben auf dieser Seite drei Ausgabetext, wie wir sie bereits kennen. Aber in dem Attribut
value sehen wir eine Syntax, die uns noch nciht begegnet ist. Hier wird die sogenannte
expression language (EL) angewendet.
<ice:outputText value="#{bookBean.title}" />
Die Raute leitet den Zugriff auf eine Managed-Bean ein. Dann folgen geschweifte Klammern, in der angegeben wird, auf welches Attribut wir zugreifen wollen. Die Notation ist genau so, wie wir sie
von Java gewöhnt sind. Der Variablenname ist dabei der Name der Bean, wie wir ihn in der faces-config.xml angegeben haben. Die Bean muss für das jeweilige Attribut Getter- und Settermethoden
enthalten, denn über diese greift IceFaces auf die Eigenschaft zu.
Die obige Anweisung bedeutet also nicht anderes als
value="#{bookBean.getTitle}".
Es ist natürlich auch möglich, ein Attribut in der Bean zu deklarieren, das wiederum das Objekt einer Klasse ist. Nehmen wir einmal an, wir würden eine Klasse Person deklarieren, die die Attribute
name und
address besitzt. Das Attribut
author ist nun kein String mehr, sondern ein Objekt der Klasse
Person.
Hier das Attribut und die entsprechenden Getter und Setter:
private Person author;
Person getAuthor() {
return author;
}
void setAuthor(Person author) {
this.author = author;
}
Von einer jspx-Seite aus wird nun folgendermaßen auf den Namen des Autors zugegriffen:
value="#{bookBean.author.name}".
Dies ist gleichbedeutend mit
value="#{bookBean.getAuthor.getName}". Es ist selbstverständlich, dass die Klassen BookBean und Person beide entsprechende Getter und Setter benötigen. Eclipse
erstellt die Getter und Setter bekanntlich selbstständig, so dass man damit keine weitere Arbeit hat.
Wenn Sie den Server nun starten und die Seite öffnen, werden die zuvor als Initialisierungswerte angegebenen Werte auf der Seite angezeigt.
Beans können nun mit allen Komponenten von IceFaces verbunden werden. In den nächsten Kapiteln werde ich viele Beispiele zeigen, wie man die Beans mit verschiedenen Komponenten verwendet.
Managed-Beans mit dem IceFaces-Plugin für Eclipse
Das IceFaces-Plugin nimmt dem Entwickler einige Arbeit bei der Definition von Managed-Beans ab. Öffnen Sie die faces-config.xml, wenn das IceFaces-Plugin installiert ist, wird ein grafischer
Editor geöffnet, den ich kurz vorstellen möchte.
Es erscheint ein Begrüßungsbildschirm, den Sie sich ansehen können - oder auch nicht. Klicken Sie auf "ManagedBean".
Hier werden die Managed-Beans angezeigt (1). Neue Beans können einfach hinzugefügt werden (2).
Sie können nun eine existierende Javaklasse eingeben (1) oder eine neue Javaklasse erstellen (2). Anschließend geht's weiter (3).
Geben Sie einen Namen für die Bean ein (1). Standardmäßig wird der Klassenname beginnend mit einem Kleinbuchstaben eingetragen. Wählen Sie nun einen Gültigkeitsbereich aus (2). Beschreibung der
Gültigkeitsbereiche finden Sie oben.
Am Ende erhalten Sie eine Zusammenfassung.
Aber der Editor enthält noch weitere Möglichkeiten.
Wenn Sie eine ManagedBean anklicken, können Sie die Daten der Bean ändern (1), Initialisierungswerte vergeben (2) oder die Bean löschen.
Ice Faces Tutorial Teil 2 - Das Eclipse-Plugin
