Java Server Faces

Willemers Informatik-Ecke

Das einzig seriöse Javabuch :-) Mehr...

Bei Amazon bestellen
JEE-Literatur
2017-10-28
Java Server Faces (JSF) ist eine Java Enterprise-Technologie für das User-Interface. Java Server Faces verwendet Facelets, die auf der Basis von XHTML aufsetzen. Ein Facelet arbeitet immer im Zweiklang mit einer Backing Bean zusammen, die den Controller-Teil der Model-View-Controller-Architektur übernimmt.

Im Gegensatz zu Java Server Pages bettet JSF kein Java ein, sondern greift auf die Attribute seiner Backing Bean zu, die direkt durch die Eingabefelder eingegeben und ebenso direkt ausgegeben werden können. Ein manuelles Umsetzen wie bei Java Server Pages (JSP) ist also nicht erforderlich. Ebenso kann ein Facelet durch Buttons oder Links die Methoden der Backing Bean aufrufen. Für diese Zugriffe und Aufrufe definiert Java Server Faces eigene Tags.

JSF mit Eclipse erzeugen

Für das Nachvollziehen der JSF-Beispiele benötigen Sie eine Entwicklungsumgebung für JEE, die aus Eclipse-Version für JEE und einem Application-Server wie beispielsweise Glassfish besteht. Tomcat wird an dieser Stelle nicht empfohlen, da Tomcat Nachinstallationen benötigt, um Java Server Faces zu realisieren.

Das erste Beispiel ist eine JSF-Seite, die zwei Zahlen addieren soll.

Backing Bean

Bevor Sie eine JSF-Datei anlegen, sollten Sie eine Backing Bean erzeugen, da das Faclet auf dieser basiert.

CalcBackBean wird durch die Annotation @Named als Backing Bean gekennzeichnet.

Mit dem Scope wird die Gültigkeit der Bean beschrieben:

import javax.enterprise.context.RequestScoped;
import javax.inject.Named;

@Named
@RequestScoped
public class CalcBackBean {
    private int a;
    private int b;
    private int summe;
    public void setA(int a) {
        this.a = a;
    }
    public int getA() {
        return a;
    }
    public void setB(int b) {
        this.b = b;
    }
    public int getB() {
        return b;
    }
    public int getSumme() {
        return summe;
    }
    
    public String calc() {
        summe = a + b;
        return "/index.xhtml";
    }
}
Die Attribute a und b sind die Summanden. Sie müssen private sein. Für jedes Feld, das ausgegeben werden soll, muss ein Getter existieren. Alle Elemente, für die es ein Eingabefeld gibt, benötigen einen Getter und einen Setter.

Darüber hinaus wird eine Methode (hier calc) benötigt, die über den Button ausgelöst wird. Sie hat keinen Parameter, liefert aber als String die Seite zurück, zu der navigiert werden soll, nachdem die Aktion ausgeführt wurde.

Anlegen der JSF-Datei

In dem Projekt wird nun das Facelet als XHTML-Datei angelegt. Sie können unter Eclipse einen Web-Editor verwenden, der es ermöglicht, die Elemente per Drag & Drop zu setzen. Es entsteht der Rahmen einer XHMTL-Datei index.xhtml. Sie wird so angepasst, wie in dem folgenden Listing:
<?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://xmlns.jcp.org/jsf/html">
<h:head>
    <title><h:outputText value="Wir addieren" /></title>
</h:head>
<h:body>
    <h:form>
        <h:panelGrid columns="2">
            <h:outputText value="A = " />
            <h:inputText value="#{calcBackBean.a}">
            </h:inputText>
            <h:outputText value="B = " />
            <h:inputText value="#{calcBackBean.b}">
            </h:inputText>
            <h:outputText value="Summe = " />
            <h:outputText value="#{calcBackBean.summe}" />
            <h:outputText value="Los geht's" />
            <h:commandButton value="OK" action="#{calcBackBean.calc}" />
        </h:panelGrid>
    </h:form>
</h:body>
</html>
Sie können die XHTML-Datei mit der rechten Maustaste anklicken und mit Run As | Run on Server starten. Funktioniert das nicht, steht die XHTML-Datei eventuell nicht unter WebContent im Projekt.

Obwohl die Datei im Projekt als index.xhtl abgelegt ist, wird sie über den Browser als index.jsf angesprochen.

Spezielle JSF-Tags

Attribute benutzerdefinierter Tags werden in der Property der UI-Komponente deklariert. Um die Tags, die mit h: beginnen aufzulösen, muss die Definition xmlns:h="http://xmlns.jcp.org/jsf/html" in das html-Tag eingebunden sein. Mit <h: beginnende Tags bilden HTML-Elemente nach.

Der Zugriff von Facelets auf ihre Backing Bean

JSF leiten den Zugriff auf Elemente durch ein Doppelkreuz (Lattenzaun, Raute) ein und umschließen sie mit geschweiften Klammern.

Inject von Attributen

Bei Attributen, die komplexer sind als zwei zu addierende Zahlen, wird man eine Klasse verwenden, die per CDI in die Backing Bean injected wird.
import java.io.Serializable;

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;

@Named
@RequestScoped
public class KundenCtrl implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Inject
    private Kunde kunde;
    
    public Kunde getKunde() {
        return this.kunde;
    }
    public void setKunde(Kunde kunde) {
        this.kunde = kunde;
    }
    
    public String speicher() {
        System.out.println(kunde.getName());
        return "/antwort.xhtml";
    }
}

In der Klasse KundenCtrl wird per CDI das Objekt kunde der Klasse Kunde eingebunden, in der dann die Daten des Facelets automatisch abgelegt werden.

import javax.enterprise.context.Dependent;

@Dependent
public class Kunde {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
Die Annotation @Dependent sorgt dafür, dass der Scope der Bean, in die injected wird, übernommen wird. Die injected Bean sollte keinen weiteren Scope haben als die einbindende Bean.

Ein Formular eines Facelets hat dann etwa folgendes Aussehen

<h:form>
    <h:inputText value="#{kundenCtrl.kunde.name}" />
    <h:commandButton value="OK" action="#{kundenCtrl.speicher}" />
</h:form>

Zugriffe auf die HTTP-Umgebung

URL-Parameter auslesen

Über den Link können Werte auch bei GET-Kommandos übergeben werden. Beispiel:
<a href="index.xhtml?wert=42">Link mich!</a>
Eine JSF liest diesen Parameter über die Map param aus:
Die Antwort ist  #{param['wert']}

Sitzungsinformationen

Templating

JSF-Seiten sollten über die Anwendung hinweg gleichmäßig aussehen. Das unterstützt JSF durch Templating. Ein Template enthält Platzhalter für andere ein JSF-Dokumente. Jenes JSF-Dokument wiederum bezieht sich auf das Template, in das es eingebettet werden will.

JEE-Literatur

Alexander Salvanos Professionell entwickeln mit Java EE 7

Marcus Schießer, Martin Schmollinger: Workshop Java EE 7

Etwas abstrakter: Dirk Weil: Java EE 7: Enterprise-Anwendungsentwicklung leicht gemacht

Nicht JEE, sondern grundlegendes Java für Java-Anfänger: Arnold Willemer: Java

Links


Homepage (C) Copyright 2013, 2017 Arnold Willemer