Aspekte von OODBMS und RDBMS
Download
Report
Transcript Aspekte von OODBMS und RDBMS
Programmierung von Client/ServerAnwendungen
J2EE – Web-Applikationen, Java Server Pages, JavaBeans und Servlets
erstellt in Anlehnung an Stark, T.: J2EE – Einstieg für Anspruchsvolle,
Addison-Wesley, Pearson Studium, München 2005
WS 2006/07
Prof. Dr. Andreas Schmietendorf
1
Ü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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
2
HTML im Rückblick
WS 2006/07
Prof. Dr. Andreas Schmietendorf
3
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
4
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
5
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)
WS 2006/07
Prof. Dr. Andreas Schmietendorf
6
Hypermediale Informationssysteme
Möglichkeiten der Einstellung
Angebot der Internet-ServiceProvider, z.B. T-Online
HTTP-Server
Beispiel: WindowsNT Server
inetpub/wwwroot/default.htm
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
WS 2006/07
TCP/IP-Netz
DSL
Laptop
DFÜ
IBM RS/6000
IBM RS/6000
Einstellung per FTP (RAS), NW-Laufwerke, NFS,
Prof. Dr. Andreas Schmietendorf
7
Hypermediale Informationssysteme
Grundaufbau einer einfachen HTML-Datei:
<HTML>
<!-----Kommentarzeile------->
<HEAD>
<TITLE>Dokumente und Informationen</TITLE>
</HEAD>
<BODY>
<H1>Client/Server-Anwendungen</H1>
<HR>
</BODY>
</HTML>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
8
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  
Verschachtelte Tags führen zu Fehlern
Zusätzliche Attribute bei einleitenden Tag möglich, z.B. die Ausrichtung
einer Überschrift der 2. Kategorie.
Bsp.: <h2 align=center>Ausgabetext<h2>
Kommentare in HTML <!--Kommentar-->
Sonderzeichen im Ausgabetext wie z.B. „ä“ sollten für die international
richtige Darstellung durch „ä“ ersetzt werden
WS 2006/07
Prof. Dr. Andreas Schmietendorf
9
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
10
Hypermediale Informationssysteme
Übersicht zum HTML-Befehlsumfang (1):
Textformatierung (Überschriften <H1>Text</H1>, Absätze <P>, Zentrieren
<CENTER>, Zeilenumbruch <BR>, Trennlienie <HR> )
Textattribute
-
physikalische (<I>...</I>, <B>...</B>, <blink>...</blink>
logische <CITE>...</CITE>, <CODE>...</CODE>)
Listen (z.B. numerierte und unnumerierte Listen)
<OL>
<UL>
<LI>… </LI>
<LI> Äpfel </LI>
</OL>
</UL>
Grafiken anzeigen (<IMG SRC=„Adresse des Bildes>, die Angabe einer alternativen
Text-Ausgabe ist möglich)
Tabellen
<TABLE> <TR> <TH>Kopfzeile der Tabelle</TH> </TR>
<TR> <TD>Datenzelle</TD></TR>
</TABLE>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
11
Hypermediale Informationssysteme
Übersicht zum HTML-Befehlsumfang (2):
Frames für Teilung der Seite in z.B. linken und rechten Bereich
<frameset cols="20%,60%">
<frame src="cmgverw.htm" name="links">
<frame src="ov_cmg.htm" name="rechts">
</frameset>
Hypertextlinks (Start- und Zielpunkt)
Links auf Dokumente: <A HREF = „Adresse des Zieldokuments“>...</A>
Link innerhalb der WWW-Seite:
<A HREF = „#Marke“>...</A>
<A NAME = „Marke“>...</A>
Link auf Internetdienste: email, news, ftp, gopher, telnet
Imagemaps Einteilung einer Grafik in anklickbare Bereiche
WS 2006/07
Prof. Dr. Andreas Schmietendorf
12
Hypermediale Informationssysteme
Übersicht zum HTML-Befehlsumfang (3):
Multimedia- und Fremdprogrammreferenzen (Browserabhängig)
Standard ist das OBJECT-Tag, bei MS Audio mit SOUND-Tag
<OBJECT DATA=„test.avi“ TYPE=„video/x-msvideo></OBJECT>
Java-Applets mit APPLET-Tag
Interaktive Formulare zur Dateneingabe
Formulardefinition:
<FORM ACTION=mailto:...METHOD=POST>
Eingabefelder:
<INPUT TYPE=„text“ NAME=„VARIABLE“>
Auswahlcheckboxen: <INPUT TYPE=„checkbox“ NAME=„VARIABLE“>
Auswahllisten (Scrollbar):
<SELECT NAME="BenchmarkNutzung“SIZE=4 MULTIPLE>
<OPTION>Harwarekenndaten
Bestätigungsbutton:
WS 2006/07
<INPUT TYPE=„submit“ [NAME=„OK-Button“]>
Prof. Dr. Andreas Schmietendorf
13
Java Server Pages – JSP‘s
WS 2006/07
Prof. Dr. Andreas Schmietendorf
14
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
15
Java Server Pages
Bausteine einer JSP:
Ausdrücke der Form <%= Java-Ausdruck %>
Scriptlets der Form <% Java-Code %>
Deklarationen der Form <%! Java-Code %>
Kommentare:
-
<%-- JSP-Kommentar %>
-
<!-- HTML-Kommentar -->
Java-Anweisungen in JSP-Ausdrücken werden nicht mit einem
Semikolon abgeschlossen jeweils nur eine Anweisung!
WS 2006/07
Prof. Dr. Andreas Schmietendorf
16
Java Server Pages
<html>
<body>
Hallo liebe Studenten der FHW Berlin!
<hr>
<p>
Es ist jetzt genau:
<%= new java.util.Date()%>
</body>
</html>
Vergleich:
System.out.print („Es ist jetzt genau „ + new java.util.Date());
WS 2006/07
Prof. Dr. Andreas Schmietendorf
17
Java Server Pages
JSP-Seite unter JSP-examples:
WS 2006/07
Prof. Dr. Andreas Schmietendorf
18
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://localhost:8080/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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
19
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
<Context path="/schmiete"
docBase="C:\jakarta-tomcat-5\schmietendorf"
debug="0" reloadable="true" crossContext="true" />
WS 2006/07
Prof. Dr. Andreas Schmietendorf
20
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
21
Java Server Pages
<html>
<head>
<title>Eine dynamische JSP-Seite</title>
</head>
<body>
<h2>Verwendung vordefinierter Variablen</h2>
<p><hr><p>
<ul>
<li>Hallo liebe Studenten der FHW Berlin!
</li>
<li>Es ist jetzt genau: <%= new java.util.Date()%>
</li>
<li>Sie sind: <%= request.getParameter("name")%>
</li>
</ul>
</body>
</html>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
22
Java Server Pages
WS 2006/07
Prof. Dr. Andreas Schmietendorf
23
Java Server Pages
Alternative Notation für JSP-Ausdrücke:
Ggf. besteht die Forderung XML-konformer JSP‘s
- Bisherige Form:
<%= Ausdruck %>
- XML-konforme Darstellung:
<jsp:expression>Ausdruck</jsp:expression>
Die XML-konforme Darstellung ist case-sensitiv
Auch hier wird nur eine Java-Anweisung verwendet
WS 2006/07
Prof. Dr. Andreas Schmietendorf
24
Java Server Pages
Bisherige Einschränkungen der verwendeten JSP‘s
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: <% beliebiger Java-Code%>
- Def. Einer Folge von Java-Befehlen
- JSP-Scriptlet Ausgaben müssen explizit definiert werden
<% String userName = request.getParameter(“user“);
out.println (Sie sind“ + userName); %>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
25
Java Server Pages
Beispiele für JSP-Scriptlets
Schleifen
<% for (int i=0; i<10; i++) { %>
HTML/JSP-Code
<% } %>
Switch-Abfrage
<% switch (arg) {
case 0 : %> HTML/JSP-Code
case 1 : %> HTML/JSP-Code
braek;
case 2 : %> HTML/JSP-Code
default: %> HTML/JSP-Code
} %>
<%
<%
<%
<%
JSP-Scriplets werden jeweils durch HTML-Code unterbrochen
WS 2006/07
Prof. Dr. Andreas Schmietendorf
26
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
// …
}
}
WS 2006/07
Prof. Dr. Andreas Schmietendorf
27
Java Server Pages
<html>
<head>
<title>Eine dynamische JSP-Seite</title>
</head>
<% String userName = request.getParameter("name");%>
<body>
<h2>Verwendung vordefinierter Variablen - Beispiel 3</h2>
<p><hr><p>
<ul>
<li>Hallo liebe Studenten der FHW Berlin!</li>
<li>Es ist jetzt genau:
<%= new java.util.Date()%></li>
<% if (userName != null) { %>
<li>Sie sind: <%= userName %></li>
<% } else { %>
<li>Sie sind: unbekannt</li>
<% } %>
</ul>
</body>
</html>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
28
Java Server Pages
else-Zweig
WS 2006/07
Prof. Dr. Andreas Schmietendorf
29
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: <%! Java-Code außerhalb des JSP-Scriplet %>
- JSP-Deklarationen sind nicht Bestandteil der JSP-Scriplet!
WS 2006/07
Prof. Dr. Andreas Schmietendorf
30
Java Server Pages
<html>
<head> <title>Eine dynamische JSP-Seite</title></head>
<%! private int count =0;%>
<% String userName = request.getParameter("name");%>
<body>
<h2>Verwendung vordefinierter Variablen - Beispiel 4</h2>
<p><hr><p>
<ul>
<li>Hallo liebe Studenten der FHW Berlin!</li>
<li>Es ist jetzt genau: <%= new
java.util.Date()%></li>
<% if (userName != null) { %>
<li>Sie sind: <%= userName %></li>
<li>Besucher: <%= ++count %></li>
<% } else { %>
<li>Sie sind: unbekannt</li>
<% } %>
</ul>
</body>
</html>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
31
Java Server Pages
14. Aufruf
15. Aufruf
WS 2006/07
Prof. Dr. Andreas Schmietendorf
32
Java Server Pages
Weiteres Beispiel einer möglichen JSP-Deklaration:
<%! 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;
}%>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
33
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
34
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
35
Java Server Pages
Kontrolle von JSPs durch folgende Speicherbereiche:
request – Variable vom Typ javax.servlet.http.HTTPServletRequest
-
Bezug zum Request-Scope
-
Mittels Methode setAttribute() können Objekte hinzugefügt werden
response – Variable vom Typ javax.servlet.http.HTTPServletResponse
-
Manipulation der Antwort an den Server
-
Z.B. Cookies an den Browser senden oder Status-Code setzten
WS 2006/07
Prof. Dr. Andreas Schmietendorf
36
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.HttpSession
-
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
37
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.ServletConfig
-
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
38
Java Server Pages
Kontrolle von JSPs durch folgende Speicherbereiche:
pageContext - Variable vom Typ javax.servlet.jsp.PageServlet
-
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
39
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
40
Java Server Pages
Page – Seitendirektiven 1:
Klassen und Packages importieren
<%@ page import=“java.util.Date“ %>
<%@ page import=“java.util.Date“, “java.math.*“ %>
JSP‘s 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:
<%@ page import=“ownjsp.fhwbln.jsp.MyJsp“
extends=“MyJsp“ %>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
41
Java Server Pages
Page – Seitendirektiven 2:
Parallele Bearbeitung von Client-Anforderungen
<%@ page isThreadSafe=“true“ %> - Standardeinstellung
<%@ page isThreadSafe=“false“ %>
errorPage – Verweis auf eigene Fehlerseiten
<%@ page errorPage=“Fehlerseite.jsp“ %>
page-Attribut contentType (MIME-Type PlugIn Auswahl)
- Teilt dem Browser die Art des nachfolgenden Dokumentes mit
- Realisierung mehrsprachiger Applikationen
WS 2006/07
Prof. Dr. Andreas Schmietendorf
42
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
43
Java Server Pages
WS 2006/07
Prof. Dr. Andreas Schmietendorf
44
Java Server Pages
<html><head><title>Eine dynamische JSP-Seite</title></head>
<body>
<h2>Ein einfaches Login für Web-Anwendungen</h2>
<p><hr><p>
<form method="post" action="Einstieg.jsp">
Login: <INPUT type="text" name="user" />
<INPUT type="submit" value="Absenden" />
<img src="../images/fhw.jpg" >
</form>
<% if (request.getParameter("msg") !=null){
out.println (request.getParameter("msg"));
} %>
</body>
</html>
Login.jsp
WS 2006/07
Prof. Dr. Andreas Schmietendorf
45
Java Server Pages
<%@ page session="true" %>
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ page errorPage="LoginError.jsp" %>
Login.jsp
<%
// 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")) {
%>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
46
Java Server Pages
<jsp:forward page="Login.jsp?msg=Benutzer nicht bekannt!" />
<%
}
// Hinzufügen des Parameters zur aktuellen Session
session.setAttribute ("USER", userName);
}
%>
<%-- keine Ausnahmefehler - weiter zu Content.jsp --%>
<jsp:forward page="Content.jsp" />
Fortsetzung - Login.jsp
WS 2006/07
Prof. Dr. Andreas Schmietendorf
47
Java Server Pages
WS 2006/07
Prof. Dr. Andreas Schmietendorf
48
Java Server Pages
<html>
<head>
<title>Eine dynamische JSP-Seite</title>
</head>
<body>
<h2>Herzlich willkommen im Portal</h2>
<p><hr><p>
Sie sind Benutzer:
<%= session.getAttribute("USER") %>
</body>
</html>
Der Einstieg ins Portal
WS 2006/07
Prof. Dr. Andreas Schmietendorf
49
JSP und JDBC
WS 2006/07
Prof. Dr. Andreas Schmietendorf
50
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
51
JSP und JDBC – Beispiel 1
<html>
<head>
<title>JSP - JDBC Zugriff</title>
</head>
<%@page language="java" import="java.sql.*" %>
<body>
<h2>Datenbankabfrage mittels JSP und JDBC</h2>
<table border="1" with="400">
<tr>
<td><b><i>ID</i></b></td>
<td><b><i>NAME</i></b></td>
<td><b><i>VORNAME</i></b></td>
<td><b><i>ORT</i></b></td>
</tr>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
52
JSP und JDBC – Beispiel 2
<%
// Schritt 1
Class.forName("org.firebirdsql.jdbc.FBDriver");
// Schritt 2
Connection myConn =
DriverManager.getConnection("jdbc:firebirdsql:localhost/3050:
C:/Programme/Firebird/examples/employee.gdb","sysdba","masterk
ey");
// Schritt 3
Statement stmt = myConn.createStatement();
// Schritt 4
ResultSet myResultSet = stmt.executeQuery("select * from
mitarbeiter");
// Schritt 5
if (myResultSet != null) {
%>
// Schritt 6
while (myResultSet.next()) {
String id = myResultSet.getString(1);
String name = myResultSet.getString(2);
String vorname = myResultSet.getString(3);
String ort = myResultSet.getString(4);
WS 2006/07
Prof. Dr. Andreas Schmietendorf
53
JSP und JDBC – Beispiel 3
// Schritt 7
<tr>
<td><%= id %></td>
<td><%= name %></td>
<td><%= vorname %></td>
<td><%= ort %></td>
</tr>
<%
// Schritt 8
} /* Ende von while */
} /* Ende von if */
// Schritt 9 und 10
stmt.close();
// Schritt 11
MyConn.close();
%>
</table></body></html>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
54
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
55
JavaBeans
WS 2006/07
Prof. Dr. Andreas Schmietendorf
56
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/beans/docs)
WS 2006/07
Prof. Dr. Andreas Schmietendorf
57
Java Beans
SUN’s 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.“
WS 2006/07
Prof. Dr. Andreas Schmietendorf
58
Java Beans
WS 2006/07
Prof. Dr. Andreas Schmietendorf
59
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
60
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
61
Java Beans
Softwarekomponentenmodell JavaBeans (aber != EJB‘s)
Konfigurierbare Container
- Kapselung von Anwendungslogik
- Speicherung von Daten (persistieren)
Trennung von Anwendungslogik und Darstellung
- Auslagerung von Logik aus den JSP‘s
- Bessere Wartbarkeit
- Entkopplung der Schichten
WS 2006/07
Prof. Dr. Andreas Schmietendorf
62
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)
WS 2006/07
Prof. Dr. Andreas Schmietendorf
63
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;
}
WS 2006/07
Prof. Dr. Andreas Schmietendorf
64
Java Beans
Verwendung von JavaBeans in JSP‘s:
<jsp:useBean id=“route“ class=“cs.j2ee.beans.RouteBean“ />
oder
<% cs.j2ee.beans.RouteBean route =
new cs.j2ee.beans.RouteBean (); %>
oder als Interface
<jsp:useBean id=“route“ type=„typ.Interface“
class=“cs.j2ee.beans.RouteBean“ />
bzw.
<% typ.Interface route =
new cs.j2ee.beans.RouteBean (); %>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
65
Java Beans
Zugriff auf Attribute der JavaBean:
Auslesen von Property-Werten
<jsp:getProperty name=“route“ property=“start“ />
oder
<%= route.getStart() %>
Setzen von Property-Werten
<jsp:setProperty name=“route“ property=“start“ value=
“Dresden“/>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
66
Java Beans
Steuerung des Gültigkeitsbereichs von JavaBean:
<jsp:useBean id=“route“
class=“cs.j2ee.beans.RouteBean“
scope=“session“ />
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
67
Java Beans
Vorteile von JavaBeans:
Wiederverwendung von Quellcode (JSP‘s & Java-Objekte)
Verständlichkeit
- Vereinfachung der Struktur von JSP‘s
- Darstellung getrennt von der Java-Implementierung
Kapselung
- JSP‘s interagieren mit dem Benutzer
- JavaBeans realisieren die Anwendungslogik
Verwaltung zusammengehöriger Daten
WS 2006/07
Prof. Dr. Andreas Schmietendorf
68
Servlets
WS 2006/07
Prof. Dr. Andreas Schmietendorf
69
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
70
Java Servlets
Das generierte Servlet unserer ersten JSP - 1:
Unter: C:\jakarta-tomcat-5\tomcat50-jwsdp\work\Catalina\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.JspSourceDependent
{
private static java.util.Vector _jspx_dependants;
public java.util.List getDependants() {
return _jspx_dependants;
}
WS 2006/07
Prof. Dr. Andreas Schmietendorf
71
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;
WS 2006/07
Prof. Dr. Andreas Schmietendorf
72
Java Servlets
Das generierte Servlet unserer ersten JSP - 3:
try {
_jspxFactory = JspFactory.getDefaultFactory();
response.setContentType("text/html");
pageContext = _jspxFactory.getPageContext(this,
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;
WS 2006/07
Prof. Dr. Andreas Schmietendorf
73
Java Servlets
Das generierte Servlet unserer ersten JSP - 4:
out.write("<html>\r\n");
out.write("<body>\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("</body>\r\n");
out.write("</html>");
WS 2006/07
Prof. Dr. Andreas Schmietendorf
74
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); }}}
WS 2006/07
Prof. Dr. Andreas Schmietendorf
75
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 JavaStrukturen unübersichtlich
- Mittels der Variable out (Typ javax.servlet.jsp.JspWriter) 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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
76
Java Servlets
Ein selbst erzeugtes Servlet - 1:
package cs.j2ee.servlets;
import
import
import
import
import
import
import
java.util.Date;
java.io.PrintWriter;
java.io.IOException;
javax.servlet.http.HttpServlet;
javax.servlet.http.HttpServletRequest;
javax.servlet.http.HttpServletResponse;
javax.servlet.ServletException;
public class HelloWorld extends HttpServlet {
public void service(HttpServletRequest request,
HttpServletResponse response)
throws IOException,
ServletException {
WS 2006/07
Prof. Dr. Andreas Schmietendorf
77
Java Servlets
Ein selbst erzeugtes Servlet - 2:
// set the contentType
response.setContentType("text/html;charset=ISO8859-1");
// get the PrintWriter
PrintWriter out = response.getWriter();
// create content
StringBuffer content = new StringBuffer();
content.append("<!DOCTYPE html PUBLIC \"//w3c//dtd html 4.0 transitional//en\"
\"http://www.w3.org/TR/REC-html40/strict.dtd\">");
content.append("<HTML><HEAD><TITLE>Ein selbst
geschriebens Servlet</TITLE></HEAD>");
WS 2006/07
Prof. Dr. Andreas Schmietendorf
78
Java Servlets
Ein selbst erzeugtes Servlet - 3:
content.append("<BODY><FONT color=\"green\"
face=\"arial\">");
content.append("<CENTER>Hallo Studenten der FHW
Berlin</CENTER><UL>");
content.append("<LI>Es ist jetzt genau ");
content.append(new Date());
content.append("</LI></UL></FONT></BODY></HTML>");
// write out
out.print (content.toString());
}
}
WS 2006/07
Prof. Dr. Andreas Schmietendorf
79
Java Servlets
Schritte zur Ausführung des Servlets:
Übersetzen des Servlets mittels eines Java-Compilers
- Verwendung einer entsprechende Entwicklungsumgebung
- 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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
80
Java Servlets
WS 2006/07
Prof. Dr. Andreas Schmietendorf
81
Java Servlets
Der Web Deployment Descriptor - 1:
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Client/Server-Programmierung</display-name>
<description>
FHW Berlin
</description>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
82
Java Servlets
Der Web Deployment Descriptor - 2:
Für jedes Servlet benötigen wir ein <servlet>-Tag
Servlet wird bereits bei der Initialisierung geladen
Prio 1-10 (1 - zuerst geladen, 10 – zuletzt geladen)
<!-- Bind Servlet to symbolic name -->
<servlet>
<servlet-name>WelcomeServlet</servlet-name>
<servlet-class>cs.j2ee.servlets.HelloWorld</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
83
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!!
<!-- Map servlet to URL -->
<servlet-mapping>
<servlet-name>WelcomeServlet</servlet-name>
<url-pattern>/servlets/HelloWorld</url-pattern>
</servlet-mapping>
</web-app>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
84
Java Servlets
Java Server Pages
Servlets
Übersetzungszeitpunkt
Zur Laufzeit von der JSPEngine 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 URL‘s 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)
WS 2006/07
Prof. Dr. Andreas Schmietendorf
85
Idee der Tag-Bibliotheken (Taglibs)
WS 2006/07
Prof. Dr. Andreas Schmietendorf
86
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)
<TAG>
doStartTag()
WS 2006/07
Rumpf
Beginn der Bearbeitung
des Rumpfes
</TAG>
doAfterBody()
Prof. Dr. Andreas Schmietendorf
doEndTag()
87
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 {
}
}
WS 2006/07
JspWriter out = pageContext.getOut();
out.print (new Date());
} catch (IOException ioex){
ioex.printStackTrace();
}
return (SKIP_BODY);
Prof. Dr. Andreas Schmietendorf
88
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
WS 2006/07
Prof. Dr. Andreas Schmietendorf
89
Tag Library Descriptor
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>j2ee</short-name>
<uri>www.masterclass.de/j2ee</uri>
<description>Example Tag</description>
<tag>
<name>date</name>
<tag-class>cs.j2ee.tags.SimpleTag</tag-class>
<description>…</description>
</tag>
</taglib>
WS 2006/07
Prof. Dr. Andreas Schmietendorf
90
Tag Library Descriptor
Einbinden des TLD in die eigene Webapplikation:
Direktes Einbinden in das Webverzeichnis
-
Sichtbar unter der URL des Webauftritts
-
http://localhost:8080/schmietendorf/tlds
Einbindung des TLD in den Deployment Descriptor
-
Verfügbar unter einer virtuellen URL (WEB-INF-Ordner)
-
Eintrag in die entsprechende web.xml
<taglib-uri> & <taglib-location>
-
Tag-Bibliotheken bleiben dem Benutzer verborgen
Verwendung in der JSP
<%@ taglib uri=„/j2ee-tags“ prefix=„j2ee“ %>
Tag im HTML-Body: <j2ee:date />
WS 2006/07
Prof. Dr. Andreas Schmietendorf
91
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
…
WS 2006/07
Prof. Dr. Andreas Schmietendorf
92