Programmierung von Client/Server-Anwendungen J2EE

1
Programmierung von Client/Server-AnwendungenJ2
EE Web-Applikationen, Java Server Pages,
JavaBeans und Servletserstellt in Anlehnung an
Stark, T. J2EE Einstieg für Anspruchsvolle,Add
ison-Wesley, Pearson Studium, München 2005
2
Übersicht zur Vorlesung

• HTML im Rückblick
• Java-Server-Pages (JSP)
• JSP und Datenbankanbindung via JDBC
• JavaBean-Komponentenmodell
• Servlets vs. JSP
• Idee der Tag-Bibliotheken

3
HTML im Rückblick
4
HTML im Rückblick

• HTML-Versionen im Vergleich (W3 Konsortiums)
• HTML (ohne Versionsnummer) - 1992
• Überschriften, Textabsätze, Grafikreferenzen,
  Hypertext-Links
• HTML V2.0 - 1995 (noch akademisch geprägt)
• kleinster gemeinsamer Nenner für Web-Seiten
• HTML V3.2 - 1997 (Zusammenarbeit mit der
  Industrie)
• Tabellen, physische Textformatierungen
• HTML V4.0 - 1998
• Verwendung von Frames (geteilte Seiten)
• Cascading Style Sheets - festlegen von z.B.
  Schriftgröße, -farbe, ...
• Verwendung von Scriptsprachen (z.B. JavaSkript)
• XHTML 1.0 Neuformulierung HTML 4.01 mit Hilfe
  von XML - 2000

5
Hypermediale Informationssysteme

• Aufbau des Unified Ressource Locator
• Ziel einheitliche Schnittstelle zum Internet
• PROTOKOLL//SERVER/VERZEICHNISPFAD/DOKUMENT
• Protokoll http, file, ftp, mailto, ftp, https,
  ...
• Server
• IP-Adresse z.B. 164.19.200.20
• alternativ Domain Name Service (DNS-Name)
• Verzeichnispfad Verzeichnis innerhalb des
  lokalen Filesystems
• Dokument eigentliche auszugebende Datei, über
  Dateiextension erfolgt die Wahl möglicher
  Plug-Ins (z.B. .htm, .pdf, ...)
• Beispiel eines URL
• http//userpage.fu-berlin.de/schmiete/index.htm

6
Hypermediale Informationssysteme

• Erstellung von HTML-Dokumenten
• Einfache ASCII-Datei, neu erstellt oder
  übernommen z.B. von Word und mit HTML-Befehlen
  versehene Datei
• Verwendung einfacher Editoren (Vorschlag
  UltraEdit-32)
• Nutzung von Generatoren (Bsp. WebWizard,
  HotMeTaL, ...)
• Verwendung von Entwicklungsumgebungen wie z.B. MS
  Visual Interdev und Frontpage (für Formulare
  sinnvoll)
• Nutzung der Genratorfunktionen von
  Textverarbeitungsprogrammen wie z.B. MS Office
  (generiert auch XML)
• Einstiegsdatei typischerweise index.htm oder
  default.htm
• (.htm unter DOS und .html unter UNIX oder
  WindowsNT)

7
Hypermediale Informationssysteme

• Möglichkeiten der Einstellung
• Angebot der Internet-Service-Provider, z.B.
  T-Online
• Im Rahmen von direkten Internet-Zugängen und
  eigenem HTTP-Server
• Verwendung akademischer Server-Systeme
• Häufig Probleme bei dynamischen Komponenten, z.B.
  zu startende Services

8
Hypermediale Informationssysteme

• Grundaufbau einer einfachen HTML-Datei
• ltHTMLgt
• lt!-----Kommentarzeile-------gt
• ltHEADgt
• ltTITLEgtDokumente und Informationenlt/TITLEgt
• lt/HEADgt
• ltBODYgt
• ltH1gtClient/Server-Anwendungenlt/H1gt
• ltHRgt
• lt/BODYgt
• lt/HTMLgt

9
Hypermediale Informationssysteme

• Merkmale der HTML-Syntax
• Befehle meist aus einleitenden und abschließenden
  Tag, keine Beachtung von Groß- und
  Kleinschreibung
• Leerzeichen im Text zusammengefaßt, explizit mit
  160
• Verschachtelte Tags führen zu Fehlern
• Zusätzliche Attribute bei einleitenden Tag
  möglich, z.B. die Ausrichtung einer Überschrift
  der 2. Kategorie.
• Bsp. lth2 aligncentergtAusgabetextlth2gt
• Kommentare in HTML lt!--Kommentar--gt
• Sonderzeichen im Ausgabetext wie z.B. ä sollten
  für die international richtige Darstellung durch
  auml ersetzt werden

10
Hypermediale Informationssysteme

• Vorgehensweise zur Erstellung von HTML-Systemen
• Analyse der auszugebenden Daten (über was soll
  informiert werden)
• Navigationsstruktur grob entwerfen (z.B.
  Baumstrukturen verwenden)
• Grundgerüst der HTML-Datei erstellen
• Maskierungsvorschriften für Umlaute,
  Sonderzeichen beachten
• Seiten durch Zeilenumbrüche und Leerzeilen
  verwenden
• Verwenden von mehreren kleinen HTML-Dateien
• nicht größer als 64 KByte (typische Größen ca. 5
  KByte)
• Audio/Video-Sequenzen sollten explizit
  angekündigt werden
• Test der erstellten Seiten unter verschiedenen
  Browser-Systemen

11
Hypermediale Informationssysteme

• Übersicht zum HTML-Befehlsumfang (1)
• Textformatierung (Überschriften ltH1gtTextlt/H1gt,
  Absätze ltPgt, Zentrieren ltCENTERgt, Zeilenumbruch
  ltBRgt, Trennlienie ltHRgt )
• Textattribute
• physikalische (ltIgt...lt/Igt, ltBgt...lt/Bgt,
  ltblinkgt...lt/blinkgt
• logische ltCITEgt...lt/CITEgt, ltCODEgt...lt/CODEgt)
• Listen (z.B. numerierte und unnumerierte Listen)
• ltOLgt ltULgt
• ltLIgt Aumlpfel lt/LIgt ltLIgt lt/LIgt
• lt/OLgt lt/ULgt
• Grafiken anzeigen (ltIMG SRCAdresse des Bildesgt,
  die Angabe einer alternativen Text-Ausgabe ist
  möglich)
• Tabellen ltTABLEgt ltTRgt ltTHgtKopfzeile der
  Tabellelt/THgt lt/TRgt
• ltTRgt ltTDgtDatenzellelt/TDgtlt/TRgt
• lt/TABLEgt

12
Hypermediale Informationssysteme

• Übersicht zum HTML-Befehlsumfang (2)
• Frames für Teilung der Seite in z.B. linken und
  rechten Bereich
• ltframeset cols"20,60"gt
• ltframe src"cmgverw.htm" name"links"gt
• ltframe src"ov_cmg.htm" name"rechts"gt
• lt/framesetgt
• Hypertextlinks (Start- und Zielpunkt)
• Links auf Dokumente ltA HREF Adresse des
  Zieldokumentsgt...lt/Agt
• Link innerhalb der WWW-Seite ltA HREF
  Markegt...lt/Agt
• ltA NAME Markegt...lt/Agt
• Link auf Internetdienste email, news, ftp,
  gopher, telnet
• Imagemaps Einteilung einer Grafik in anklickbare
  Bereiche

13
Hypermediale Informationssysteme

• Übersicht zum HTML-Befehlsumfang (3)
• Multimedia- und Fremdprogrammreferenzen
  (Browserabhängig)
• Standard ist das OBJECT-Tag, bei MS Audio mit
  SOUND-Tag
• ltOBJECT DATAtest.avi TYPEvideo/x-msvideogtlt/OB
  JECTgt
• Java-Applets mit APPLET-Tag
• Interaktive Formulare zur Dateneingabe
• Formulardefinition ltFORM ACTIONmailto...METHOD
  POSTgt
• Eingabefelder ltINPUT TYPEtext
  NAMEVARIABLEgt
• Auswahlcheckboxen ltINPUT TYPEcheckbox
  NAMEVARIABLEgt
• Auswahllisten (Scrollbar)
• ltSELECT NAME"BenchmarkNutzungSIZE4
  MULTIPLEgt
• ltOPTIONgtHarwarekenndaten
• Bestätigungsbutton ltINPUT TYPEsubmit
  NAMEOK-Buttongt

14
Java Server Pages JSPs
15
Java Server Pages

• Pendant zu folgenden Techniken
• Microsofts Active Server Pages (kurz ASP)
• CGI-basierte Anwendungen oder auch PHP
• Einbetten von Java-Code zwischen HTML-Anweisungen
• Server-Seite, die dynamisch bei URL-Anforderung
  erzeugt wird
• Bestandteile einer JSP
• HTML-Elemente
• Skriptlets Skript-Elemente in Java
• Java Servlets
• Java Beans
• Aus Bestandteilen der JSP wird ein Servlet
  generiert

16
Java Server Pages

• Bausteine einer JSP
• Ausdrücke der Form lt Java-Ausdruck gt
• Scriptlets der Form lt Java-Code gt
• Deklarationen der Form lt! Java-Code gt
• Kommentare
• lt-- JSP-Kommentar gt
• lt!-- HTML-Kommentar --gt
• Java-Anweisungen in JSP-Ausdrücken werden nicht
  mit einem Semikolon abgeschlossen ? jeweils nur
  eine Anweisung!

17
Java Server Pages

• lthtmlgt
• ltbodygt
• Hallo liebe Studenten der FHW Berlin!
• lthrgt
• ltpgt
• Es ist jetzt genau
• lt new java.util.Date()gt
• lt/bodygt
• lt/htmlgt
• Vergleich
• System.out.print (Es ist jetzt genau new
  java.util.Date())

18
Java Server Pages
JSP-Seite unter JSP-examples
19
Java Server Pages

• JSP liegt nicht in einem eigenen Verzeichnis
• Nicht günstig im Falle einer Neuinstallation
• Besser ist die Anlage eines eigenen
  Projektverzeichnis
• http//localhost8080/eigenes_verzeichnis/.jsp
• Möglichkeiten zur Anlage eines solchen
  Verzeichnis
• Verwendung des Sysdeo-Plugin unter Eclipse
  (GUI-Dialog)
• Editieren der Datei conf/server.xml im Tomcat
  Verzeichnis

20
Java Server Pages

• Erzeugen eines eigenen Arbeitsverzeichnisses
  Unterverzeichnisse
• css Ablage von Cascading Stylesheets
• html Aufnahme statischer HTML-Dokumente
• images Aufnahme von Bildern
• jsp Aufnahme von Java Server Pages (dynamische
  Dokumente)
• WEB-INF enthält Web Deployement Descriptor ?
  web.xml
• Eintrag in der server.xml-Datei unter Tomcat
• ltContext path"/schmiete"
• docBase"C\jakarta-tomcat-5\schmietendorf"
• debug"0" reloadable"true" crossContext"true"
  /gt

21
Java Server Pages

• Vordefinierte Variablen in einer JSP (verwaltet
  im Servlet-Container)
• request javax.servlet.http.HTTPServletRequest
• Zugriff auf Informationen des Request-Header
• z.B. akzeptierte Dateiformate, Sprachen, Art des
  User-Agent
• response javax.servlet.http.HTTPServletResponse
• Modifikation der Antwort des Servers an den
  Client
• Status-Code setzen oder Response-Header
  modifizieren
• out javax.servlet.jsp.JspWriter
• Verwendet der Server um die Ausgabe an den Client
  zu senden

22
Java Server Pages

• lthtmlgt
• ltheadgt
• lttitlegtEine dynamische JSP-Seitelt/titlegt
• lt/headgt
• ltbodygt
• lth2gtVerwendung vordefinierter Variablenlt/h2gt
• ltpgtlthrgtltpgt
• ltulgt
• ltligtHallo liebe Studenten der FHW Berlin!
• lt/ligt
• ltligtEs ist jetzt genau lt new
  java.util.Date()gt lt/ligt
• ltligtSie sind lt request.getParameter("name")gt
• lt/ligt
• lt/ulgt
• lt/bodygt
• lt/htmlgt

23
Java Server Pages
24
Java Server Pages

• Alternative Notation für JSP-Ausdrücke
• Ggf. besteht die Forderung XML-konformer JSPs
• Bisherige Form
• lt Ausdruck gt
• XML-konforme Darstellung
• ltjspexpressiongtAusdrucklt/jspexpressiongt
• Die XML-konforme Darstellung ist case-sensitiv
• Auch hier wird nur eine Java-Anweisung verwendet

25
Java Server Pages

• Bisherige Einschränkungen der verwendeten JSPs
• Nur jeweils eine Java-Anweisung
• Keine definierbaren lokale Variablen zur
  Speicherung von Werten
• Keine bedingten Entscheidungen (if-else)
• Keine Schleifen zur Wiederholung von Anweisungen
• Verwendung von sogenannten JSP-Scriptlets
• Allg. Form lt beliebiger Java-Codegt
• Def. Einer Folge von Java-Befehlen
• JSP-Scriptlet Ausgaben müssen explizit definiert
  werden
• lt String userName request.getParameter(user)
  
• out.println (Sie sind userName) gt

26
Java Server Pages

• Beispiele für JSP-Scriptlets
• Schleifen
• lt for (int i0 ilt10 i) gt
• HTML/JSP-Code
• lt gt
• Switch-Abfrage
• lt switch (arg)
• case 0 gt HTML/JSP-Code lt
• case 1 gt HTML/JSP-Code lt
• braek
• case 2 gt HTML/JSP-Code lt
• default gt HTML/JSP-Code lt
• gt
• JSP-Scriplets werden jeweils durch HTML-Code
  unterbrochen

27
Java Server Pages

• JSP-Scriptlets ? zusammenhängende Java-Methode
• Definiert den Ablauf der JSP
• Vordefinierte Variablen request, response und out
  können als Parameter der Methode verstanden
  werden
• Servlet(Web)-Container sieht JSP als
  Java-Programm
• Public classMyJsp
• public void response (Request req, Response,
  res)
• // JSP-Scriplets
• //

28
Java Server Pages

• lthtmlgt
• ltheadgt
• lttitlegtEine dynamische JSP-Seitelt/titlegt
• lt/headgt
• lt String userName request.getParameter("name")
  gt
• ltbodygt
• lth2gtVerwendung vordefinierter Variablen -
  Beispiel 3lt/h2gt
• ltpgtlthrgtltpgt
• ltulgt
• ltligtHallo liebe Studenten der FHW Berlin!lt/ligt
• ltligtEs ist jetzt genau
• lt new java.util.Date()gtlt/ligt
• lt if (userName ! null) gt
• ltligtSie sind lt userName gtlt/ligt
• lt else gt
• ltligtSie sind unbekanntlt/ligt
• lt gt
• lt/ulgt
• lt/bodygt

29
Java Server Pages
else-Zweig ?
30
Java Server Pages

• JSP-Deklarationen
• Variablen innerhalb der JSP-Methoden ? pot.
  Probleme
• Lokale Variablen
• Verlieren Wert nach ausgeführten Request
• Zählen der Zugriffe auf eine Seite
• Notwendige Speicherung des Anzahl Zugriffe
• Verwendung von JSP-Deklarationen (vgl. globale
  Variablen)
• Form lt! Java-Code außerhalb des JSP-Scriplet gt
• JSP-Deklarationen sind nicht Bestandteil der
  JSP-Scriplet!

31
Java Server Pages

• lthtmlgt
• ltheadgt lttitlegtEine dynamische JSP-Seitelt/titlegtlt/h
  eadgt
• lt! private int count 0gt
• lt String userName request.getParameter("name")
  gt
• ltbodygt
• lth2gtVerwendung vordefinierter Variablen -
  Beispiel 4lt/h2gt
• ltpgtlthrgtltpgt
• ltulgt
• ltligtHallo liebe Studenten der FHW Berlin!lt/ligt
• ltligtEs ist jetzt genau lt new
  java.util.Date()gtlt/ligt
• lt if (userName ! null) gt
• ltligtSie sind lt userName gtlt/ligt
• ltligtBesucher lt count gtlt/ligt
• lt else gt
• ltligtSie sind unbekanntlt/ligt
• lt gt
• lt/ulgt
• lt/bodygt
• lt/htmlgt

32
Java Server Pages
? 14. Aufruf
15. Aufruf ?
33
Java Server Pages

• Weiteres Beispiel einer möglichen
  JSP-Deklaration
• lt! Private boolean existUser
• (javax.servlet.SerletRequest req, String
  userName)
• // Test ob der User schon vorhanden ist
• if (request.getParameter(userName) null)
• return false
• return true
• gt

34
Java Server Pages

• Vordefinierte Variablen einer JSP
• HTTP als zustandsloses Protokoll
• Server bedient nur die aktuelle Anfrage
• Client ist dem Server danach unbekannt
• Komplexe Applikationen bedingen
• Client muss ggf. wieder erkannt werden
• Zwischenspeicherung bestimmter Zustände
• Kontexte des Web Containers
• Stellen verschiedene Gültigkeitsbereiche für
  Variablen zur Verfügung
• 3 Speicherbereiche werden genutzt

35
Java Server Pages

• 3 Speicherbereiche für Anfragen an den
  Webservers
• Application-Scope (Informationen über die
  Lebenszeit des Servers)
• Globale, statische Variablen
• Art der Applikationsnutzung
• Session-Scope (Informationen ab dem 1. Aufruf)
• Speicherung einer Session-ID z.B. eindeutige
  Kundennummer
• Time-out Parameter
• Request-Scope (lokaler Gültigkeitsbereich)
• Sind nur während der Bearbeitung einer Antwort an
  den Client gültig
• Verfallen nach Beantwortung der Client-Anfrage

36
Java Server Pages

• Kontrolle von JSPs durch folgende
  Speicherbereiche
• request Variable vom Typ javax.servlet.http.HTTP
  ServletRequest
• Bezug zum Request-Scope
• Mittels Methode setAttribute() können Objekte
  hinzugefügt werden
• response Variable vom Typ javax.servlet.http.HTT
  PServletResponse
• Manipulation der Antwort an den Server
• Z.B. Cookies an den Browser senden oder
  Status-Code setzten

37
Java Server Pages

• Kontrolle von JSPs durch folgende
  Speicherbereiche
• out Variable vom Typ javax.servlet.jsp.JspWriter
  
• Bezieht sich auf den Ausgabestrom zwischen Server
  und Client
• Ermöglicht die Ausgabe von beliebigen Objekten
  bzw. Basistypen
• session - Variable vom Typ javax.servlet.http.Http
  Session
• Bezug auf den Session-Scope (z.B. beim Login)
• Mit setAttribute() können Werte zur Sitzung
  abgespeichert werden
• ? Nutzerspezifische Daten über mehrere Sitzungen
  ? Cookie-Technik

38
Java Server Pages

• Kontrolle von JSPs durch folgende
  Speicherbereiche
• application globale Variable zwischen
  Applikationen eine Webservers
• Bezug auf den Application-Scope
• Parallel laufende Anwendungen können so
  Ressourcen teilen
• config - Variable vom Typ javax.servlet.jsp.Servle
  tConfig
• Bietet den Zugriff auf serverseitige
  Initialisierungsparameter der JSP
• Werte können aus der web.xml gelesen werden
• z.B. Konfigurationsdaten für den Zugriff auf
  Datenbanken

39
Java Server Pages

• Kontrolle von JSPs durch folgende
  Speicherbereiche
• pageContext - Variable vom Typ javax.servlet.jsp.P
  ageServlet
• Realisiert den Zugriff auf Seitenattribute einer
  JSP
• Weiterleiten eines Requests
• Einfügen einer weiteren Seite
• page Synonym des Schlüsselwortes this in Java
• Ist vom Typ java.lang.Object
• Soll ggf. die Verwendung anderer Scriptsprachen
  unterstützen

40
Java Server Pages

• JSP Direktiven (Bezug zum Servlet-Container)
• page (kein Bezug auf die gleichnamige Variable)
• Eigenschaften der JSP als Java-Klasse
• Angabe einer Superklasse, Verhalten im
  Fehlerfall, Ausgabepufferung
• include
• Beschreibt den modularen Aufbau einer
  JSP-Anwendung
• Beziehung zu gemeinsam genutzten JSP-Seiten (z.B.
  Menüs)
• taglib
• Verhalten des JSP-Dokumentes auf der markup-Ebene
• z.B. Möglichkeiten zur Definition eigener tags

41
Java Server Pages

• Page Seitendirektiven 1
• Klassen und Packages importieren
• lt_at_ page importjava.util.Date gt
• lt_at_ page importjava.util.Date, java.math.
  gt
• JSPs ableiten von einer Superklasse (nicht
  generell unterstützt!)
• Package ownjsp.fhwbln.jsp
• Import javax.servlet.jsp.HttpJspPage
• Public class MyJsp implements HttpJspPage
• // eigener Code
• Nutzung
• lt_at_ page importownjsp.fhwbln.jsp.MyJsp
• extendsMyJsp gt

42
Java Server Pages

• Page Seitendirektiven 2
• Parallele Bearbeitung von Client-Anforderungen
• lt_at_ page isThreadSafetrue gt -
  Standardeinstellung
• lt_at_ page isThreadSafefalse gt
• errorPage Verweis auf eigene Fehlerseiten
• lt_at_ page errorPageFehlerseite.jsp gt
• page-Attribut contentType (MIME-Type ? PlugIn
  Auswahl)
• Teilt dem Browser die Art des nachfolgenden
  Dokumentes mit
• Realisierung mehrsprachiger Applikationen

43
Java Server Pages

• Beispiel einer einfachen Login-Prozedur
• Bestandteile eines komplexen Web-Auftritts
• Login-Seite ? Login.jsp
• Authentifizierung des Benutzers ? Einstieg.jsp
• Inhalt des eigentlichen Portals (z.B. Frame) ?
  Content.jsp
• Fehlerseite bei gescheiterter Anmeldung ?
  LoginError.jsp

44
Java Server Pages
45
Java Server Pages
lthtmlgtltheadgtlttitlegtEine dynamische
JSP-Seitelt/titlegtlt/headgt ltbodygt lth2gtEin einfaches
Login für Web-Anwendungenlt/h2gt ltpgtlthrgtltpgt ltform
method"post" action"Einstieg.jsp"gt Login
ltINPUT type"text" name"user" /gt ltINPUT
type"submit" value"Absenden" /gt ltimg
src"../images/fhw.jpg" gt lt/formgt lt if
(request.getParameter("msg") !null)
out.println (request.getParameter("msg"))
gt lt/bodygt lt/htmlgt
Login.jsp
46
Java Server Pages
lt_at_ page session"true" gt lt_at_ page
contentType"text/html charsetUTF-8" gt lt_at_
page errorPage"LoginError.jsp" gt lt // Test
ob noch eine entsprechende Session besteht if
(session.getAttribute("USER") null) //
Lesen des Parameters vom request String userName
request.getParameter("user") // Test ob der
Parameter existiert if (userName null)
throw new Exception ("Nutzername nicht
vorhanden!") // Test ob der Parameter
gültig ist if (! userName.equals("Thomas"))
gt
Login.jsp
47
Java Server Pages
ltjspforward page"Login.jsp?msgBenutzer nicht
bekannt!" /gt lt // Hinzufügen des Parameters
zur aktuellen Session session.setAttribute
("USER", userName) gt lt-- keine
Ausnahmefehler - weiter zu Content.jsp
--gt ltjspforward page"Content.jsp" /gt
Fortsetzung - Login.jsp
48
Java Server Pages
49
Java Server Pages
lthtmlgt ltheadgt lttitlegtEine dynamische
JSP-Seitelt/titlegt lt/headgt ltbodygt lth2gtHerzlich
willkommen im Portallt/h2gt ltpgtlthrgtltpgt Sie sind
Benutzer lt session.getAttribute("USER")
gt lt/bodygt lt/htmlgt
Der Einstieg ins Portal ?
50
JSP und JDBC
51
JSP und JDBC

1. Erstellen einer Instanz des JDBC-Treibers
2. Erstellen einer Verbindung zur DB über die
   JDBC-Treiberinstanz
3. Erstellen von Anweisungen die die DB-Verbindung
   verwenden
4. Ausführen der entsprechender SQL-Anweisungen
5. Prüfen auf vorhandenen Inhalt des ResultSet
6. Auswerten des ResultSet
7. Einfügen in die Felder der HTML-Tabelle
8. Beenden entsprechender Java-Anweisungen
9. Schließen des Statement und der Connection

52
JSP und JDBC Beispiel 1

• lthtmlgt
• ltheadgt
• lttitlegtJSP - JDBC Zugrifflt/titlegt
• lt/headgt
• lt_at_page language"java" import"java.sql." gt
• ltbodygt
• lth2gtDatenbankabfrage mittels JSP und JDBClt/h2gt
• lttable border"1" with"400"gt
• lttrgt
• lttdgtltbgtltigtIDlt/igtlt/bgtlt/tdgt
• lttdgtltbgtltigtNAMElt/igtlt/bgtlt/tdgt
• lttdgtltbgtltigtVORNAMElt/igtlt/bgtlt/tdgt
• lttdgtltbgtltigtORTlt/igtlt/bgtlt/tdgt
• lt/trgt

53
JSP und JDBC Beispiel 2

• lt
• // Schritt 1
• Class.forName("org.firebirdsql.jdbc.FBDriver")
• // Schritt 2
• Connection myConn DriverManager.getConnection(
  "jdbcfirebirdsqllocalhost/3050
• C/Programme/Firebird/examples/employee.gdb","sy
  sdba","masterkey")
• // Schritt 3
• Statement stmt myConn.createStatement()
• // Schritt 4
• ResultSet myResultSet stmt.executeQuery("selec
  t from mitarbeiter")
• // Schritt 5
• if (myResultSet ! null)
• // Schritt 6
• while (myResultSet.next())

54
JSP und JDBC Beispiel 3

• // Schritt 7
• lttrgt
• lttdgtlt id gtlt/tdgt
• lttdgtlt name gtlt/tdgt
• lttdgtlt vorname gtlt/tdgt
• lttdgtlt ort gtlt/tdgt
• lt/trgt
• lt
• // Schritt 8
• / Ende von while /
• / Ende von if /
• // Schritt 9 und 10
• stmt.close()
• // Schritt 11
• MyConn.close()
• gt

55
JSP und JDBC

• Typische Probleme des aufgezeigten Vorgehens
• Keine Trennung von Darstellung und
  Anwendungslogik
• Design der Oberfläche kann nicht separat
  entwickelt werden
• Hohe Fehleranfälligkeit (schwer eingrenzbar)
• Arbeitsteilige Softwareentwicklung ist schwierig
• Geringe Lesbarkeit und daraus folgend schwer
  wartbar
• ? Verbesserung der Situation mit Hilfe der
  JavaBeans
• ? MVC Model View Controller Pattern

56
JavaBeans
57
Java Beans

• Unterstützung der Idee einer arbeitsteiligen
  Softwareentwicklung
• Spezialisierte Zulieferunternehmen
• IV-technische Komponenten
• Domain- bzw. fachspezifische Komponenten
• Reduktion der Erstellungszeiten von
  Informationssystemen
• Sprachumfang von Java wurde nicht erweitert!
• Montage der Komponenten in entsprechenden
  Bean-Builder Tools
• Java-Studio (Entwicklung bei SUN aber
  eingestellt)
• VisualAge for Java (Umfangreiche Anwendung von
  JavaBeans)
• BDK Bean Development Kit (http//java.sun.com/bean
  s/docs)

58
Java Beans

• SUNs ursprüngliche Definition der JavaBeans
• JavaBeans components, or Beans, are reusable
  software components that can be manipulated
  visually in a builder tool. Beans can be combined
  to create traditional applications, or their
  smaller web-oriented brethren, applets. In
  additional, applets can be designed to work as
  reusable Beans.

59
Java Beans
60
Java Beans

• Introspection (Selbstbeobachtung) - Beans können
  zur Laufzeit Auskunft zu den gebotener Funktionen
  und Eigenschaften geben
• Auf den direkten Quellcode-Zugriff kann so
  verzichtet werden
• Implizite Introspection-Funktion bietet alle
  Methoden des Bean
• Explizite Introspection-Funktion über das
  BeanInfo Interface
• Customisation (Anpassung) - Beans können über die
  Nutzung von Dialogen angepasst werden.
• Angebot an Standard-Dialogen
• Angebot an angepassten Dialogen
• Event-Handling (Ereignisverarbeitung) -
  Verwendung des Delegation-Event-Handling-Model
  (Event-Sources und -Listener)
• Persistenz - Möglichkeit der dauerhaften
  Abspeicherung alter und neuer Werte von Properties

61
Java Beans

• Methoden - werden genutzt um entsprechende
  Properties des Beans zu ändern. Alle als public
  definierte Methoden werden in einem
  Bean-Builder-Tool angeboten.
• Einschränkung der angebotenen Methoden über
  BeanInfo-Klasse
• Einschränkung auch beim Import des Bean in ein
  Builder-Tool möglich
• Properties - (Eigenschaften) - Kapseln Daten
  einer Instanz eines Bean und können von außen
  abgefragt und geändert werden
• Signature pattern für Properties getProperty() /
  setProperty()
• Simple Properties - repräsentieren einen
  einzelnen Wert
• Indexed Properties - Array gleichen Datentyps
• Bound Properties - Kombination eines Properties
  mit einem Event (z.B. ausgelöst nach der Änderung
  eines Properties)
• Constrained Properties - Zustimmung zur Änderung
  einer Propertie von z.B. einem anderen Bean holen

62
Java Beans

• Softwarekomponentenmodell ? JavaBeans (aber !
  EJBs)
• Konfigurierbare Container
• Kapselung von Anwendungslogik
• Speicherung von Daten (persistieren)
• Trennung von Anwendungslogik und Darstellung
• Auslagerung von Logik aus den JSPs
• Bessere Wartbarkeit
• Entkopplung der Schichten

63
Java Beans

• Eigenschaften
• Besitzen einen leeren Konstruktor
• Sollten keine öffentlichen (public)
  Instanzvariablen besitzen
• Zustände werden über Zugriffsmethoden manipuliert
• Mögliche Methodensignaturen
• setXxx
• getXxx
• isXxx (bei booleschen Attributen)

64
Java Beans

• Beispiel einer einfachen JavaBean
• package cs.j2ee.beans
• / Speicherung einer Fahrtroute /
• public class RouteBean
• / Startpunkt der Fahrtroute /
• private String start
• public String getStart()
• return start
• public void setStart (String start)
• this.start start

65
Java Beans

• Verwendung von JavaBeans in JSPs
• ltjspuseBean idroute classcs.j2ee.beans.Route
  Bean /gt
• oder
• lt cs.j2ee.beans.RouteBean route new
  cs.j2ee.beans.RouteBean () gt
• oder als Interface
• ltjspuseBean idroute typetyp.Interface
  classcs.j2ee.beans.RouteBean /gt
• bzw.
• lt typ.Interface route new cs.j2ee.beans.RouteB
  ean () gt

66
Java Beans

• Zugriff auf Attribute der JavaBean
• Auslesen von Property-Werten
• ltjspgetProperty nameroute propertystart
  /gt
• oder
• lt route.getStart() gt
• Setzen von Property-Werten
• ltjspsetProperty nameroute propertystart
  value Dresden/gt

67
Java Beans

• Steuerung des Gültigkeitsbereichs von JavaBean
• ltjspuseBean idroute
• classcs.j2ee.beans.RouteBean
• scopesession /gt
• Steuerung über das scope-Attribut
• page Variablen sind nur innerhalb der aktuellen
  Seite gültig
• session gültig bis Browser geschlossen wird
• Verwendung für die Nutzerauthentifizierung
• Ablage aktuell ausgewählter Datensätze
• application für den applikationsübergreifenden
  Datenaustausch
• request Variablen sind für die Dauer eines
  Request gebunden

68
Java Beans

• Vorteile von JavaBeans
• Wiederverwendung von Quellcode (JSPs
  Java-Objekte)
• Verständlichkeit
• Vereinfachung der Struktur von JSPs
• Darstellung getrennt von der Java-Implementierung
• Kapselung
• JSPs interagieren mit dem Benutzer
• JavaBeans realisieren die Anwendungslogik
• Verwaltung zusammengehöriger Daten

69
Servlets
70
Java Servlets

• Server side applets, without face
• Bestandteile von Web Applicationen
• Bieten die Funktionalität von CGI-Skripts
• Kontext für Web Applikationen
• Unterstützung mehrerer Servlets
• Unterstützung mehrerer HTML-Seiten
• Unterstützung mehrerer Java Server Pages
• Filter für bestimmte Datentypen

71
Java Servlets

• Das generierte Servlet unserer ersten JSP - 1
• Unter C\jakarta-tomcat-5\tomcat50-jwsdp\work\Cat
  alina\localhost\schmiete\org\apache\jsp\jsp
• package org.apache.jsp.jsp
• import javax.servlet.
• import javax.servlet.http.
• import javax.servlet.jsp.
• public final class beispiel1_jsp extends
  org.apache.jasper.runtime.HttpJspBase
• implements org.apache.jasper.runtime.JspSource
  Dependent
• private static java.util.Vector
  _jspx_dependants
• public java.util.List getDependants()
• return _jspx_dependants

72
Java Servlets

• Das generierte Servlet unserer ersten JSP - 2
• public void _jspService(HttpServletRequest
  request, HttpServletResponse response)
• throws java.io.IOException,
  ServletException
• JspFactory _jspxFactory null
• PageContext pageContext null
• HttpSession session null
• ServletContext application null
• ServletConfig config null
• JspWriter out null
• Object page this
• JspWriter _jspx_out null
• PageContext _jspx_page_context null

73
Java Servlets

• Das generierte Servlet unserer ersten JSP - 3
• try
• _jspxFactory JspFactory.getDefaultFactory(
  )
• response.setContentType("text/html")
• pageContext _jspxFactory.getPageContext(th
  is, request, response,
• null, true, 8192, true)
• _jspx_page_context pageContext
• application pageContext.getServletContext(
  )
• config pageContext.getServletConfig()
• session pageContext.getSession()
• out pageContext.getOut()
• _jspx_out out

74
Java Servlets

• Das generierte Servlet unserer ersten JSP - 4
• out.write("lthtmlgt\r\n")
• out.write("ltbodygt\r\n")
• out.write("Hallo liebe Studenten der FHW
  Berlin!\r\n")
• out.write("Es ist jetzt genau\r\n")
• out.print( new java.util.Date())
• out.write("\r\n")
• out.write("lt/bodygt\r\n")
• out.write("lt/htmlgt")

75
Java Servlets

• Das generierte Servlet unserer ersten JSP - 5
• catch (Throwable t)
• if (!(t instanceof SkipPageException))
• out _jspx_out
• if (out ! null out.getBufferSize() !
  0)
• out.clearBuffer()
• if (_jspx_page_context ! null)
  _jspx_page_context.handlePageException(t)
• finally
• if (_jspxFactory ! null)
  _jspxFactory.releasePageContext(_jspx_page_context
  )

76
Java Servlets

• Alles was mit JSPs realisiert werden kann, kann
  auch unter Verwendung von Servlets erreicht
  werden
• Potentielle Nachteile von JSPs
• Mischung von JSP und HTML-Code wird bei komplexen
  Java-Strukturen unübersichtlich
• Mittels der Variable out (Typ javax.servlet.jsp.Js
  pWriter) können keine Binärdaten ausgegeben
  werden (z.B. Bilder)
• JSP können HTML-Dokumente erzeugen, deutlich
  schwieriger ist es bei anderen Datenformaten
• Fehler werden häufig erst zur Laufzeit erkannt
• ? Servlets stärker in der Funktionalität, als in
  der Darstellung

77
Java Servlets

• Ein selbst erzeugtes Servlet - 1
• package cs.j2ee.servlets
• import java.util.Date
• import java.io.PrintWriter
• import java.io.IOException
• import javax.servlet.http.HttpServlet
• import javax.servlet.http.HttpServletRequest
• import javax.servlet.http.HttpServletResponse
• import javax.servlet.ServletException
• public class HelloWorld extends HttpServlet
• public void service(HttpServletRequest
  request,
• HttpServletResponse
  response)
• throws IOException,
  ServletException

78
Java Servlets

• Ein selbst erzeugtes Servlet - 2
• // set the contentType
• response.setContentType("text/htmlcharsetI
  SO-8859-1")
• // get the PrintWriter
• PrintWriter out response.getWriter()
• // create content
• StringBuffer content new StringBuffer()
• content.append("lt!DOCTYPE html PUBLIC
  \"-//w3c//dtd html 4.0 transitional//en\"
  \"http//www.w3.org/TR/REC-html40/strict.dtd\"gt")
  
• content.append("ltHTMLgtltHEADgtltTITLEgtEin
  selbst geschriebens Servletlt/TITLEgtlt/HEADgt")

79
Java Servlets

• Ein selbst erzeugtes Servlet - 3
• content.append("ltBODYgtltFONT color\"green\"
  face\"arial\"gt")
• content.append("ltCENTERgtHallo Studenten der FHW
  Berlinlt/CENTERgtltULgt")
• content.append("ltLIgtEs ist jetzt genau ")
• content.append(new Date())
• content.append("lt/LIgtlt/ULgtlt/FONTgtlt/BODYgtlt/HTMLgt")
  
• // write out
• out.print (content.toString())

80
Java Servlets

• Schritte zur Ausführung des Servlets
• Übersetzen des Servlets mittels eines
  Java-Compilers
• Verwendung einer entsprechende Entwicklungsumgebun
  g
• Verwendung eines entsprechende Build-Files (Tool
  Ant)
• Anlegen einer entsprechenden Verzeichnisstruktur
  im Web-Server
• /WEB-INF/sources Java Quelldateien
• /WEB-INF/classes Java Klassendateien
• /WEB-INF/lib benötigte Klassenbibliotheken
• /deploy_lib Klassen die nur zur Übersetzung
  benötigt werden
• Web Deployment Decsiptor (web.xml) erstellen bzw.
  bearbeiten

81
Java Servlets
82
Java Servlets

• Der Web Deployment Descriptor - 1
• lt!DOCTYPE web-app PUBLIC
• "-//Sun Microsystems, Inc.//DTD Web
  Application 2.3//EN"
• "http//java.sun.com/dtd/web-app_2_3.dtd"gt
• ltweb-appgt
• ltdisplay-namegtClient/Server-Programmierunglt/displ
  ay-namegt
• ltdescriptiongt
• FHW Berlin
• lt/descriptiongt

83
Java Servlets

• Der Web Deployment Descriptor - 2
• Für jedes Servlet benötigen wir ein ltservletgt-Tag
• Servlet wird bereits bei der Initialisierung
  geladen
• Prio 1-10 (1 - zuerst geladen, 10 zuletzt
  geladen)
• lt!-- Bind Servlet to symbolic name --gt
• ltservletgt
• ltservlet-namegtWelcomeServletlt/servlet-namegt
• ltservlet-classgtcs.j2ee.servlets.HelloWorldlt/se
  rvlet-classgt
• ltload-on-startupgt2lt/load-on-startupgt
• lt/servletgt

84
Java Servlets

• Der Web Deployment Descriptor - 3
• Verknüpfen des Servlets mit einer URL
• Servlets liegen physikalisch an einem anderen
  Ort!
• Keine relativen Adressen innerhalb des HTML-Codes
• Verweise relativ zur virtuellen Adresse des
  Servlet setzen!!
• lt!-- Map servlet to URL --gt
• ltservlet-mappinggt
• ltservlet-namegtWelcomeServletlt/servlet-namegt
• lturl-patterngt/servlets/HelloWorldlt/url-pattern
  gt
• lt/servlet-mappinggt
• lt/web-appgt

85
Java Servlets
Java Server Pages Servlets
Übersetzungszeitpunkt Zur Laufzeit von der JSP-Engine erzeugt, kann ggf. vorkompiliert werden. Muss manuell übersetzt werden.
Bindung an URL Unter dem tatsächlichen Pfad, innerhalb der Web-Applikation erreichbar. Wird über den Web Deployment Descriptor an eine oder mehrere symbolische URLs gebunden.
Vordefinierte Variablen Stehen direkt zur Verfügung. Müssen über Methoden aus dem Request bzw. Response gebunden werden.
HTML-Code Kann direkt eingefügt werden. Muss über print() und write() ausgegeben werden.
Dokumenttypen Beschränkt auf textbasierte Dokumente. Unterstützt sowohl Text-, als auch Binärformate.
Services Beschränkt auf eine einzige Service-Methode. Eigene Servicemethoden für jeden Request-Typ (PUT, GET, POST)
86
Idee der Tag-Bibliotheken (Taglibs)
87
Verwendung eigener Tags

• Vorraussetzungen für eigen definierte Tags
• Implementierung der Funktionalität ? Tag-Handler
• Package javax.servlet.jsp.tagext.
• Zusammenfassen in Tag-Bibliotheken
• Steuerung des Lebenszyklus eines Tag
• doStartTag() Aufruf bei einem öffnenden Tag
  (Initialisierung)
• doAfterBody() Aufruf unmittelbar vor dem
  schließenden Tag
• doEndTag() Aufruf nach dem schließenden Tag
  (Freigabe)

88
Beispiel eines Tag-Handlers

• package cs.j2ee.tags
• import javax.servlet.jsp.JspWriter
• import javax.servlet.jsp.tagext.TagSupport
• public class SimpleTag extends TagSupport()
• public int doStartTag()
• try
• JspWriter out pageContext.getOut()
• out.print (new Date())
• catch (IOException ioex)
• ioex.printStackTrace()
• return (SKIP_BODY)

89
Tag Library Descriptor

• Festlegung des zum Tag-Handler korrespondierenden
  Tags
• xml-Datei mit der Extension .tld
• Festlegung der taglib-Version
• Festlegung der unterstützten JSP-Version
• Festlegung von Namensräumen für die Taglibs
• Mapping zwischen Java-Klasse und Tag herstellen
• Reservierte Namensräume
• Java, javax, jsp, jspx, servlet, sun, sunw
• Leere Präfixe sind ebenfalls nicht erlaubt

90
Tag Library Descriptor

• lttaglibgt
• lttlib-versiongt1.0lt/tlib-versiongt
• ltjsp-versiongt1.2lt/jsp-versiongt
• ltshort-namegtj2eelt/short-namegt
• lturigtwww.masterclass.de/j2eelt/urigt
• ltdescriptiongtExample Taglt/descriptiongt
• lttaggt
• ltnamegtdatelt/namegt
• lttag-classgtcs.j2ee.tags.SimpleTaglt/tag-classgt
• ltdescriptiongtlt/descriptiongt
• lt/taggt
• lt/taglibgt

91
Tag Library Descriptor

• Einbinden des TLD in die eigene Webapplikation
• Direktes Einbinden in das Webverzeichnis
• Sichtbar unter der URL des Webauftritts
• http//localhost8080/schmietendorf/tlds
• Einbindung des TLD in den Deployment Descriptor
• Verfügbar unter einer virtuellen URL
  (WEB-INF-Ordner)
• Eintrag in die entsprechende web.xml
• lttaglib-urigt lttaglib-locationgt
• Tag-Bibliotheken bleiben dem Benutzer verborgen
• Verwendung in der JSP
• lt_at_ taglib uri/j2ee-tags prefixj2ee gt
• Tag im HTML-Body ltj2eedate /gt

92
Verfügbare Taglibs

• JSTL JavaServer Pages Standard Tag Library
• Standard-API für Tags von SUN
• URL http//java.sun.com/products/jsp/jstl
• Apache Jakarta Taglibs
• Benchmarking, Logging, Cache, JMS ,
• URL http//jakarta.apache.org/taglibs