Quattro Stagioni

Vorbei die Zeit der statischen Internetseiten. Nur diejenigen Unternehmen können sich am Markt behaupten, die in der Lage sind, innerhalb kürzester Zeit auf eine geänderte Nachfrage der Kunden durch ein entsprechendes Angebot im WWW zu reagieren. Der Point of Sale der Unternehmen sind vermehrt Online-Auktionen, virtuelle Buchläden und komplette Internetversandhäuser. Dazu müssen ständig sich ändernde Informationen und Geschäftsprozesse ‘up to date’ ins Internet.

Sun Microsystems hat die JavaServer Pages (JSP) für die Realisierung der Präsentationsschicht einer Webanwendung entwickelt. Sie integrieren Businesskomponenten und existierende Systeme elegant ins Web. Die JSP-Technik basiert auf dem Java-Servlet-API und dient im Wesentlichen zur einfachen Erzeugung von HTML- und XML-Ausgaben eines Webservers. Wie PHP, ASP oder Perl können Autoren direkt HTML oder XML mit einer Skriptsprache mischen. Natürlich hat sich Sun hier für Java entschieden, um so die Möglichkeiten der vorhandenen robusten und zahlreichen Java-APIs einzubringen.

Ein Entwicklerteam kann ausschließlich mit der Programmiersprache Java die Logik implementieren. Das Design kann dagegen weiterhin von einem HTML-Autor und Grafikern durchgeführt werden. Damit das Beste der HTML- und Java-Welt zusammenkommen kann, sind in den JSP einige Tags zur Verfügung gestellt, die es erleichtern, ohne eine einzige Zeile Java kleine und spätestens im dritten Teil dieses Tutorials auch große Anwendungen zu schreiben. Mit der JSP-Spezifikation 1.1 sind die Standard-Tags durch so genannte Taglibs sogar erweiterbar. Noch fehlt es zwar an einer Standard-Taglib für Feldprüfung, Ausgabeformatierung, for-, if- und switch-Anweisungen, aber dies soll die zurzeit in Arbeit befindliche Version 1.2 klären. Einzelne Hersteller (Allaire, Unify, BEA) sind heute schon in der Lage, Entsprechendes zu liefern. Teil 2 und 3 beschäftigen sich mit der Programmierung einer solchen Taglib. Bevor es ans JSP-‘Eingemachte’ geht, sei hier noch einmal auf die Unterschiede von komponenten- und seitenzentrierter Webanwendungsentwicklung eingegangen.

Geschäftsabläufe ins Web

Techniken wie Shellskripts, CGI/Perl, PHP oder ASP wurden schon entworfen und eingesetzt, als das Web in den Kinderschuhen steckte. Viele Unternehmen hatten noch nicht registriert, dass sie ihre Geschäftsabläufe und Informationen im Internet präsentieren müssen, um langfristig überleben zu können. Die wenigen dynamischen Seiten waren schnell in einer Skriptsprache direkt in die Webseite programmiert. Das seitenzentrierte Modell hat gegenüber anderen Modellen einen großen Vorteil - es ist einfach zu erlernen. Die Programmierung ist übersichtlich, und jeder ist schnell erfolgreich.

Heute stellt sich die Aufgabe für Entwickler nicht mehr so einfach dar. Ganze Geschäftsprozesse eines Unternehmens müssen durch das Web gefüllt, überwacht und gesteuert werden. Es entstehen große verteilte und skalierbare Anwendungen, die deutlich in ihrer Komplexität von der einfachen Formularerfassung der ersten Tage abweichen. Die Logik, die in einer Seite programmiert wird, müssen nun wieder verwendbare Komponenten eventuell durch EJB, RMI, CORBA oder Host-Services von verschiedenen Anwendungen aus gleichzeitig nutzen.

Es ist notwendig, die Präsentation von der Business- und Datenzugriffslogik zu trennen. So kann ein Entwicklungsteam die verschiedenartigen Techniken voneinander getrennt entwickeln und testen. In großen Unternehmen existieren meist schon riesige Anwendungen, deren Komponenten nicht einfach für eine weitere Anwendung neu entwickelt werden können. Webanwendungen werden ihre Komplexität stetig steigern, und die Limitierungen des seitenzentrierten Modells werden immer offensichtlicher.

Die Zeit ist gekommen, sich nach besseren Möglichkeiten umzusehen, um Webanwendungen auch in Zukunft schnell und stabil zur Verfügung stellen zu können. JavaBeans bieten für Java-Entwickler und die Werkzeugschmieden (IBM, Borland, Symantec/BEA, Oracle, Persistence, Sybase, Togethersoft et cetera) eine solche gemeinsame Basis. Ein Experte stellt die Anforderungen für Komponenten, die der Entwickler in entsprechend unabhängige JavaBeans umsetzen kann (siehe Abbildung 1). Java bietet eine umfassende Plattform für die Integration bestehender Systeme (J2EE). Damit sind die sonst langatmigen und aufhaltenden technischen Hindernisse einer Systemverbindung einfacher, wenn auch nicht trivial geworden. Eine JSP kann nun durch Zugang zu solchen JavaBeans dem Webdesigner die Chance geben, mächtige Funktionen im Web zu präsentieren, ohne sich mit den Details der Business- und Datenzugriffslogik herumzuplagen.

JSP-Engine übernimmt die Arbeit

Eine JSP ist eigentlich ein spezielles Servlet, das durch eine JSP-Engine erzeugt wird. Der Servlet-Container nimmt eine HTTP-Anfrage an und ermittelt anhand eines URL-Mapping, dass es sich um eine JavaServer Page handelt. Eine JSP-Engine wird aufgerufen und schaut in ihrer Verwaltung nach, ob vielleicht schon eine kompilierte aktuelle JSP für die Anfrage vorliegt. Falls nicht, lädt sie aus dem Dateisystem die entsprechende Seite und erzeugt ein Servlet (mittels Java-Sourcecode) daraus (siehe die JSP-1.1-Spezifikation). Anschließend übersetzt sie diesen Servlet-Source und lädt die resultierende Klasse mit einem ClassLoader. Abbildung 2 zeigt die Initialisierung einer JSP.

Sie erfolgt mit der Methode jspInit(). Hier können eigene Erweiterungen direkt durch Überschreiben der entsprechenden Methode in der eigenen JSP stattfinden. Solange sie bezüglich des generierten Servlet nicht verändert wurde, bearbeitet die Methode _jspService() jede Anfrage. Nach erfolgreicher Arbeit wird die Seite mit jspDestroy() von der bevorstehenden ‘Vernichtung’ informiert. Dies geschieht immer dann, wenn ein aktuellerer JSP-Source vorliegt oder der Servlet-Container bestimmt, ein oder alle Servlets runterzufahren.

Pizza Service Online, die erste

Ein Beispiel zur Demonstration des Gelernten darf natürlich nicht fehlen. Wie jeder weiss, handelt es sich bei des Programmierers liebster Speise um die Pizza. Deshalb soll hier ein Pizza Service Online als durchgehendes Beispiel dienen.

Da der Schwerpunkt dieses Teils auf den Grundlagen der JSP liegt, sind die Funktionen und das Pizza-Angebot des Online-Services zunächst bewusst gering gehalten. Es soll ja schließlich noch Potenzial für Verbesserungen übrig bleiben. Auch auf sonst übliche Programmiertechniken wie Exception Handling und Eingabeprüfungen wird an einigen Stellen aus Gründen der Übersichtlichkeit verzichtet.

Nach einer Begrüßungsseite gelangt der Kunde direkt zur Online-Bestellung. Neben einer Basis-Pizza kann er auf dieser Webseite zusätzlich beliebig viele Zutaten bestellen. Anschließend kann der Kunde die zu beliefernde Adresse eingeben, damit der Service weiß, an wen er die virtuelle Pizza via Internet versenden soll. Eine Bestätigung über seine Bestellung erhält der Kunde natürlich auch. Wie das im Einzelnen aussieht, zeigen die folgenden Abbildungen.

Im ersten Teil können Kunden pro Bestellung jeweils nur eine Pizza angeben. Und auch auf Getränke müssen sie zunächst verzichten. Ein hungriger Leser wird übrigens schnell feststellen, dass neben diesen beiden Punkten noch einige weitere Ansätze für Verbesserungen existieren. So muss er für jede Bestellung die Lieferadresse erneut eingeben und fehlerhafte Eingaben werden ignoriert. All diese Aspekte sind Bestandteil des zweiten Artikels und wurden hier deshalb zunächst vernachlässigt.

Mit der Syntax anfangen

Zunächst stellt sich natürlich die Frage, wie eine JSP überhaupt aufgerufen werden kann. Ein Webserver kann sie nur dann verarbeiten, wenn eine entsprechende Engine vorhanden ist, die für die Übersetzung der JSP in ein Java-Servlet sorgt. Wir empfehlen, im ersten Schritt die tomcat-Referenzimplementierung aus dem Apache-Projekt zu verwenden, da sie alle grundlegenden Funktionen bietet, die eine solchen ‘Maschine’ gemäß der JSP-Spezifikation 1.1 enthalten sollte. Näheres zur Installation findet sich im Kasten ‘Standalone-Installation tomcat’.

<Context path="/jspTutorial" 
  docBase="webapps/jsp-Tutorial-app" 
  debug="9" reloadable="true" > 
</Context>

Es sei an dieser Stelle darauf hingewiesen, dass der professionelle Einsatz von JSP innerhalb einer Webapplikation in der Regel auch eine ‘professionelle’ Lösung im JSP-Engine-Umfeld benötigt. Hierbei geht es weniger um das Einhalten der Spezifikation an sich, als vielmehr um die vielen kleinen Added Values, die den täglichen Umgang mit den integrierten Tools erheblich vereinfachen.

Wie bereits weiter oben erwähnt, lassen sich JSPs als eine Art HTML-Seiten mit zusätzlichen, JSP-spezifischen Tags und Java-Code beschreiben. Generell sind vier Typen von gültigen JSP-Elementen unterscheidbar:

JSP-Direktiven
JSP-Skriptelemente
JSP-Kommentare
JSP-Aktionen

Die Aufgabe von Direktiven liegt in der Übermittlung von speziellen Seiteninformationen an die JSP-Engine. Mit ihrer Hilfe kann man angeben, wie im Fehlerfall weiter zu verfahren ist, welche Skriptsprachen unterstützt werden oder dass die JSP eine Taglib einbindet. Die allgemeine Syntax der Direktiven lautet <%@ .... %>. Alternativ ist die XML-Syntax <jsp:directive.name ... /> erlaubt, wobei name für eine der im Folgenden erläuterten Direktiventypen steht.

In diesem ersten Teil kommt hauptsächlich die so genannte page-Directive zum Einsatz. Sie dient einerseits dazu, für die einzelnen JSP eine generelle Fehlerseite zu definieren und andererseits zum Import der innerhalb der Seiten benötigten Java-Klassen. Der in Listing 1 wiedergegebene Auszug aus choice.jsp zeigt ein typisches Beispiel für die Nutzung von Seitendirektiven.

<%-- choice.jsp --%>

<%-- Setting up an error page --%>
<%@ page errorPage="/jspTutorial/errorpage.htm" %>

<%-- import needed java classes --%>      
<%@ page import="java.util.*" %>
<%@ page import="de.ix.jspTutorial.model.Pizza" %>
<%@ page import="de.ix.jspTutorial.model.PizzaList" %>
<%@ page import="de.ix.jspTutorial.model.Ingredient" %>
<%@ page import="de.ix.jspTutorial.model.IngredientList" %>

Neben den zwei gezeigten Seitendirektive-Attributen errorPage und import existieren eine ganze Anzahl weiterer erlaubter Attribute, die in der Tabelle unten erläutert sind.

Auch wenn es erlaubt ist, mehrere Attribute in einer Seitendirektive anzugeben, sollte aus Gründen der Lesbarkeit für jedes Attribut eine eigene Direktive aufgeführt werden. Dies erleichtert eine spätere Fehlersuche.

Neben der bisher beschriebenen Seitendirektive existieren die include- und die taglib-Direktiven. Wie die Namen nahe legen, dient die Include-Direktive zum Einfügen von Inhalten. Dabei wird die Direktive durch die entsprechende lokale Datei ersetzt, die zum Beispiel eine weitere JSP- oder aber eine HTML-Datei sein kann. Im Beispiel des Pizza Service Online dient diese Direktive dazu, das immer wiederkehrende ‘Copyright’ einzubinden.

<%@ include file="/jspTutorial/includes/copyright.html"%>

Die taglib-Direktive ist nicht Bestandteil dieses Artikels, aber sie kommt im dritten Teil zentral vor.

Variablen und Methoden

Deklarationen dienen, wie aus Java bekannt, zur Definition von Variablen und Methoden, die dann von anderen Elementen der JSP angesprochen werden können. Das übersetzte Servlet generiert für jede JSP- eine eigene Java-Methode. Die allgemeine Syntax der Deklarationen lautet:

<%! declaration(s) %>

Auch hier ist alternativ die XML-Syntax möglich:

<jsp:declaration> declaration(s) </jsp:declaration>

Innerhalb des Pizza-Dienstes finden die Deklarationen zum Beispiel bei der Definition einer Methode zur Formatierung der DM-Beträge Verwendung (siehe Listing 2).

<%! public String formatCurrency(double aCurrencyValue) {
     DecimalFormat theFormat = new DecimalFormat();
     theFormat.setGroupingUsed(true);
     theFormat.setMinimumFractionDigits(2);
     theFormat.setMaximumFractionDigits(2);
return theFormat.format(aCurrency) ;
  }
 %>

Da Deklarationen die Variablen und Methoden lediglich definieren, nicht aber verwenden, erzeugen sie keine Ausgaben innerhalb der JavaServer Pages. Dafür sind die Scriptlets und JSP-Ausdrücke verantwortlich. Will man die Variablen und Methoden direkt zur Erzeugung von HTML-Ausgabe verwenden, erreicht man dies mittels der so genannten JSP-Expressions. Mit Hilfe von Ausdrücken wie

<%= expression %>
[oder]
<jsp:expression> expression </jsp:expression>

können Entwickler auf einfache Art und Weise dynamisch die HTML-Ausgabe innerhalb einer JSP generieren. Da HTML bekanntlich nur Textelemente kennt, erfolgt eine automatische Konvertierung der verschiedenen Java-Typen in den Datentyp String. Hierzu wird die von der Klasse java.lang.Object geerbte Methode toString() herangezogen.

Ein Problem ergibt sich lediglich bei den primitiven Datentypen, da diese mangels einer zu Grunde liegenden Klasse über keine toString()-Methode verfügen. Die Tabelle ‘Konvertierungssregeln’ zeigt die entsprechenden Methoden.

Beispiele für Ausdrücke gibt es viele innerhalb des Pizza-Dienstes. Der in Listing 3 zu sehende Ausschnitt aus choice.jsp zeigt den dynamischen Aufbau der Pizza-Auswahlliste. Name, Größe, Preis und Identität der Pizzen werden jeweils mittels JSP-Expressions ermittelt.

<!-- Table for choice of pizza -->
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">

  <!--  erzeuge Kopf der Tabelle  -->     
  <TR BGCOLOR="#406E6E">
    <TD WIDTH="150"><FONT FACE="Arial,Helvetica" 
           SIZE="2" COLOR="#FFFFFF">&nbsp;Name</TD> 
    <TD WIDTH="150"><FONT FACE="Arial,Helvetica" 
           SIZE="2" COLOR="#FFFFFF">&nbsp;Größe</TD>
    <TD WIDTH="100"><FONT FACE="Arial,Helvetica" 
           SIZE="2" COLOR="#FFFFFF">&nbsp;Preis</TD>
    <TD WIDTH="75"><FONT FACE="Arial,Helvetica" 
           SIZE="2" COLOR="#FFFFFF">&nbsp;</TD>     
  </TR>

  <!--  Ausgabe über alle Pizzas in der Pizzaliste 
  und generiere die Auswahltabelle-->
     
  <%     
  Set entrySet = pizzaList.getPizzas().entrySet();

  for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
  
  Map.Entry entry = (Map.Entry)iter.next();
  Pizza pizza = (Pizza)entry.getValue();
  
  %>
  
  <TR>
    <TD><FONT FACE="Arial,Helvetica" 
           SIZE="2">&nbsp;<%=pizza.getName()%></TD>
    <TD><FONT FACE="Arial,Helvetica" 
           SIZE="2">&nbsp;<%=pizza.getSize()%></TD>
    <TD><FONT FACE="Arial,Helvetica" 
           SIZE="2">&nbsp;DM&nbsp;<%=pizza.getBasePrice()%></TD>
    <TD><FONT FACE="Arial,Helvetica" 
           SIZE="2"><INPUT NAME="ID_PIZZA" TYPE="radio     
       "VALUE="<%=pizza.getId()%>"></TD>
  </TR>
  
 <%     
  }
 %>
</TABLE>

Scriptlets für die Ausgabe

Während JSP-Deklarationen und -Ausdrücke per Definition in ihrer Funktion relativ beschränkt sind, wenn es darum geht, HTML-Ausgaben erzeugen und Ablauflogik zu implementieren, dienen Scriptlets genau zu diesem Zweck. Auch wenn die Verwendung von Scriptlets nicht automatisch mit HTML-Ausgaben gleichzusetzen ist, werden sie doch meistens direkt oder indirekt für diesen Zweck herangezogen. Die allgemeine Syntax der Scriptlets lautet:

<% scriptlet %>
[oder]
<jsp:scriptlet> scriptlet </jsp:scriptlet>

Der Pizza-Dienst macht regen Gebrauch von Scriptlets. So wird zum Beispiel mit ihnen die Liste der möglichen Pizzen innerhalb der Seite choice.jsp durchlaufen (Listing 4). Wie es zeigt, lassen sich Scriptlets und HTML-Tags beliebig kombinieren - in etwa mit PHP vergleichbar.

<%
    Set entrySet = pizzaList.getPizzas().entrySet();

    for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
      Map.Entry entry = (Map.Entry)iter.next();
      Pizza pizza = (Pizza)entry.getValue();
%>
    
  <TR>
    <TD><FONT FACE="Arial,Helvetica" 
              SIZE="2">&nbsp;<%=pizza.getName()%></TD>
    <TD><FONT FACE="Arial,Helvetica"  
              SIZE="2">&nbsp;<%=pizza.getSize()%></TD>
    <TD><FONT FACE="Arial,Helvetica"  
              SIZE="2">&nbsp;DM&nbsp;<%=pizza.getBasePrice()%></TD>
    <TD><FONT FACE="Arial,Helvetica"  
              SIZE="2"><INPUT NAME="ID_PIZZA" TYPE="radio" 
              VALUE="<%=pizza.getId()%>"></TD>
  </TR>
<%     
  }
%>

Mit Hilfe des Java Collection Framework und dem darin definierten Iterator wird die Liste aller Pizzen im Rahmen einer for-Schleife durchlaufen. Zu beachten ist dabei, dass sich die Schleife über zwei JSP-Scriptlets erstreckt. Die eigentliche Ausgabe der einzelnen Pizzen erfolgt via HTML und JSP-Expressions.

Auch wenn Scriptlets aufgrund ihrer Mächtigkeit einen gewissen Anreiz für ihre Verwendung bieten, sollten Entwickler in der Regel - anders als in diesem ersten Teil des Tutorials - relativ sparsam mit ihnen umgehen. Besser ist es, Businesslogik und Ablaufsteuerung klar von der Ebene der Darstellung zu trennen. Dies lässt sich durch eine geschickte Kombination von JavaServer Pages (Design/View), Servlets (Controller), Taglibs und JavaBeans (Modell) erreichen. So kann der HTML/JSP-Designer sich um die Bereiche der Optik kümmern, während Java-Entwickler den Part der Businesslogik und Ablaufsteuerung übernehmen. Genau das wird einen Schwerpunkt des zweiten Tutorials bilden.

Entwickler kommentieren nicht

Natürlich darf in einer Technik wie JSP die Möglichkeit zur Quelltextdokumentation nicht fehlen. Dies ist gerade in Hinblick auf getrennte Rollen bei der Erstellung der JSP von besonderer Bedeutung. Generell lassen sich drei verschiedene Arten von Kommentaren unterscheiden:

Content Comment
JSP Comment
Scripting Language Comment

Während der inhaltliche Kommentar zurück an den Browser übermittelt wird und somit auch in den HTML-Sourcen für den Betrachter der HTML-Seiten sichtbar ist, können nur Entwickler die anderen beiden Typen einsehen. Bei dem erstgenannten handelt es sich um den Standard-HTML/XML-Kommentar mit der Syntax:

<!-- comment -->

Interessant aus Sicht der JSP ist dabei, dass inhaltliche Kommentare gültige JSP-Expressions beinhalten dürfen. So ist zum Beispiel ein Kommentar in der Art

<!-- Diese Seite ist Teil des 
iX-JSP-Tutorials, Version <%= getVersion() %> 
-->

denkbar. JSP-Kommentare sind nur innerhalb der original JSP-Datei sichtbar und besitzen folgende Syntax:

<%-- comment --%>

Ein typisches Beispiel innerhalb des Pizza-Dienstes stellen die Kommentare zur Erläuterung des jeweiligen Seiteninhaltes einer JSP dar.

<%--
  % choice.jsp
  %
  % Diese JSP ist Teil des iX-Tutorials.
  % Anwender koennen Pizza und
  % Zutaten bestellen
  %
 --%>

Der dritte Typ, der so genannte Skriptsprachenkommentar, ist abhängig von der gewählten Sprache und kann innerhalb von JSP-Scriptlets verwendet werden. Da es sich in unserem Falle um die Skriptsprache Java handelt, sind somit die Formen für einzeiligen und mehrzeiligen Kommentar erlaubt:

// comment
/* comment */

Neben den bisher vorgestellten Direktiven, Skriptelementen und Kommentaren bilden die so genannten Aktionen den vierten und letzten Teil der gültigen JSP-Elemente. Im Rahmen dieses ersten Teils sollen lediglich drei verschiedene Bean-Tags

<jsp:useBean>
<jsp:getProperty>
<jsp:setProperty>

besprochen werden. Die anderen JSP-Actions sind dagegen Bestandteil des zweiten Artikels, wo auch ausführlicher auf die Möglichkeiten der Bean-Tags eingegangen wird.

Generell kommt ihnen die Aufgabe zu, mit serverseitigen JavaBeans zu interagieren. Dies bedeutet, dass mit ihrer Hilfe serverseitige Objekte erzeugt, gelesen und manipuliert werden können.

Der Zweck dieser Tags liegt hauptsächlich in der sauberen Trennung zwischen Design und Entwicklung der Businesslogik einer Webapplikation. Der HTML-Designer muss lediglich die neuen Tags sowie die notwendigen Attribute kennen, um Informationen in die oder aber aus den serverseitigen JavaBeans zu bekommen. Java-Kenntnisse sind nicht erforderlich. Um die Implementierung der JavaBeans kümmert sich ein Java-Entwickler. So kann sich jeder Beteiligte im Projekt mit der Thematik beschäftigen, für die er ausgebildet ist, was bei ausreichender Kommunikation und Dokumentation automatisch zu besseren Webanwendungen führen sollte.

Um mit einer JavaBean zu interagieren, muss die JSP natürlich zunächst wissen, wo die zu finden ist. Diese Informationen können mit Hilfe des <jsp:useBean>-Tags angegeben werden. Während dessen einfache Variante

<jsp:useBean id="beanName" 
  class="full class name" ... />

lediglich ein id-Attribut angibt, unter der die Bean angesprochen werden kann, sowie die zur Bean gehörige Java-Klasse, lässt sich mit der zweiten Variante

<jsp:useBean id="beanName" 
  class="full class name" ... > 
[initialer Code] 
</jsp:useBean>

zusätzlicher Code zur initialen Konfiguration der Bean definieren. Im Pizza-Dienst wird diese Tatsache zum Beispiel dafür genutzt, die Liste der Pizzen und Zutaten einmalig in die HttpSession einzulesen:

<%- initialize pizza list -%>
<jsp:useBean id="pizzaList"
   class="de.ix.jspTutorial.model.PizzaList"
   scope="session">
  <% pizzaList.readList(application); %>
</jsp:useBean>

Das zusätzliche Attribut scope gibt innerhalb des <jsp:useBean>-Tags den Sichtbarkeitsbereich der Bean-Instanz an. Der Wert session signalisiert, dass die Bean unter der id ‘pizzaList’ innerhalb der aktuellen HttpSession von jeder beliebigen Seite aus angesprochen werden kann.

Wichtig dabei ist, dass die Bean-Instanz nur beim ersten Aufruf neu erzeugt und der Code zur initialen Konfiguration der Bean durchlaufen wird.

Bei jedem weiteren Aufruf wird auf die bereits bestehende Instanz innerhalb der Session zurückgegriffen. Im Falle des Pizza-Dienstes bedeutet dies konkret, dass die Liste der Pizzen nur einmal pro Session eingelesen wird und anschließend allen JSPs zur Verfügung steht.

Per Definition verfügt eine JavaBean über eine Reihe von Attributen, die Entwickler mittels get- und set-Methoden setzen und lesen können. Das Pendant hierzu innerhalb der JSP stellen die beiden Bean-Tags

<jsp:getProperty name="beanName"
property="propertyName" />
<jsp:setProperty name="beanName"
property="propertyName" ... />

dar, wobei beanName für die im <jsp:useBean>-Tag definierte id und propertyName für das gewünschte Attribute der JavaBean steht. Zum Einsatz kommen diese beiden Tags innerhalb des Dienstes unter anderem in der Datei confirm.jsp (siehe Listing 5). Die Zeile

<jsp:setProperty name="order"
property="*" />

erreicht, dass alle Parameter innerhalb des aktuellen Request - also des Aufrufs aus der Seite order.jsp heraus - in die gleichnamigen Attribute der JavaBean-Instanz mit der id order geschrieben werden. Das anschließende Auslesen und Ausgeben der Informationen erfolgt wiederum durch die verschiedenen <jsp:getProperty>-Tags.

<HTML>
<HEAD>
  <TITLE>Pizza Service online - confirm</TITLE>
</HEAD>

<BODY BGCOLOR="#FFFFFF" LINK="#406E6E" ALINK="#406E6E" 
VLINK="#406E6E">

<jsp:setProperty name="order" property="*" />

<!-- [...] -->

Die Bestellung wird an folgende Adresse geliefert:<BR>
<BR>     
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
  <TR BGCOLOR="#406E6E">
    <TD WIDTH="350"><FONT FACE="Arial,Helvetica" SIZE="2"
             COLOR="#FFFFFF">&nbsp;Lieferadresse
    </TD>          
  </TR>
  <TR VALIGN="top">
    <TD><FONT FACE="Arial,Helvetica" 
              SIZE="2">&nbsp;<jsp:getProperty name="order"
                                  property="firstname"/>&nbsp;
                             <jsp:getProperty name="order" 
                                  property="lastname"/>
     </TD>
  </TR>     
  <TR VALIGN="top">
    <TD><FONT FACE="Arial,Helvetica" 
              SIZE="2">&nbsp;<jsp:getProperty name="order" 
                                  property="address1"/>
     </TD>
  </TR>     
  <TR VALIGN="top">
     <TD><FONT FACE="Arial,Helvetica" 
               SIZE="2">&nbsp;<jsp:getProperty name="order" 
                                   property="address2"/>
     </TD>
   </TR>     
   <TR VALIGN="top">
     <TD><FONT FACE="Arial,Helvetica" 
               SIZE="2">&nbsp;<jsp:getProperty name="order" 
                                   property="zip"/>&nbsp;
                              <jsp:getProperty name="order" 
                                   property="town"/>
      </TD>
   </TR>     
</TABLE>

Ausblick

Dieser erste Teil beschert mit dem gesamten Listing eine kleine Anwendung. Es ist der erste Schritt, um Komponenten für dynamischen Webapplikationen zu verwenden. Das Potenzial der JSP ist erkennbar, wir müssen sie nun in den folgenden Teilen des Tutorials nutzen. Die Anbindung einer Datenbank, Anwendung von Templates, eine verbesserte Nutzerführung sowie eine vernünftige Fehlerbehandlung sind unumgänglich. In der nächsten iX ...

Lars Röwekamp
ist als IT-Berater mit den Schwerpunkten Neue Technologien und OO/Java für seine Firma openKnowledge tätig.

Peter Roßbach
ist freiberuflicher IT-Berater für die Konzeption, Organisation und Entwicklung von Java-Web-Anwendungen.

Literatur

[1] Peter Roßbach, Hendrik Schreiber; JavaServer und Servlets; München (Addison-Wesley) 1999

[2] Duane K. Fields and Mark A. Kolb; Web Development with JavaServer Pages; Manning 1999; als eBook