Eine neue (alte) Welt: JSF
Java • 19. November 2025 • Lesezeit: 7 Minuten
Wenn man zum ersten Mal mit Jakarta Server Faces (JSF) arbeitet, wirkt vieles zunächst etwas „magisch“. Plötzlich erscheinen Daten im Browser, ohne dass man genau weiß, wie sie dorthin kommen. Doch wenn man einmal verstanden hat, wie JSF im Hintergrund arbeitet, wird schnell klar, dass es sich um ein mächtiges Framework handelt, das die Entwicklung von serverseitigen Webanwendungen in Java stark vereinfacht. In diesem Beitrag schauen wir uns die Grundlagen von JSF an, verstehen den Lebenszyklus und lernen, wie man einfache Seiten mit Eingabeformularen und Ausgaben erstellt.
Was ist JSF eigentlich?
JSF ist ein serverseitiges Webframework, das auf dem Jakarta EE Stack aufbaut. Es bietet eine komponentenbasierte Architektur – das heißt, du arbeitest nicht direkt mit HTML, sondern mit Java-Komponenten, die daraus HTML generieren. Im Gegensatz zu reinen Frontend-Frameworks wie React oder Vue.js liegt bei JSF der Fokus klar auf der serverseitigen Verarbeitung und Zustandsverwaltung.
Die Standarddatei für eine JSF-Seite ist eine .xhtml-Datei. Sie kombiniert HTML mit speziellen JSF-Tags, die über XML-Namensräume eingebunden werden. Die zugehörige Logik befindet sich in sogenannten „BackBeans“ – also Java-Klassen, die per Annotation mit der Oberfläche verbunden sind.
Ein erstes Beispiel
Sehen wir uns direkt ein einfaches Beispiel an. Eine Seite, die den Benutzer begrüßt:
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>Hallo JSF</title>
</h:head>
<h:body>
<h:form>
<h:outputText value="Bitte gib deinen Namen ein:" /><br />
<h:inputText value="#{helloBean.name}" /><br />
<h:commandButton value="Sagen Sie Hallo" action="#{helloBean.sayHello}" />
<h:outputText value="#{helloBean.message}" style="display:block;margin-top:10px;"/>
</h:form>
</h:body>
</html>
Die zugehörige Bean könnte so aussehen:
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
@Named
@RequestScoped
public class HelloBean {
private String name;
private String message;
public void sayHello() {
if (name == null || name.isEmpty()) {
message = "Bitte gib einen Namen ein.";
} else {
message = "Hallo " + name + "!";
}
}
// Getter und Setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getMessage() {
return message;
}
}
Ausgabe im Browser:
Bitte gib deinen Namen ein: [__________] [Sagen Sie Hallo] Eingabe: Peter Klick auf Button -> Ausgabe: Hallo Peter!
Das ist bereits ein vollständiges JSF-Beispiel. Die Seite zeigt ein Eingabefeld und einen Button. Beim Klick auf den Button wird die Methode sayHello() in der Bean ausgeführt. JSF sorgt automatisch dafür, dass der eingegebene Text im Feld an das Attribut name gebunden wird. Nach der Verarbeitung wird die Seite erneut gerendert, und die Ausgabe wird im Browser angezeigt.
Wie funktioniert die Bindung?
JSF verwendet eine bidirektionale Datenbindung: Das bedeutet, Werte werden automatisch zwischen Oberfläche und Bean hin- und hergereicht. Wenn du also in <h:inputText value="#{helloBean.name}" /> etwas eingibst, landet der Wert nach dem Absenden des Formulars direkt im Java-Objekt.
Dieser Mechanismus funktioniert über den sogenannten „JSF-Lebenszyklus“. Der Ablauf ist vereinfacht so:
1. Die Seite wird gerendert – JSF erzeugt HTML.
2. Der Benutzer interagiert (z. B. gibt Text ein, klickt auf einen Button).
3. JSF überträgt die Werte an die Bean, führt die Action aus und rendert die Seite erneut.
Als Entwickler musst du dich also nicht um die Verarbeitung der Request-Parameter kümmern – JSF erledigt das für dich.
Etwas mehr Dynamik – Berechnungen
JSF eignet sich auch wunderbar, um einfache Berechnungen oder Formularlogiken umzusetzen. Hier ein Beispiel, das zwei Zahlen addiert:
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>JSF Rechner</title>
</h:head>
<h:body>
<h:form>
<h:panelGrid columns="2" cellpadding="5">
<h:outputLabel value="Zahl 1:" />
<h:inputText value="#{calcBean.number1}" />
<h:outputLabel value="Zahl 2:" />
<h:inputText value="#{calcBean.number2}" />
<h:commandButton value="Berechnen" action="#{calcBean.calculate}" />
</h:panelGrid>
<h:outputText value="Ergebnis: #{calcBean.result}" style="display:block;margin-top:10px;"/>
</h:form>
</h:body>
</html>
Die Java-Bean dazu:
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
@Named
@RequestScoped
public class CalcBean {
private double number1;
private double number2;
private double result;
public void calculate() {
result = number1 + number2;
}
// Getter und Setter
public double getNumber1() {
return number1;
}
public void setNumber1(double number1) {
this.number1 = number1;
}
public double getNumber2() {
return number2;
}
public void setNumber2(double number2) {
this.number2 = number2;
}
public double getResult() {
return result;
}
}
Ausgabe im Browser:
Zahl 1: [10] Zahl 2: [15] [Klick auf Berechnen] Ergebnis: 25.0
Dieses Beispiel zeigt gut, wie einfach JSF serverseitige Logik abbilden kann. Nach dem Klick auf den Button wird die calculate()-Methode aufgerufen, und das Ergebnis erscheint direkt auf der Seite. JSF kümmert sich wieder automatisch um den Datenaustausch.
Ein kurzer Blick auf Managed Beans und Scopes
Jede Bean kann einen bestimmten Scope haben, also eine Lebensdauer. Im Beispiel oben wurde @RequestScoped verwendet – das bedeutet, die Bean lebt nur für eine einzelne Anfrage. Klickt der Benutzer erneut auf den Button, wird eine neue Bean-Instanz erzeugt.
Alternativ gibt es etwa @SessionScoped (die Bean lebt so lange wie die Benutzersitzung) oder @ViewScoped (lebt, solange die Seite aktiv ist). Diese Scopes helfen, den Zustand der Anwendung gezielt zu steuern.
Fazit
JSF ist zwar kein modernes Frontend-Framework, aber es bleibt ein stabiles, bewährtes Werkzeug für Unternehmensanwendungen. Gerade für Einsteiger, die Java kennen und Webentwicklung lernen wollen, ist JSF ein hervorragender Einstieg, um zu verstehen, wie serverseitige UI-Komponenten funktionieren und wie Daten zwischen Oberfläche und Logik ausgetauscht werden. Es zwingt dich zu einer klaren Trennung von Präsentation und Logik – etwas, das später in jeder Architektur entscheidend ist.
Wenn du JSF im Zusammenspiel mit PrimeFaces verwendest, eröffnen sich noch viel mehr Möglichkeiten - von Tabellen über Dialoge bis hin zu Ajax-Interaktionen. Doch das ist ein Thema für einen späteren Beitrag.
Für den Anfang gilt: Wenn du verstehst, wie value und action in JSF zusammenspielen, hast du schon den wichtigsten Teil gemeistert.
Suchen
Kategorien
Support
Weitere Informationen, wie du mich und meine Arbeit unterstützen kannst, findest du hier.