se Servlets und Java Server Pages
Werbung
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Java: Kapitel 10
Einführung in die Java Platform,
Enterprise Edition (Java EE):
Servlets und Java Server Pages
Programmentwicklung WS 2009/2010
Holger Röder
holger.roeder@informatik.uni-stuttgart.de
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Überblick über Kapitel 10
Überblick über die Java EE
Statische und dynamische Web-Seiten, HTTP GET und POST
Servlets
Parameterzugriff
Deployment von Web-Anwendungen
Request- und Response-Objekte
Cookies
Sitzungen
Java Server Pages (JSP)
Bestandteile von JSPs
Integration von Servlets und JSPs
2
© Holger Röder
Die Java Platform, Enterprise Edition (Java EE; früher J2EE) ist eine
Entwicklungsplattform für serverbasierte Java-Anwendungen.
Java EE sieht ein verteiltes, mehrschichtiges und komponentenbasiertes
Architekturmodell vor.
Java EE ist insbesondere gut geeignet als Entwicklungsplattform für WebAnwendungen.
Programmentwicklung
Winter 2009/2010
Überblick über die Java EE
se
3
© Holger Röder
Programmentwicklung
Winter 2009/2010
Java EE Application Model
se
Quelle: Sun Microsystems
4
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Java EE Server – Infrastruktur
Ein Java EE Application Server wird als Laufzeitumgebung für Java EEKomponenten benötigt. Der Application Server stellt (häufig benötigte)
Infrastruktur-Dienste für die eigentliche Anwendung bereit, z. B.
Lebenszyklus-Verwaltung
Sicherheit, Persistenz, Transaktionsverwaltung,
Namens-/Verzeichnisdienste
Kommunikation zwischen Komponenten
Application Server umfassen meist zwei (logisch getrennte) Container:
Web Container: Laufzeitumgebung für Java Server Pages und
Servlets
EJB Container: Laufzeitumgebung für Enterprise Java Beans
Am Markt sind viele verschiedene Java EE Application Server verfügbar
Vollständige Application Server: Sun Java System Application
Server, IBM Websphere, Oracle, BEA WebLogic, JBoss etc.
Nur Web Container: Apache Tomcat, Jetty etc.
5
© Holger Röder
Apache Tomcat ist ein frei verfügbarer Web Container:
Unterstützung für Servlets und JSPs
Integrierter HTTP-Server
Komplett in Java geschrieben, Open Source
http://tomcat.apache.org/
Programmentwicklung
Winter 2009/2010
Web-Container: Beispiel Apache Tomcat
se
6
© Holger Röder
Winter 2009/2010
Statische vs. dynamische Web-Seiten
Klassische statische Web-Seiten:
Alle Dokumente (z. B. HTML-Seiten, Grafiken) sind statisch und
werden vom Web-Server an den Client (Web-Browser) übermittelt.
HTTP Request
<html>
<title>
...
HTTP Response
Web-Browser
Benutzer
Programmentwicklung
Web-Server
se
7
© Holger Röder
Winter 2009/2010
Statische vs. dynamische Web-Seiten (2)
Dynamische Web-Seiten:
Statisch vorliegende Dokumente (z. B. Grafiken) werden vom WebServer direkt zurückgeliefert.
Dynamische Web-Seiten werden im Web Container (des Application
Servers) bei jeder Anfrage dynamisch erzeugt
HTTP Request
<html>
<title>
...
HTTP Response
Programmentwicklung
Web-Server
se
HTTP Request:
Parameter
Application Server,
Web Container
Servlet
oder JSP
Web-Browser
Benutzer
HTTP Response:
Dynamischer
Inhalt
Datenzugriff
Datenbank
8
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Java Servlets – Überblick
Mit Hilfe der Java Servlet API können dynamische Web-Seiten
implementiert werden.
Servlets sind Java-Objekte, deren Klasse das Interface
javax.servlet.Servlet implementiert.
Servlets werden innerhalb eines Web Containers ausgeführt. Der Web
Container übernimmt das Lebenszyklus-Management des Servlets
(Instanziierung, Aufruf, Zerstörung).
Servlets können prinzipiell beliebige Arten von Anfragen beantworten, die
an den Server gestellt werden (Request-Response-Prinzip).
In der Praxis wird in den meisten Fällen die abstrakte Basisklasse
HttpServlet verwendet. Ein HttpServlet beantwortet HTTPAnfragen, die z. B. durch einen Web-Browser gestellt werden.
Servlets bekommen vom Client Parameter im Request-Objekt
übergeben.
Servlets erzeugen meistens HTML-Code, der als Antwort im
Response-Objekt an den Client zurückgeliefert wird.
9
© Holger Röder
Winter 2009/2010
Request-Response-Prinzip
Der Web-Browser sendet einen Request (mit
Parametern) an den Web Container.
Der Web Container ruft das Servlet auf und
übergibt den Request.
Request
Web
Container
Programmentwicklung
Servlet
se
Geschäftslogik
(in „StandardJava“
implementiert)
Response
Das Servlet erstellt dynamisch die Folgeseite und
liefert diese an den Web-Browser zurück.
10
© Holger Röder
Winter 2009/2010
Aufgaben des Servlets
Request
„Aufgabe 1“
Durchführung der im Request angeforderten Tätigkeiten
Geschäftslogik anwenden, Daten speichern etc.
Programmentwicklung
Dynamische Erzeugung des Antwortdokuments
Meistens HTML, Rückgabe über Response-Objekt
se
„Aufgabe 2“
Response
11
© Holger Röder
Wichtig: Java EE ist nur eine
Spezifikation. Die eigentliche
Implementierung der Klassen ist
Teil des Application Servers.
Programmentwicklung
Winter 2009/2010
Servlet-Hierarchie
se
12
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Servlet-Lebenszyklus
Als Laufzeitumgebung ist der Web Container ist für das LebenszyklusManagement der Servlets verantwortlich.
Bei der ersten Anfrage wird das Servlet zunächst geladen und initialisiert
Aufruf der Methode init() des Servlets
Alle Anfragen werden an die Servlet-Instanz weitergegeben
Generisch (in der Schnittstelle Servlet definiert):
service(ServletRequest req, ServletResponse res)
Vereinfachung für HTTP-Anfragen (in HttpServlet definiert):
doGet(HttpServletRequest req,
HttpServletResponse resp)
doPost(HttpServletRequest req,
HttpServletResponse resp)
Wird der Server oder das Servlet gestoppt, entfernt der Web Container die
Servlet-Instanz.
Aufruf der Methode destroy() des Servlets
13
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
GET- und POST-Anfragen
HTTP unterstützt verschiedene Request-Methoden: die Methoden GET
und POST kommen am häufigsten zum Einsatz.
GET-Anfragen:
Parameter werden als Teil der URL übergeben:
http://localhost/helloWorld?name=carl&uni=stuttgart
Bearbeitung in der Methode doGet() des Servlets
POST-Anfragen:
Parameter werden als separater Teil der Requests übergeben, sind
nicht Teil der URL
Einsatz bei Formularen, allgemein bei größeren Datenmengen und
Binärdaten
Bearbeitung in der Methode doPost() des Servlets
14
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Beispiel: „Hello World“ als Java Servlet
public class HelloWorldServlet extends HttpServlet {
@Override
public void init() throws ServletException {
super.init();
// Eigene Initialisierung ...
}
}
Eigenes Servlet auf
Basis von
HttpServlet
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
Zugriff auf Responsethrows ServletException, IOException {
Objekt
PrintWriter out = response.getWriter();
HTML-Code, der als Antwort an
out.println("<html><body>");
den Browser geschickt wird
out.println("Hallo Welt!<br />");
out.format ("Heute ist der %1$te. %1$tB!", new Date());
out.println("</body></html>");
out.close();
“Geschäftslogik”: Aufruf
}
beliebiger Java-Objekte
15
Aufruf des Servlets im Web-Browser: http://localhost:8080/
HelloWorld/HelloWorldServlet
Programmentwicklung
Winter 2009/2010
© Holger Röder
Beispiel: „Hello World“ als Java Servlet (2)
se
Zuvor muss der Web Container entsprechend konfiguriert und das Servlet
im Web Container installiert werden.
16
© Holger Röder
Das Installieren einer Java EE Web-Anwendung in einem Web Container
wird als Deployment bezeichnet.
Eine Web-Anwendung kann Servlets, Java Server Pages, statische
HTML-Seiten, Grafiken etc. umfassen.
Zusätzlich wird eine Konfigurationsdatei benötigt (web.xml).
Die XML-Konfigurationsdatei wird als Deployment Descriptor bezeichnet.
Sie enthält Informationen über die Web-Anwendung, die der Application
Server für die Einbindung benötigt.
Web-Anwendungen werden häufig als einzelnes Archiv (WAR, Web
Application aRchive) ausgeliefert.
Programmentwicklung
Winter 2009/2010
Deployment von Web-Anwendungen
se
17
© Holger Röder
Deployment Descriptor
Beispiel: Auschnitt aus einer Konfigurationsdatei web.xml
Programmentwicklung
Winter 2009/2010
web.xml
se
<web-app id="HelloWorldServlet" ...>
<display-name>
HelloWorld</display-name>
<servlet>
<servlet-name>HelloWorldServlet</servlet-name>
<servlet-class>pe.HelloWorldServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorldServlet</servlet-name>
<url-pattern>/HelloWorldServlet</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
18
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Deployment aus Eclipse
Das Eclipse Web Tools Platform Project erleichtert die Entwicklung von
JEE-Anwendungen in Eclipse.
Das Deployment von Web-Anwendungen und die Kontrolle des
Application Servers ist auf diese Weise bequem aus Eclipse heraus
möglich.
http://www.eclipse.org/webtools/
19
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Auswertung von HTML-Formularen
HTML-Formulare werden zur Dateneingabe auf Web-Seiten verwendet.
<html>
Request-Methode POST
<body>
<form action="HelloWorldServlet" method ="post">
Eingabe:
<input type="text" name="eingabe" />
<br /><br />
Ausgabe: <!-- Hier steht die Ausgabe -->
<br /><br />
<input type="submit"
value="Text spiegeln" />
</form>
</body>
</html>
Der Inhalt der Eingabefelder wird häufig
per POST-Request an den Server übertragen.
20
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Auswertung von HTML-Formularen (2)
Die Bearbeitung im Servlet erfolgt in der Methode doPost().
Auf die mitgeschickten Parameter (Formularinhalte) kann über das
Request-Objekt zugegriffen werden.
...
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
Auslesen des HTMLthrows ServletException, IOException {
Parameters eingabe
PrintWriter out = response.getWriter();
String eingabe = request.getParameter("eingabe");
String html = erzeugeHtml(eingabe); /* Hilfsmethode */
out.println(html);
out.close();
}
...
21
se
Programmentwicklung
Winter 2009/2010
© Holger Röder
Anfrage-Objekte: ServletRequest
22
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
HttpServletRequest
Die Schnittstelle HttpServletRequest repräsentiert eine HTTPAnfrage.
Verschiedene Methoden bieten Zugriff auf die Bestandteile der Anfrage,
z. B.
String getQueryString(): liefert den Query String, der nach
dem Aufrufpfad folgt (bei GET-Anfragen: Parameterliste).
Enumeration getParameterNames(): liefert die Namen aller
Parameter
String getParameter(String): liefert den Wert des
angegebenen Parameters
String[] getParameterValues(String): liefert alle Werte des
angegebenen Parameters
Auch Informationen über den aufrufenden Client können ermittelt werden,
z. B.
String getRemoteAddr(): liefert die IP-Adresse des Clients
String getRemoteHost(): liefert den Hostnamen des Clients
23
© Holger Röder
Beispiel: Aufruf der folgenden URL im Web-Browser http://
localhost/ServletTest/MeinServlet?p1=AB&p2=2007
String s1 = req.getRemoteAddr();
// 127.0.0.1
String s2 = req.getQueryString();
// p1=AB&p2=2007
String s3 = req.getParameter("p2");
// 2007
Enumeration params = req.getParameterNames(); // p1, p2
...
Programmentwicklung
Winter 2009/2010
HttpServletRequest (2)
se
24
se
Programmentwicklung
Winter 2009/2010
© Holger Röder
Antwort-Objekte: ServletResponse
25
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
HttpServletResponse
Die Schnittstelle HttpServletResponse repräsentiert eine Antwort des
Servlets auf eine HTTP-Anfrage.
Die Methode getWriter() liefert ein PrintWriter-Objekt zurück, über
das Text (z. B. HTML-Code) als Antwort zurückgeliefert werden kann.
PrintWriter out = response.getWriter();
out.println("<html><body> Hallo Welt! </body></html>");
...
Sollen Binärdaten zurückgeliefert werden (z. B. dynamisch erzeugte
Grafiken), kann ServletOutputStream getOutputStream()
verwendet werden.
Weitere Methoden:
sendRedirect(String): leitet die Anfrage um
setHeader(String, String): setzt einen HTTP-Header
26
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
HTTP-Cookies
Einfache Daten können vom Server als sogenanntes Cookie auf dem
Client gespeichert werden.
Bei jeder Anfrage sendet der Web-Browser die für diesen Server (bzw.
Pfad) gespeicherten Cookies mit.
Die „Nutzlast“ eines Cookies besteht im Wesentlichen aus einem NameWert-Paar.
Beispiele: userId=carlcoder, lastVisit=20070105-102334
Zusätzlich werden für jedes Cookie weitere Informationen gespeichert,
etwa der zugehörige Server, der zugehörige Pfad und das maximale Alter
des Cookies.
Cookies werden häufig zur (Wieder-)Erkennung des Clients oder für das
Sitzungsmanagement eingesetzt.
27
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Die Klasse Cookie – Cookies auslesen
Die Klasse Cookie im Paket javax.servlet.http bietet
Unterstützung bei der Verwendung von Cookies.
Alle vom Client mitgeschickten Cookies können über die Methode Cookie
[] getCookies() des Request-Objekts ermittelt werden. Die in den
einzelnen Cookies gespeicherten Daten können über dann über
entsprechende Methoden (getName(), getValue() etc.) ausgelesen
werden.
PrintWriter out = response.getWriter();
if (request.getCookies() != null) {
/* Cookies mitgeschickt */
for (Cookie c : request.getCookies()) {
String cookieName = c.getName();
String cookieValue = c.getValue();
out.println(cookieName + " = " + cookieValue);
}
28
© Holger Röder
Winter 2009/2010
Die Klasse Cookie – Cookies schreiben
Der Konstruktor Cookie(String, String) erzeugt ein neues Cookie
mit dem angegebenen Name-Wert-Paar als Inhalt.
Die Eigenschaften des Cookies können über entsprechende Methoden
gesetzt werden (setMaxAge(), setDomain() etc.).
Über die Methode addCookie(Cookie) des Response-Objekts kann ein
Cookie zum Client gesendet werden.
Cookie c = new Cookie("lastVisit", "20070105-102334");
c.setMaxAge(24*60*60); /* Max. 1 Tag speichern */
Programmentwicklung
response.addCookie(c);
se
29
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Sitzungen
HTTP ist zustandslos, jede HTTP-Anfrage erfolgt unabhängig von
anderen Anfragen.
In vielen Fällen sollen aufeinanderfolgende Anfragen eines Clients
dennoch miteinander verknüpft und ein gemeinsamer Zustand über die
Anfragen hinweg bewahrt werden.
Eine solche Folge von zusammenhängenden Anfragen wird als Sitzung
(Session) bezeichnet. Die Servlet API bietet Unterstützung für die
Sitzungsverwaltung (Session Management).
Wichtig: Die technische Realisierung der Sitzungsverwaltung bleibt dem
Web Container überlassen (z. B. durch Cookies, durch URL-Encoding
etc.)
30
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
HttpSession
Die Klasse HttpSession repräsentiert eine Client-Sitzung.
Über die Methode getSession() des Request-Objekts kann das
HttpSession-Objekt für den anfragenden Client ermittelt werden.
In der Session können beliebige Objekte (Object) unter einem
eindeutigen Namen (String) gespeichert und ausgelesen werden.
// Objekt in Session speichern
HttpSession session = request.getSession();
Double summe = 14.99;
session.setAttribute("gesamtsumme", summe);
...
// Objekt aus Session auslesen
HttpSession session = request.getSession();
Double summe = (Double) session.getAttribute("gesamtsumme");
Die Sitzung wird nach einer festgelegten Zeitspanne, innerhalb der keine
Anfragen vom Client kommen, ungültig.
session.setMaxInactiveInterval(5*60); // max. 5min Inaktivität
...
session.invalidate(); // alternativ: Session sofort ungültig machen
31
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Java Server Pages
Die alleinige Verwendung von Java Servlets kann problematisch sein:
Präsentations- und Verarbeitungslogik werden vermischt.
HTML-Entwicklungswerkzeuge sind nicht verwendbar.
Java Server Pages (JSPs) können hier Abhilfe schaffen. JSPs sind für
den Einsatz als Web-Seiten konzipiert, die sowohl statische als auch
dynamische generierte Teile beinhalten.
Präsentations- und Verarbeitungslogik werden im Vergleich zu
normalen Servlets strikter getrennt.
Dynamische Inhalte werden über spezielle JSP Tags eingebunden.
Die fachliche Verarbeitung erfolgt in Komponenten (z. B. Java
Beans).
Technisch betrachtet sind auch JSPs Servlets: beim ersten Aufruf einer
JSP wird diese in ein Servlet übersetzt und kompiliert.
32
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
JSP-Beispiel
Normaler HTMLCode
JSP-page-Direktive
<%@ page ... %>
Java-Code,
eingeschlossen in <
% ... %> Tags
out und request
stehen als Objekte
direkt zur Verfügung
index.jsp
<%@ page language="java"
contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<html>
<head>
<title>Text spiegeln</title>
</head>
<body>
<form method ="post">
Eingabe:
<input type="text" name="eingabe" value="" />
<br /><br />
Ausgabe: <strong>
<%
String eingabe = request.getParameter("eingabe");
if (eingabe != null) {
String ausgabe = new StringBuilder(eingabe)
.reverse().toString();
out.print(ausgabe);
}
%>
</strong>
<br /><br />
<input type="submit" value="Text spiegeln" />
</form><br />
</body>
</html>
33
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
JSPs und JavaBeans
JavaBeans werden in JSPs häufig für die fachliche Verarbeitungslogik
eingesetzt. Die Einbindung von JavaBeans erfolgt über den Tag
<jsp:useBean ... />
Lebensdauer (page,
request, session
application)
Java-Klassenname
...
<body>
<form method ="post">
<jsp:useBean id="reverseStringBean" class="ReverseStringBean" scope="session" />
<jsp:setProperty name="reverseStringBean"
property="string" value="<%= request.getParameter("eingabe") %>" />
Eingabe:
<input type="text" name="eingabe"
value="<jsp:getProperty name="reverseStringBean" property="string"/>" />
<br /><br />
Ausgabe: <strong>
<jsp:getProperty name="reverseStringBean" property="reverseString"/>
</strong>
<br /><br />
Zugriff auf die JavaBean
<input type="submit" value="Eingabe spiegeln" />
</form><br />
</body>
...
34
© Holger Röder
Winter 2009/2010
Programmentwicklung
JavaBeans
ReverseTextBean.java
public class ReverseStringBean {
String string = "";
public void setString(String s) {
if (s != null)
string = s;
}
public String getString() {
return string;
}
public String getReverseString() {
return new StringBuilder(string)
.reverse().toString();
}
}
se
JavaBeans sind „normale“ JavaKlassen
Auf bestimmte Eigenschaften
(Properties) der JavaBean kann
aus der JSP heraus zugegriffen
werden.
In der JavaBean-Klasse existieren
setX(...) und/oder getX()Methoden für die Property X
Der Zugriff in der JSP erfolgt über
die JSP-Tags
<jsp:setProperty> und
<jsp:getProperty>
35
© Holger Röder
Die Properties einer JavaBean können fest mit den im Request-Objekt
gespeicherten Parametern verknüpft werden.
...
<jsp:setProperty name="reverseStringBean" property="*" />
...
Mit * werden alle Properties mit gleichnamigen Parametern verknüpft;
alternativ können auch einzelne Parameter angegeben werden.
Programmentwicklung
Winter 2009/2010
JSPs und JavaBeans (2)
se
36
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Wichtige JSP-Direktiven und -Tags
Include-Direktive
Syntax: <%@ include file="..." %>
Fügt (einmalig) vor dem Kompilieren der JSP den Inhalt einer Datei
ein
Include-Tag
Syntax: <jsp:include page="..." />
Fügt beim Aufruf der JSP den Inhalt der angegebenen statischen
oder dynamischen Ressource (z. B. JSP) ein
Forward-Tag
Syntax: <jsp:forward page="..." />
Leitet die Client-Anfrage an die angegebene HTML-Datei, JSP oder
das Servlet zur Verarbeitung weiter
37
© Holger Röder
Winter 2009/2010
JSP-Scripting: Deklarationen und Ausdrücke
JSPs können „normalen“ Java-Quellcode enthalten, der beim Aufruf der
JSP ausgeführt wird (Scripting).
Deklarationen:
Syntax: <%! ... %>
Deklaration von Variablen und Methoden (durch Semikolon
abgeschlossen)
Programmentwicklung
<%! int a = 17; %>
se
Ausdrücke:
Syntax: <%= ... %>
Beliebige gültige Ausdrücke sind zulässig (ohne abschließendes
Semikolon). Der jeweilige Ausdruck wird zur Laufzeit ausgewertet
und der resultierende Wert in einen String konvertiert.
a + b = <%= a + b %>
38
© Holger Röder
Winter 2009/2010
Scriptlets
Vollständige Java-Code-Blöcke in JSPs werden als Scriptlets bezeichnet.
Syntax: <% ... %>
<%
String eingabe = request.getParameter("eingabe");
if (eingabe != null) {
String ausgabe = new StringBuilder(eingabe)
.reverse().toString();
out.print(ausgabe);
}
Programmentwicklung
%>
se
39
© Holger Röder
Winter 2009/2010
Scriptlets: Implizite Variablen
Innerhalb von Scriptlets stehen verschiedene implizite Variablen zur
Verfügung, die ohne Deklaration verwendet werden können, z. B.
ServletRequest request
ServletResponse response
JspWriter out
HttpSession session
...
<%
out.println("Hallo Welt!");
Programmentwicklung
%>
se
40
© Holger Röder
Versteckte Kommentare (Hidden Comments)
Syntax: <%-- Kommentar --%>
Versteckte Kommentare können zur Dokumentation des JSP-Codes
verwendet werden. Sie werden von der JSP-Engine nicht verarbeitet
und deshalb auch nicht zum Client gesendet.
Ausgabe-Kommentare (Output Comments)
Syntax: <!-- Kommentar -->
Ausgabe-Kommentare sind normale HTML-Kommentare, die auch
im an den Client gesendeten HTML-Code enthalten sind.
Programmentwicklung
Winter 2009/2010
Kommentare
se
41
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Zusammenspiel von Servlets und JSPs
Das Servlet führt alle
Tätigkeiten aus, die durch
den Request angefordert
sind („Aufgabe 1“).
Die Darstellung wird an die
JSP delegiert.
Die JSP implementiert die
Darstellung der Folgeseite
(„Aufgabe 2“).
Die für die Darstellung
benötigten Daten werden
aus dem Request-Objekt
oder über JavaBeans
geholt, die ihrerseits auf
die Geschäftslogik
zugreifen.
Request
Web
Container
Servlet
Geschäftslogik
JSP
JavaBeans
Response
42
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Datenübergabe Servlet JSP
Beide Technologien – Servlets und JSPs – können kombiniert werden:
Servlets: Bearbeitung der Anfragen (Geschäftslogik)
JSPs: Präsentation der Antworten
Übergabe von Daten vom Servlet an die JSP:
1. Der Web Container ruft bei einem ankommenden Request das
Servlet auf.
2. Das Servlet bearbeitet die Anfrage.
3. Ermittelte Ergebnisse werden als Attribute im Request-Objekt
gespeichert:
request.setAttribute("gesamtsumme", summeGesamt);
4. Mittels eines Dispatching-Mechanismus wird die JSP aufgerufen und
das Request-Objekt übergeben.
5. JSP liest das Attribut aus dem Request-Objekt aus:
Double summe = request.getAttribute("gesamtsumme");
6. JSP erzeugt dynamisch die HTML-Darstellung.
7. HTML-Seite wird an den Client zurückgeschickt.
43
© Holger Röder
Winter 2009/2010
Programmentwicklung
se
Dispatching-Mechanismen
Um innerhalb eines Servlets eine JSP aufzurufen, muss zunächst ein
RequestDispatcher-Objekt erzeugt werden.
RequestDispatcher dispatcher =
getServletContext().getRequestDispatcher("/MeineJSP.jsp");
Anschließend existieren zwei verschiedene Aufruf-Möglichkeiten:
include() bindet die JSP ein, anschließend fährt das Servlet mit
der Verarbeitung fort. include() kann mehrfach aufgerufen
werden.
dispatcher.include(request, response);
... // weitere Anweisungen
forward() übergibt die Kontrolle vollständig an die JSP. Das
Servlet ist anschließend in die Bearbeitung der Anfrage nicht mehr
eingebunden. forward() kann deshalb auch nur einmal aufgerufen
werden.
dispatcher.forward(request, response);
44
