Willemers Informatik Ecke: Java Server Pages JSP

Java Server Pages (JSP) ermöglicht die Einbettung von Java-Code in HTML-Seiten. Eine JSP-Seite wird auf einem Applicaton-Server wie Tomcat oder Glassfish ausgeführt.

Vergleichbar zu PHP wird der Java-Code in den HTML-Code eingebettet, auf dem Server ausgeführt und das Ergebnis als HTML-Code an den Client übertragen, so dass der Client die Java-Anteile gar nicht mehr zu sehen bekommt.

Im Gegensatz zu Javascript oder zu Java-Applets wird der Programmcode nicht auf dem Client, also im Browser ausgeführt, sondern auf dem Server.

Technisch basieren JSP-Seiten auf Servlets, sind aber spezialisiert und eingeschränkt auf Browser als Clients und HTML als Datenformat.

Einbettung von Java-Code in HTML

Java Server Pages sind HTML-Seiten mit Java-Code (vergleichbar PHP). Die Einbettung in HTML geschieht durch ein Tag mit Prozenten.

<% /* Hier steht Java-Code */ %>|

Zwischen den Tags wird Java gesprochen.

Request- und Response-Parameter

request: Übergabeparameter für die Anfrageumgebung

String str = request.getParameter("name");
RequestDispatcher dispatch =
             request.getRequestDispatcher("gastneu.jsp");
dispatch.forward(request, response);

response: Übergabeparameter für die Antwort an den Client.
```
response.sendRedirect("index.html");
```

Variablen

Die Variable out steht für einen Ausgabekanal vom Typ PrintWriter.

In Servlets würde die Variable über response.getWriter() ermittelt. Durch den Aufruf von out.print(varname) können Java-Variablen in die HTML-Ausgabe eingefügt werden.

<hr> <% out.print(javavar); %> <hr>

Die Ausgabe lässt sich noch weiter verkürzen, indem das Tag durch ein Gleichheitszeichen ergänzt wird.

<%= javavar %>

Die Variablen session und application können Daten über eine Sitzung oder sogar bis zum Herunterfahren des Servers speichern. Typischerweise werden die Daten als assoziative Attribute abgelegt, vergleichbar mit einer Map.

session: liefert den Zugriff auf die aktuelle Sitzung. Mit setAttribute und getAttribute können Objekte an die Session gebunden werden.
```
session.setAttribute("kunde", kunde);
// ...
Kunde kunde = (Kunde)session.getAttribute("kunde");
```
application: liefert den Zugang auf die Anwendung. Ein Servlet würde sie über getServletContext() ermitteln. Auch application ermöglicht die Verwendung von getAttribute und setAttribute. Sie bleiben hier allerdings für die Dauer der Anwendung und nicht nur der Sitzung.

Beispiel Anmeldung

Eine kleine Web-Anwendung soll als Beispiel dienen:

newuser.jsp: Eine Eingabemaske für User und Passwort. Das Passwort wird zwei Mal eingegeben. Sollte eine Nachricht für diese Sitzung bestehen, wird sie angezeigt.
register.jsp: Die Eingabefelder werden geprüft. Fehlt die Benutzerkennung oder sind die beiden Eingaben unterschiedlich, wird newuser.jsp aufgerufen. Andernfalls wird der Benutzer für die Session gespeichert und main.jsp aufgerufen.
main.jsp: Das soll für die Hauptseite stehen und diese begrüßt den Benutzer.

Erzeugen einer JSP-Seite in Eclipse

Zunächst benötigen Sie ein Projekt für den Application-Server (File|New Project|Web|Dynamic Web Project).

Das dynamische Web-Projekt mit der rechten Maustaste anklicken
Im Menü New|New JSP File oder New|Other|Web|JSP File anklicken
Den Dateinamen mit der Endung .jsp eingeben
Den Button Finish anklicken

Eclipse erzeugt einen HTML-Rahmen, der erst auf den zweiten Blick JSP-Spezifika enthält.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

</body>
</html>

Zwischen die body-Tags bauen wir die JSP-Seite.

newuser.jsp: Anmeldung

Im ersten Schritt wird geprüft, ob jemand in der Session eine Nachricht hinterlegt hat. Sie wird angezeigt und zurückgesetzt.

<body>
    <h1>Register per JSP:</h1>
    <%
        String msg = (String)session.getAttribute("msg");
    	if (msg!=null && !msg.isEmpty()) {
    		%>
    		<hr> <% out.print(msg); %> <hr>
    		<%
    	}
    	session.setAttribute("msg", "");
    %>
    <form action="register.jsp" method="post">
        <table>
            <tr>
                <td>Name</td>
                <td><input type="text" name="user"></td>
            </tr><tr>
                <td>Passwort</td>
                <td><input type="password" name="pw1"></td>
            </tr><tr>
                <td>Passwort wiederholen</td>
                <td><input type="password" name="pw2"></td>
            </tr><tr><td></td>
                <td><input type="submit"></td>
            </tr>
        </table>
    </form>

</body>

Das Formular für die Registrierung sendet die Daten per POST an register.jsp.

register.jsp: Auswertung der Registrierung

Die Datei register.jsp hat die Aufgabe, die Anmeldung zu prüfen.

Mit getParameter holt sie sich die Eingabeinhalte.

Sie prüft, ob der Benutzername leer ist oder ob die Passwörter nicht übereinstimmen. In diesem Fall wird die entsprechende Meldung in der Session hinterlegt und der Client zu newuser.jsp zurückgeschickt.

Ist alles gut, wird der Benutzer unter user in der Sitzung hinterlegt und main.jsp aufgerufen.

Die Seite benötigt keine Darstellung. Aus diesem Grund könnte man sie vielleicht sogar besser als Servlet implementieren.

<body>
    <%
        String name = request.getParameter("user");
        String pw1 = request.getParameter("pw1");
        String pw2 = request.getParameter("pw2");
        if (name.isEmpty()) {
            session.setAttribute("msg", "Kein Benutzer");
            response.sendRedirect("newuser.jsp");
        } else if (!pw1.equals(pw2)) {
            session.setAttribute("msg", "Passworteingabe nicht gleich");
            response.sendRedirect("newuser.jsp");
        } else {
            session.setAttribute("user", name);
            response.sendRedirect("main.jsp");
        }
        %>
</body>

main.jsp: Die Hauptseite

Die Hauptseite holt nun aus der Session den Benutzernamen und nutzt ihn für eine persönliche Ansprache.

<body>
<h1>Herzlich Willkommen</h1>

<% String user = (String)session.getAttribute("user"); %>

Hallo <% out.print(user); %>, schön Dich zu sehen.

</body>

Direktiven

Wird hinter der öffnenden JSP-Tag ein @-Zeichen gesetzt, spricht man von einer Direktive.

Das erstes Schlüsselwort der Direktive bezeichnet die Art der Direktiven. Dazu gehören page, include und taglib.

Page-Direktive

Page-Direktiven ermöglichen den Zugriff auf die HTTP-Header.

<%@ page language="Java" %>
<%@ page contentType="text/html" %>
<%@ page pageEncoding="UTF-8" %>

Page-Direktive für Java-Import

Java import-Anweisungen können nicht einfach zwischen die Standard-Prozent-Tags gesetzt werden. Das betrifft nicht nur eigene Klassen, sondern auch Standardbibliotheken.

<%@ page import="java.util.Enumeration" %>    
<%@ page import="mypackage.Myklasse" %>

Eigene Klassen müssen darüber hinaus in eigenen Packages abgelegt werden.

Include-Direktive

Webseiten-Fragmente können in einer eigenen Datei abgelegt werden. Sie bekommen standardmäßig die Endung .jspf.

Diese Fragmente kann von verschiedenen JSP-Seiten aus eingebunden werden, indem eine Include-Direktive verwendet wird:

<%@ include file="header.jspf" %>

Taglib-Direktive

Mit der Taglib-Direktive können die JSTL-Bibliotheken eingebunden werden. In der Anweisung wird die Bibliothek dazu einem Präfix zugeordnet, der später bei Aufruf verwendet wird.

Die Einbindung der Bibliotheken kann im Header stehen.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml"%>

Auf diese Weise wurde die Core-Bibliothek dem Prefix c und die XML-Bibliothek dem Prefix x zugeordnet.

Darüber hinaus gibt es noch die Bibliotheken fmt (Formatierung), funktions (String- und Array-Funktionen) und sql (Datenbankzugriffe).

Als Beispiel wird hier die Liste (kundenliste) von Kunden (kunde) als XML-String von einem REST-Server geholt und anschließend ausgewertet.

<c:import var="xmlStrg" url="http://localhost:8080/RestWar/app/kunde"/>
<x:parse xml="${xmlStrg}" var="output" />

<x:forEach select="$output/kundenliste/kunde" var="element">
    <x:out select="$element/id" />
    <x:out select="$element/name" />
</x:forEach>

Torsten Horn: JSP Custom Tags und Tag Libraries (Taglibs)

Java-Methoden in JSP

Wenn auf einer JSP-Seite eine Java-Methode benötigt wird, wird sie mit dem speziellen Tag-Paar <%! und %> umschlossen.

<%!
String gruss(String name) {
        return "Hallo " + name;
}
%>
...
<% String user = (String)session.getAttribute("user"); %>
<% out.print(gruss(user)); %>, schön Dich zu sehen.

Die Methode kann sowohl im Header als auch im Body der JSP-Seite angelegt werden.