Architektur von Web- Datenbanksystemen. © Prof. T. Kudraß, HTWK Leipzig Schichtenarchitektur Aufteilung einer Web-DB-Anwendung in verschiedene Schichten

Architektur von Web-Datenbanksystemen

© Prof. T. Kudraß, HTWK Leipzig

Schichtenarchitektur

Aufteilung einer Web-DB-Anwendung in verschiedene Schichten

Logische Schichten vs. physische Schichten Physisch:

– Aufteilung der Anwendung auf Client, DB-Server und Middleware

– Middleware: ein Webserver oder mehrere Application Server

Logisch:– Einordung in einzelne Schichten hinsichtlich der

Aufgabenverteilung– Gängiges Modell: 3-Schichten-Architektur


3-Schichten-Architektur

Präsentationsschicht– Visualisierung der Dokumente auf Anwenderseite– Keine Anwendungslogik zur Erstellung der Seiten (thin clients)– Client = Rechner mit Browser einschl. PlugIns

Anwendungslogikschicht– Weiterleitung von Anfragen des Client an den entsprechenden

Dienst, Datenbankanfragen, Erstellung dynamischer Seiten und Zurücksendung an den Client

– Weitere Aufgaben: Verwaltung von Transaktionen Lastverteilung der Anfragen Sicherheitsaufgaben

Datenhaltungsschicht– Speicherung der Daten + Datenzugriff– Typischerweise Datebanksystem (auch Dateien möglich)


Analogie: Winsbergs Modell

Remote Presentation Distributed Logic Remote Data Access

Presentation Mgr. Presentation Mgr. Presentation Mgr.

Presentation Logic

Presentation LogicPresentation Logic

Data Logic

Data Logic

Data Manager Data ManagerData Manager

Data Logic


Verteilung der Schichten

Anorexic Client Big-Boned Client Fat Client

Web Browser View View

Application Model

Application ModelApplication Model

Domain

Domain

Persistence PersistencePersistence

Domain

Application Model

View: Servlets


Klassifikation von Web-Informationssystemen (WebIS)

unterschiedliche Komplexitätsgrade Anwendungsgebiet bestimmt Architektur in komplexen WebIS mehrere Architektur-

varianten gleichzeitig vorhanden Varianten:

1. Statische WebIS2. WebIS mit DB-Unterstützung3. Applikationsorientierte WebIS4. Ubiquitäre WebIS5. Portal-orientierte WebIS


Statische WebIS

Dokumente in statischer Form auf Webserver abgelegt Basis: HTTP-Protokoll: Web-Client <-> Web-Server einfache Interaktivität (CGI, HTML-Formulare) Vermischung von Präsentation, Inhalt und Hypertext manuelle Pflege, Gefahr von Inkonsistenzen


Statische WebIS: Bewertung

Vorteile– Einfachheit und Stabilität– niedrige Antwortzeiten

Einsatzgebiet– geringe Anzahl von Webseiten– niedrige Änderungsfrequenz– Heterogenität der Webseiten hinsichtlich

Hypertextstruktur und Präsentation


WebIS mit DB-Unterstützung

Vorteile – vereinfachte Aktualisierung der Webseiten– hoher Grad an Interaktivität

strukturierte Suche auf Basis von DB-Anfragen dezentrale Aktualisierung des Datenbestandes

Nachteile– Verwaltung der Abbildungsvorschriften für

Zusammenstellung der Webseite erforderlich

Web-Client Web-Server

DBS-Server

Präsentation

Inhalt


WebIS mit DB-Unterstützung (Forts.)

Motivation (Einsatzgebiet z.B. Produktkatalog): – große Anzahl von Webseiten– hohe Änderungsfrequenz– Homogenität der Webseiten hinsichtlich Hypertext-

struktur und Präsentation– Nutzung existierender (Legacy)Datenbestände

Weiterführung – Integration heterogener verteilter Daten

strukturierte Daten (Datenbanken) unstrukturierte Daten (Textdokumente) semistrukturierte Daten (HTML-Dateien)


Applikationsorientierte WebIS

Funktionalität des Applikations-Servers– DB-Anbindung– Transaktionsmanagement– Sicherheit– Lastausgleich– Caching


DBS-Server

PräsentationApplikationslogik

Applikations-Server

Inhalt

IIOP


Applikationsorientierte WebIS (Forts.)

Produkte– kombinierte Web-/Applikationsserver: Coldfusion, Netscape

Application Server, Oracle Internet Application Server– Enterprise-Application-Server: WebSphere (IBM), WebLogic

(Bea Systems)

Motivation– hohe zu erwartende Server-Last, bei großer Anzahl gleich-

zeitig zugreifender Clients– komplexe Geschäftslogik, z.B. bei Online-Kauf oder Online-

Buchung)– hohe Transaktionsorientiertheit, z.B. bei Online-Banking-

Anwendungen


Ubiquitäre WebIS

Ziel– richtigen Dienst – zum richtigen Zeitpunkt– am richtigen Ort– in der richtigen Form

anbieten


DBS-Server

PräsentationApplikationslogik

Applikations-Server

Inhalt Anp

assu

ngs-

kom

pone

nte


Ubiquitäre WebIS (Forts.)

Produkte– Oracle Wireless Application Server– WebSphere Transcoding Publisher (IBM)

Motivation– Zugriff auf die im WebIS präsentierte Information nicht nur

über WWW, sondern z.B. auch über mobile Endgeräte– Anpassung der Inhalte und/oder der Präsentationsaspekte an

Benutzerprofile (Personalisierung)– Realisierung lokations/zeitabhängiger Dienste, wie z.B.

lokationssensitiver Museumsführer


Portal-orientierte WebIS


Daten 1

Präsentation

Aggregation

Inhalt

Applikationslogik

Portlet 1

Web Service 1

Portlet 2

Web Service 2

Portlet 3

Web Service 3

Daten 2 Daten 3

Architektur eines portal-orientierten WebIS


Portalorientiertes WebIS (Forts.)

Große Anwendungen mit vielen Diensten erfordert portalorientierte Architektur

Portal = zentraler Zugang zu einem Anwendungssystem, welches verschiedene Dienste und Anwendungen integriert und z.B. Funktionen zur Suche oder Personalisierung bereitstellt

Portlets = Teile von Dokumenten aus unterschiedlichen Quellen

Zusammensetzen von Portlets zu ganzen Seiten, die über Web-Server an den Client verschickt werden

Einsatz von Web Service-Technologien, die den Aufruf von Diensten über definierte Schnittstellen ermöglichen

Vorteil hohe Flexibilität bei der Verwendung der Portlets


HTTP-Protokoll

Hypertext Transfer Protokoll (HTTP) für Kommunikation zwischen Web-Server und Client

Funktionsweise: Request-Response-Prinzip– HTTP-Request: URL – HTTP-Response: gewünschte Dokument

Verbindungs- und statusloses Protokoll: keine dauerhafte Verbindung, keine Speicherung des Zustands zwischen Client und Server

Methoden zur Anforderung eines Dokuments– GET: Client fordert die angegebene URL an, wobei eventuelle

Parameter im String der URL mitgegeben werden– POST: Client schickt Daten an den Server, wobei diese nicht in der

URL sondern direkt im Header der Anforderung übergeben werden– HEAD, PUT, DELETE: keine Bedeutung für die Entwicklung von

Webapplikationen


HTTP Request

1. Zeile: Methode, Ressource, Version des HTTP-ProtokollsGET http://www.test.de/index.html HTTP/1.0

Mehre Message Header, die zusätzliche Informationen übertragen

– Accept: MIME-Typen, die der Client verarbeiten kann– Host: Domainname des Webservers– Referer: URL der Herkunftsressource– User-Agent: Name und Version des Clientbrowsers– Authorization: Benutzername und Paßwort des Clients,

Authorization Header als Reaktion auf WWW-Authenticate-Header des Servers zum Zugriff auf das gewünschte Dokument

Bei Methode POST: Anhängen von Daten (aus Formular) an die Headerinformationen, z.B.Eingabe1=Strasse&Eingabe2=54455


HTTP Response

Status– Version des verwendeten HTTP-Protokolls– Statuscode– textuelle Beschreibung des Status Beispiel:

Optionale Response-Header– Server: Name und Version des Webservers– WWW-Authenticate: Verlangt vom Client eine Authentifizierung und

gibt u.a. das Authentifizierungsschema an– Location: URL der Ressource

Eigentliches Dokument (falls eines zurückgeliefert werden soll)<HTML><HEAD><TITLE>Titelzeile</TITLE></HEAD><BODY> …


Anbindungsarchitekturen


Anbindungsarchitekturen - Varianten

1. Anwendung mit statischen Seiten: Datenbankinhalte manuell einarbeiten, keine Kommunikation mit der Datenbank

2. Realisierung der Webanwendung als CGI-Programm: Datenbankzugriff vom Programm. Die fertige HTML-Seite wird zum Client übertragen.

3. Applets werden zum Client übertragen und dort ausgeführt. Die Kommunikation mit der DB findet dabei direkt mit dem Client statt, z.B. über JDBC (nicht HTTP!)

4. Server-APIs: serverseitige Erweiterungen für den Zugriff auf die Datenbank und den Aufbau der HTML-Datei.

5. Einsatz von Servlets in der Serverumgebung, erfordert spezielle Servlet Engine und eine Java Virtual Machine (JVM). DB-Zugriff erfolgt z. B. über die JDBC-API oder direkt, wenn Servlet Engine im Datenbankserver integriert ist.

6. Auslagerung komplexer Programmlogik auf einen Applikationsserver. Dieser realisiert auch die Verbindung zur Datenbank, wobei DB-Verbindungen zur Performance-Verbesserung zwischengespeichert werden.

7. Erstellung der HTML-Dateien über einen Präprozessor: Verarbeitung von XML- und XSL-Dateien (siehe auch Vorlesung XML-Datenbanken / 7. Semester)


Anbindungstechnologien


Anforderungen an eine DB-Server-Anbindung

Integrierte Benutzerschnittstelle– Verschiedene Medientypen– Browser-Darstellung, keine proprietären Formate

Interaktivität– erfordert zustandswahrende Verbindung

Konsistenz und Datenintegrität Performance Sicherheit

– Programme, die von Web-Server geladen werden Skalierbarkeit Offenheit

– Konflikt mit Performance (Java vs. Microsoft)


Client-Seitige DB-Anbindungen

Prinzip:– Übertragung von Java Applets (plattformunabhängiger

Bytecode) vom Web-Server zum Client– Direkte Verbindung zum Datenbank-Server über JDBC oder

SQLJ– Ausführung der Clients durch eine Java Virtual Machine (JVM)


DBS-Server

JVMApplet

JDBC


Eigenschaften der clientseitigen Anbindung über Applets

Datendarstellung– Anwendungslogik und Präsentationslogik clientseitig unterstützt– Web-Client erwartet kein HTML, sondern die direkt

übertragenen Daten, die beliebig visualisiert werden könnenDateneingabe

– Volle Funktionalität einer Programmiersprache zur Validierung der Eingabe und Verarbeitung der Daten aus einer DB

Transaktionsunterstützung– DB-Verbindung über die gesamte Laufzeit der Anwendung

offen– Speicherung von Zuständen und Durchführung “langer“

Transaktionen, die voneinander abhängen– Beliebig lange Transaktionen unter Nutzung des 2PC

realisierbar -> Mehrschritt-Interaktionen möglich (im HTTP nur mit Umwegen)


Nachteile von Applets

Client-seitige Unterstützung ist notwendig (z.B. JVM) Java-Sicherheitsrestriktionen erlaubt Applets nur

Verbindungen zum Rechner, von wo sie geladen wurden

erzwingt Anordnung aller Server auf einem Rechner (Flaschenhalsproblem)

– Abhilfe: explizite Gewährung von Verbindungsrechten; signierte Applets

Initial lange Ladezeiten für die Applets– Abhilfe: persistente Speicherung von Applets auf der Client-Seite

(Nutzung von JAR-Dateien, Kombination mit signierten Applets)– Java Interfaces: Nachladen der Implementierung zur Laufzeit

Benutzerinteraktion und Datenrepräsentation müssen programmiert werden


Serverseitige DB-Anbindung

Generierung von HTML-Seiten im Server und Zurücksenden an den Client

Daten aus der Datenbank können in HTML-Dokument enthalten sein

2 Ansätze (je nach Generierungsmethode)– Externe Programme: erzeugen den HTML-Code des

Dokuments (HTML-Generierende Anwendungen)– Erweiterung der Serverfunktionalität: Anreicherung des HTML-

Codes um spezifische Funktionalitäten zum Einfügen von dynamischem Inhalt ins Dokument (HTML-Erweiterungen)


Serverseitige Anbindung: Externe Programme


Serverseitige Anbindung: Erweiterung der Serverfunktionalität


Vergleich der client- und serverseitigen Anbindung

Präsentation und Eingabe von Daten– Clientseitig:

alle Darstellungsmöglichkeiten der verwendeten Programmiersprache

Prüfung von Benutzereingaben vor Absenden der Anfrage abhängig von Installation aller benötigten Programme / Plug-Ins

auf der Clientseite

– Serverseitig: Dokumente können nur die Darstellungsmöglichkeiten von HTML

nutzen Überprüfung von Benutzereingaben durch clientseitige

Skriptsprache (Java Script) oder nach Senden der Anfrage Anzeige der Seiten auf beliebigem Browser, keine zusätzliche

Installation von Programmen auf Clientseite erforderlich


Vergleich der client- und serverseitigen Anbindung (2)

Datenbankanbindung und Transaktionsunter-stützung– Clientseitig:

Direkte Verbindung zwischen Anwendung und Datenbank (ohne HTTP)

DB-Verbindung kann über die Laufzeit offen bleiben lange Transaktionen möglich

– Serverseitig: DB-Verbindung wird nur von Seiten des Web- oder

Applikationsservers aufgebaut, keine Verbindung von der Clientseite über das zustandslose HTTP-Protokoll

mehrschrittige Anfragen eines Clients an die DB nur über Umwege realisierbar


Vergleich der client- und serverseitigen Anbindung (3)

Performance– Clientseitig:

Lange Ladezeit: Anwendung muß komplett zum Client übertragen werden

Ausführungsgeschwindigkeit abhängig von Leistungsfähigkeit des Clientrechners

Gute Performance bezüglich der Anfrage an die Datenbank, da direkte Kommunikation über DB-Protokolle

– Serverseitig: Ausführungsgeschwindigkeit davon abhängig, ob jedesmal ein

Programm gestartet werden bzw. HTML-Dokumente nach Skripteinschüben geparst

Kommunikation zur Datenbank ist langsamer als bei clientseitiger Anbindung, da Umweg über Web- oder Applikationsserver


Oracle Application ServerOracle 9iAS


Oracle HTTP Server


Oracle HTTP Server im Detail

Basiert auf Apache HTTP Server und wurde um einige Funktionalitäten erweitert (Oracle-spezifische Module)

HTTP-Listener wartet auf ankommende Anfragen vom Client und leitet diese entsprechend ihres Typs an das jeweilige Modul im Server

Wichtige Module:– mod_perl: leitet Anfragen an den Perl-Interpreter weiter, der im

HTTP-Server enthalten ist, zur Unterstützung der CGI-Schnittstelle– mod_plsql: Anfragen an gespeicherte Prozeduren in der Datenbank– mod_oc4j: Modul für die Kommunikation mit dem Oracle 9iAS

Container für J2EE-Anwendungen– mod_osso: Single Sign-On für alle Oracle9iAS Komponenten– mod_ossl: SSL-Verbindung zwischen HTTP-Server und Client

(HTTPS)


Serverseitige Technologien im Überblick

CGI (am Beispiel Perl) Web-Server API Server Side Include (SSI) Active Server Page (ASP) PL/SQL und PL/SQL Server Page (PSP) PHP Übergreifende Technologien

– Java Database Connectivity (JDBC)– SQLJ– Java und J2EE (Enterprise Java Beans)

Java Servlet Java Server Page (JSP)


Common Gateway Interface (CGI)

Keine Programmiersprache Kann mit allen Sprachen realisiert werden, die Zugriff

auf Umgebungsvariable sowie die Standardein- und ausgabe erlauben (z.B. Perl, C, C++)

Standardisierte Schnittstelle für die Kommunikation zwischen Web-Server und externen Programmen (Übergabe von Daten von HTML-Seiten an Programme)

Aufbau– Verschiedene Umgebungsvariablen für die Datenübertragung

Web-Server CGI-Programm– Variablen mit festem Namen bei jeder Client-Anfrage neu

initialisiert und vom CGI-Programm für die HTML-Generierung nutzbar


Umgebungs-variablen einer CGI-Anwendung


Allgemeiner Ablauf der Programmausführung bei CGI

Allgemeines Prinzip:

Client (Anwender) Server-Rechner

HTML-Dateimit Formular Daten-

bank

WWW-Server

automatischerzeugteHTML-Datei

CGI-Skript

automatischerzeugteHTML-Datei

1. Formularabschicken

übertragen

2. CGI-Skriptaufrufen

5. HTML-Dateiübertragen

3. DB abfragenAbfrage-Report der DB auswerten

4. HTML-Datei aus Abfrage-Report erzeugen


Ablauf der Verarbeitung bei Ablauf eines CGI-Programms


CGI-Programmbeispiel (mSQL)


CGI-Programmbeispiel (Perl)print "Content-type: text/html\n\n";

$values = <STDIN>;($name, $wert) = split( /=/, $values);$name =~ s/\%(..)/pack("c",hex($1))/ge; $wert =~ s/\%(..)/pack("c",hex($1))/ge;

print "<HTML>", "<HEAD>", "<TITLE>Testseite mit Perl ohne cgi.pm</TITLE></HEAD>";

print "<BODY>", "<H1>Testseite mit Perl ohne cgi.pm</H1>";

if ($wert) { print ("Hallo $wert.<p>");

# Zugriff auf CGI-Umgebungsvariableprint ("Client-IP-Adresse: $ENV{REMOTE_ADDR}");

}

print '<FORM method=POST>Bitte Namen eingeben: ';print '<input type="text" name="txtname" size="30">';print '<INPUT TYPE="submit">';print "</FORM>",

"</BODY>","</HTML>";


Ausgabe der Beispielseite


CGI-Programbeispiel (gleiche Seite) mit Perl-Modul cgi.pm

use CGI qw(:standard);# Variable name auslesen

$name = param("name");# Header schreiben: Content-type: text/html

print header; # Start-HTML mit Titel

print start_html("Testseite mit Perl und cgi.pm"); # Ausgabe Überschrift des Typs H1

print h1("Testseite mit Perl und cgi.pm"); # Wenn Name gesetzt, ausgeben

if ($name) { print ("Hallo $name.<p>");

# Zugriff auf CGI-Umgebungsvariableprint ("Client-IP-Adresse: $ENV{REMOTE_ADDR}");

}# Formularkopf

print start_form; # Eingabefeld für Name mit Bezeichnung Name

print ("Bitte Namen eingeben: ", textfield("name",""));# Submit-Button

print submit(-name=>'button_submit', -value=>'Submit'); # Formularende

print end_form; # HTML-Ende (</BODY></HTML>)

print end_html();


CGI Bewertung

Vorteile:– Unterstützung durch alle Web-Server– anforderungsspezifisch programmiert– schnell und flexibel

Nachteile:– Pro Interaktion Start eines CGI-Prozesses / Aufbau einer DB-

Verbindung (Verbesserung FastCGI)– Kein Transaktionskonzept zwischen Client und WWW-Server,

Problem der Realisierung von Zuständen– Logische Formular-Eingabefehler erst im CGI-Programm erkannt– Sicherheit (da Zugriff auf Betriebssystem-Ressourcen des Web-

Servers)– Aufwendige Programmerstellung– Formatierung des Dokuments problematisch, da generiert


Web-Server API

Prinzip:– nutzereigene Funktionen (Custom Functions) und servereigene

Funktionen (Server Application Functions) auf Basis des API des Web-Servers

– Kein externes Programm für DB-Zugriff mehr notwendig– Server entscheidet anhand URL, ob (prozeßinterne)

Erweiterungsfunktion aufgerufen werden muß Vorteile:

– Sitzungen können im Web-Server verwaltet werden– Performance-Gewinn durch dauerhafte DB-Verbindung und

gemeinsame Nutzung des Hauptspeichers Nachteile:

– Gefahr des Hängenbleibens offener DB-Verbindungen– Proprietäre Web-Server-Software (z.B. Internet Server API (ISAPI)

von Microsoft inkompatibel zu Netscape Server API (NSAPI)


Server Side Includes (SSI)

Prinzip:– Erweiterung der Funktionalität von Web Servern – SSI = dynamische HTML-Dokumente, angereichert

mit speziellen Steuerungsbefehlen in HTML-Syntax und DB-Zugriffsfunktionalität (z.B. Anzeige aktueller Uhrzeit oder Börsenkurse)

– Ebenfalls möglich: Aufruf anderer Anwendungen (z.B. CGI-Programme, BS-

Kommandos) und Erzeugung eines neuen Prozesses Verarbeitung regulärer HTML-Formulare


SSI mit LiveWire


NS-API

SSJS-Funktionen

LiveWire

DBS-Server

OCI

HTTP<HTML>...<SERVER>database.CONNECT(...)result = database.cursor(“SELECT name,age FROM Person“)name1 = result.nameage1 = result.agedocument.WRITELN(name1 + “,“ +

age1 + “<BR>“)name2 = result.name...</SERVER></HTML>

<HTML>...<SERVER>database.CONNECT(...)result = database.cursor(“SELECT name,age FROM Person“)name1 = result.nameage1 = result.agedocument.WRITELN(name1 + “,“ +

age1 + “<BR>“)name2 = result.name...</SERVER></HTML>

SSI-Beispiel mit LiveWire


Active Server Pages (ASP)

HTML Dokument mit eingebetteten Anweisungen in VBScript oder JScript

ASP Bestandteil des Internet Information Server große Funktionalität durch Mächtigkeit der Skript-

Sprachen (aber geringer als Java/C++) Einbettung von SQL in Skriptsprache (DB-Zugriff über

ODBC und ADOs) Session Management mit Hilfe von Session-IDs (von

Cookies übertragen) Zugriff auf Formular- und Umgebungsvariablen


Ablauf der Verarbeitung mit PL/SQL

Entwicklungsunterstützung durch WebServer Developer‘s Toolkit (Menge von Packages)

HTP (HyperText Procedures) HTF (HyperText Functions)– erleichtern die Generierung von HTML-Tags aus

PL/SQL heraus

OWA_UTIL– Dienstfunktionen für eine bequemere Generierung

von HTML-Output


Toolkit - Beispiele

htp.title(‘My First Page Title‘);htp.title(‘My First Page Title‘);PL/SQL

HTML<TITLE>My First Page Title</TITLE><TITLE>My First Page Title</TITLE>

Funktionsauruf title:=htf.title(‘My First Page Title‘)title:=htf.title(‘My First Page Title‘)

Verschachtelung

htp.center(htf.header(1,‘My First HTML Header - Level 1‘));htp.center(htf.header(1,‘My First HTML Header - Level 1‘));

<CENTER<<H1>My First HTML Header - Level 1</H1></CENTER><CENTER<<H1>My First HTML Header - Level 1</H1></CENTER>


Toolkit - Überblick

1. Print-Prozeduren2. Struktur-Tags3. Head-Related Tags4. Body Tags5. List Tags6. Character Format Tags7. Form Tags8. Table Tags9. OWA_UTIL Package


Beispiel: Web Server Developer Kit

CREATE OR REPLACE PROCEDURE home_page AS BEGIN

htp.htmlOpen; htp.headOpen;htp.title(‘My home page‘);htp.headClose;htp.bodyOpen;htp.print (‘This is the home page of ‘|| user ||‘generated on ‘ || sysdate || ‘.‘);htp.bodyClose;htp.htmlClose;

END;

CREATE OR REPLACE PROCEDURE home_page AS BEGIN

htp.htmlOpen; htp.headOpen;htp.title(‘My home page‘);htp.headClose;htp.bodyOpen;htp.print (‘This is the home page of ‘|| user ||‘generated on ‘ || sysdate || ‘.‘);htp.bodyClose;htp.htmlClose;

END;


PL/SQL Server Pages (PSP)Grundidee

– Internet-Seiten mit dynamischer Präsentation von Inhalten durch Einsatz von PL/SQL-Anweisungen

– Server-Side Scripting (Generierung der Seiten im DB-Server - nicht im Webserver)

– Basiert auf PL/SQL Web Toolkit– Bestandteil von Oracle Application Server (OAS)

und Oracle WebDB– Einbindung dynamischer Inhalte durch PL/SQL-

Skripte, durch spezielle Tags gekennzeichnet


PSP Beispiel

<%@ page language="PL/SQL" %><%@ plsql procedure="psp_bspseite" %><%@ plsql parameter="p_name" default="null"%><HTML><HEAD><TITLE>Beispielseite mit PL/SQL Server Page</TITLE></HEAD><BODY><H1>Beispielseite mit PL/SQL Server Page</H1><%-- Inhalt des Parameters p_name anzeigen, wenn belegtif not(p_name is null) then %>Hallo <%=p_name%>.<p>Client-IP-Adresse: <%=owa_util.get_cgi_env('REMOTE_ADDR')%><%END if;%>

<FORM method=POST>Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"></FORM></BODY></HTML>

<%@ page language="PL/SQL" %><%@ plsql procedure="psp_bspseite" %><%@ plsql parameter="p_name" default="null"%><HTML><HEAD><TITLE>Beispielseite mit PL/SQL Server Page</TITLE></HEAD><BODY><H1>Beispielseite mit PL/SQL Server Page</H1><%-- Inhalt des Parameters p_name anzeigen, wenn belegtif not(p_name is null) then %>Hallo <%=p_name%>.<p>Client-IP-Adresse: <%=owa_util.get_cgi_env('REMOTE_ADDR')%><%END if;%>

<FORM method=POST>Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"></FORM></BODY></HTML>


Schrittfolge PSP

Kompilieren der PSP-Datei mittels loadpsp Erzeugen einer gespeicherten Prozedur in der

Datenbank (Procedure-Tag) HTML-Anweisungen werden unter Verwendung des

PL/SQL Web-Toolkits in Print-Anweisungen des HTTP-Pakets umgewandelt

PL/SQL-Anweisungen der Skripteinschübe werden unverändert übernommen

Komfortablere Entwicklung, da automatische Übersetzung


PSP Beispiel – Generierter PL/SQL Code (Gespeicherte Prozedur)

( p_name IN VARCHAR2 default null) ASBEGIN NULL;htp.prn(‘<HTML><HEAD><TITLE>Beispielseite mit PL/SQL Server Page</TITLE></HEAD><BODY><H1>Beispielseite mit PL/SQL Server Page</H1>‘);

-- Inhalt des Parameters p_name anzeigen, wenn belegtif not(p_name is null) thenhtp.prn(‘Hallo ‘);htp.prn(p_name);[. . .]

( p_name IN VARCHAR2 default null) ASBEGIN NULL;htp.prn(‘<HTML><HEAD><TITLE>Beispielseite mit PL/SQL Server Page</TITLE></HEAD><BODY><H1>Beispielseite mit PL/SQL Server Page</H1>‘);

-- Inhalt des Parameters p_name anzeigen, wenn belegtif not(p_name is null) thenhtp.prn(‘Hallo ‘);htp.prn(p_name);[. . .]


Verarbeitung einer PSP

1. Weiterleiten der Anfrage vom Browser an den Modul mod_plsql

2. Verbindung zur Datenbank, Ausführung der gespeicherten Prozedur

3. Erzeugung einer HTML-Seite durch Prozedur

4. Zurücksenden des HTML-Dokuments an mod_plsql

5. Zurücksenden der HTML-Seiteals HTTP-Response zumanfragenden Client


Vorteile von PSP

Trennung von Anwendungs- und Präsentationslogik– HTML-Anweisungen und PL/SQL Code separat– Abgrenzung durch PL/SQL-spezifische Tags

Leichte Erlernbarkeit Einfacher Zugriff auf Daten der Datenbank

– Kein Umweg über HTTP oder JDBC Ausführung im Server (PSP selbst in der DB) Verbindung mit anderen Skriptsprachen möglich

– z.B. Javascript oder Visual Basic-Script (zur Prüfung von Benutzereingaben)

– nicht kombinierbar mit anderen serverseitigen Scripting-techniken


Nachteile von PSP

Stärkere Beanspruchung des DB-Servers– Statische Seiten besser im Web-Server speichern

Plattformabhängigkeit– Beschränkt auf Oracle– Migration auf andere DB erfordert Neuentwicklung

der Anwendung


PHP

PHP = Personal Homepage Tools (war ursprünglich eine Sammlung von Tools und Makros)

entwickelt von Rasmus Lerdorf 1994, Open Source Produkt

serverseitige, in HTML eingebettete Script-Sprache (Ausführung auf dem Webserver)

plattformunabhängig unterstützt umfangreiche Menge von Oracle-

Funktionen (erfordert Installation im Web-Server) verwandt mit

– Active Server Pages (ASP) von Microsoft– Java Server Pages (JSP)– PL/SQL Server Pages (PSP) von Oracle


PHP

PHP-Seite als Script-Datei – Extension .php – Verarbeitung durch PHP-Prozessor

Einbettung von Skripteinschüben in spezielle Tags– <? echo “Hello world!“ ?>– <?php echo “Hello world!“; ?>– <script language=“php“>

echo “Hello world!“;</script>


Verarbeitung einer PHP-Seite


PHP Beispiel<HTML><HEAD><TITLE>Testseite mit PHP</TITLE></HEAD><BODY><H1>Testseite mit PHP</H1><?php// Lesen des per HTTP-Post übertragenen Parameters aus Array$p_name = $_POST['p_name'];

if ($p_name) {// Namen ausgeben, wenn eingegeben.

print("Hallo $p_name.<p>");// Zugriff auf Umgebungsvariable

print("Client-IP-Adresse: ".$_SERVER['REMOTE_ADDR']);

}</script><FORM method="POST">Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"></FORM></BODY></HTML>

<HTML><HEAD><TITLE>Testseite mit PHP</TITLE></HEAD><BODY><H1>Testseite mit PHP</H1><?php// Lesen des per HTTP-Post übertragenen Parameters aus Array$p_name = $_POST['p_name'];

if ($p_name) {// Namen ausgeben, wenn eingegeben.

print("Hallo $p_name.<p>");// Zugriff auf Umgebungsvariable

print("Client-IP-Adresse: ".$_SERVER['REMOTE_ADDR']);

}</script><FORM method="POST">Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"></FORM></BODY></HTML>


Java und Datenbanken

Java Database Connectivity (JDBC)– Idee– Drivertypen– Klassen und Schnittstellen

SQLJ J2EE Anwendungen Java Servlets Java Server Pages


Java Database Connectivity (JDBC)

Motivation:– Zugriff auf SQL-Datenbanken mit Java benötigt– Nachteil selbstgestrickter Java-Zugriffsmethoden

aufwendig fehlerbehaftet nicht einfach portierbar

– Überwindung des Mismatch zwischen Java (objektorientiert, ohne Pointer) C (prozedural, mit Pointern) SQL (mengenorientiert)

Beziehung zu ODBC– Wurde in Anlehnung an ODBC (Open Database Connectivity)

entwickelt und mit einer ähnlichen Klassenbibliothek ausgestattet


JDBC (Forts.)

DB-Kommunikation erfolgt über ein Call Level Interface (CLI)

Basiert auf Java: kann Objekte direkt verwenden, um DB-Objekte und ihre Operationen direkt und natürlich darzustellen

– Beispiel: Objekt Connection mit einer Methode close()

JDBC-Klassenbibliothek– Seit JDK 1.1 im Sprachumfang enthalten, wird ständig um

weitere Funktionalität ergänzt– Trennung in ein “Core API“ und “Standard Extension API“


JDBC Entwurfsziele

Call-Level Dynamic SQL API– Äquivalent zu ODBC und X/Open CLI– Allgemeines API, das die Basis-SQL-Funktionalität unterstützt– Höhere APIs (z.B. mit Mapping Klassen-Tabellen) können darauf

aufsetzen Implementierbar “on top of“ allgemeinen SQL-APIs

– Implementierbar auf Basis von ODBC und X/Open CLI– Brückentreiber JDBC-ODBC somit leicht realisierbar

SQL Conformance– Jeder SQL-Dialekt verarbeitbar, falls ein JDBC-Driver dafür

vorhanden ist– Mindest-Anforderung: SQL-92 (Entry Level) muß von allen Drivern

unterstützt werden Strenges, statisches Typing Einfaches API für den Normalfall (80-20 Regel)


JDBC-Architektur

Application

Driver Manager

Driver Driver Driver

Data source Data source Data source

JDBC API

JDBC Driver API

Proprietär


Driver Typ 1: JDBC-ODBC-Bridge

Java Anwendung

JDBC Driver Manager

JDBC-ODBC Bridge

DBMSServer

LAN oder Intranet

Client

ODBC

DBMS Client Bibliothek

• Zugriff auf einen ODBC-fähigen DB-Server ohne einen eigenen JDBC Driver

• Nutzbar nur für Java-Applika-tionen, aber nicht für unsignierte Applets

• Bridge und ODBC Komponenten müssen auf jedem Client-Rechner geladen sein

• Geeignet für Unternehmen, wo Installation der Software auf dem Client problemlos

• Nicht für Internet-Anwendungen

• ODBC hat nicht Funktionsumfang von JDBC

JDBC API


Driver Typ 2: Partial-Java-JDBC Driver

• Nutzt verfügbare Technologie: Übersetzt JDBC-Aufrufe in Aufrufe einer nativen Datenbank-API

• Nicht geeignet für Internet-Anwendungen

• Abbildungsschicht und DBMS-spezifische Software müssen auf dem Client-Rechner vorinstalliert sein

• Effizient durch Direktzugriff auf die Datenbank

• Nicht binärkompatibel mit anderen Plattformen

Java Anwendung

JDBC Driver Manager

Partial Java JDBC Driver

DBMSServer

LAN oder Intranet

Client

DBMS Client Bibliothek

JDBC API


Driver Typ 3: Pure-Java-JDBC-Middleware Driver

Java Applet/Anwendung

JDBC API

Pure-Java-JDBC-Middleware Driver

DBMS 1

MiddlewareServer

Internet oder Intranet

Client

• Wickeln die gesamte DB-Kommunikation über Middleware-Server ab

• DBMS-unabhängiges Netz-werk-Protokoll (DBMS gekapselt)

• Ein einziger Driver (Universal Driver) auf dem Client, somit binärkompatible Plattformen

• Plattformunabhängigkeit (Java)

• Geeignet für Internet-Anwendungen

• Höhere Systemsicherheit (Firewall-Lösungen)

• Schlechtere Antwortzeiten, da Umweg über Middleware

DBMS-Client-Bibliothek

DBMS 2

DBMS-Client-Bibliothek

DBMSServer

Standard-Netzwerkprotokoll

JDBC Driver Manager


Driver Typ 4: Pure-Java-JDBC-Net Driver

Java Applet / Anwendung

JDBC Driver Manager

JDBC Driver

DBMS

Internet oder Intranet

Client

• Übersetzt die JDBC-Aufrufe direkt in das vom DBMS verwendete Netzprotokoll

• Direkte Kommunikation des Clients mit dem DB-Server

• Antwortzeiten bei diesem Typ am besten

• Einschränkungen für unsignierte Applets bzgl. Plazierung DB-Server (Einsatz i.allg. in Intranets)

• Spezielle Sicherheitsmaß-nahmen erforderlich, da Kommunikationsport bekannt (daher eher Einsatz in Intranets)

Server

DBMS-spezifischesNetzwerk-Protocol

JDBC-API


JDBC Klassen und Interfaces

java.sql.DriverManager(class, class methods)

java.sql.Connection(interface)

java.sql.Connection(interface)

java.sql.Statement(interface)



java.sql.Resultset(interface)

java.sql.Resultset(interface)

java.sql.Driver(interface, drivers only)


JDBC Version 2

Neue Methoden / Konzepte Erweiterungen von Standard SQL

Scrollbare und änderbare ResultSets

Connection Pooling

SQL:1999-Typen Verteilte Transaktionen

Batch Updates Java Naming und Directory (JNDI)

Package: java.sql Package: javax.sql


JDBC vs. ODBC

Open Database Connectivity (ODBC)– DBMS-unabhängige Schnittstelle– C-Interface– nicht zur direkten Verwendung aus Java geeignet– Aufrufe von C-Code aus Java beeinträchtigen Sicherheit,

Robustheit, leichte Portierbarkeit Vorteile von JDBC

– Plattformunabhängigkeit– Einfache Programmierung → kurze Entwicklungszeit

Nachteile von JDBC– Fehlererkennung erst zur Laufzeit– Performance-Verlust (Interpretation der übersetzten

Programme zur Laufzeit)– Lösungen: JITs (Just-in-Time-Compiler) und optimierte JVMs


JDBC Beispiel SELECT

// Create a connection and connectConnection conn;Statement stmt;ResultSet rs;int partID;float price;

conn = DriverManager.getConnection("jdbc:odbc:Sales", "myname", "mypassword");

// Create a statement and execute a SELECT statementstmt = conn.createStatement();rs = stmt.executeQuery ("SELECT PartID, Price FROM Parts");

// Create a connection and connectConnection conn;Statement stmt;ResultSet rs;int partID;float price;


// Create a statement and execute a SELECT statementstmt = conn.createStatement();rs = stmt.executeQuery ("SELECT PartID, Price FROM Parts");


JDBC Beispiel SELECT (Forts.)

// Fetch and print each rowwhile (rs.next()){ partID = rs.getInt(1); price = rs.getFloat(2); System.out.println("Part Number: " + partID + " Price: " + price);} // Close the result setrs.close();

// Close the statement and connectionstmt.close();conn.close();

// Fetch and print each rowwhile (rs.next()){ partID = rs.getInt(1); price = rs.getFloat(2); System.out.println("Part Number: " + partID + " Price: " + price);} // Close the result setrs.close();



JDBC Beispiel UPDATE

// Create a connection and connectConnection conn;Statement stmt;int rowCount;


conn.setAutoCommit(false);

// Create a statement and execute an UPDATE statementstmt = conn.createStatement();rowCount = stmt.executeUpdate ("UPDATE Parts SET Price = 10.0 WHERE PartID = 123");


JDBC Beispiel UPDATE (Forts.)

// Check if row was changedif (rowCount != 0){ System.out.println("Price changed");}else{ System.out.println("Part not found");}// Commit the transactionconn.commit();



SQLJ Einführung

Historie– 1997: Konsortium verschiedener IT-Firmen (z.B. Oracle, IBM, Microsoft,

Sun)– Alternative zur komplizierten DB-Programmierung auf Basis von JDBC

Java Pendant zum “klassischen“ Embedded SQL Implementierung von SQLJ basiert auf JDBC als Low Level API Vorteil: Überprüfung der SQL-Anweisungen auf Typkonsistenz zur

Übersetzungszeit

Teil 0: Embedded SQLEinbindung von statischen SQL-Statements in ein Java-Programm

Teil 1: Java Stored RoutinesNutzung von statischen Java-Methoden als SQL Stored Procedures

Teil 2: Java Data TypesVerwendung von Java-Klassen als SQL Abstract Data Types


Embedded SQL in Java

Übersetzung von SQL– Ersetzen der eingebetteten SQL-Statements in JDBC-Aufrufe– Ergebnis: Java-Programm, das normal compiliert wird– Überprüfung von Syntax und Semantik der SQL-Anweisungen

Customizer von DBMS-Herstellern– Erzeugen von DB-spezifische SQL Statements aus den SQLJ Statements; wird Teil

der SQLJ Applikation– Zur Laufzeit wird für das verwendete DBMS entschieden, ob eine entsprechende

Customization existiert, ansonsten Verwendung des originalen JDBC-Codes

SQL File Java File Class File

S

QL

Tra

nsla

tor

Ja

va C

ompi

ler


Java-Programm mit SQLJ (Beispiel)// Iterator für Ergebnismenge definieren

#sql public iterator ResRec (String name,String url );

// Iterator für 2. Beispiel definieren#sql public iterator MyPos (String, String);

Class BookmarkQueries {public static void main (String args[]) {

// Verbindung aufbauenConnectionManager.initContext();

// Beispiel 1// DB-Anweisung

ResRec rr;#sql rr = {select name,url from bookmarks

where name LIKE ‘Sch%‘ order by name };// Ergebnisse abholen und zeilenweise ausgeben

while (rr.next())

{ system.out.println (rr.name()+ ““ +rr.url());}

// Ergebnismenge schließenrecRec.close();


Java-Programm mit SQLJ (Forts.)

// Beispiel 2MyPos mp; String rname; String rurl;

// DB-Anweisung ausführen#sql mp = {select name,url from bookmarks

where name LIKE ‘Sch%‘ order by name );while (true) {

// über Iterator Ergebnis in eigene Variable holen #sql { FETCH :mp INTO :rname, :rurl };if (mp.endFetch()) break;System.out.println(rname + „ „ +rurl); }

// Fehlerbehandlung und Programmende} catch (SQLException ex) { ...


Bemerkungen zu SQLJ

Iteratoren: normale Objekte der Wirtssprache Java (auch außerhalb von SQLJ verwendbar)

2 verschiedene Arten von Iteratoren– Bindung über Namen (Beispiel 1)– Bindung über Position (Beispiel 2)

Nur Typen der Ergebnisspalten bekannt Erfordert zusätzliche FETCH-Anweisung

Unterstützung mehrerer gleichzeitiger DB-Verbindungen möglich– ConnectionContext Objekt implizit oder explizit verwendet– Bei mehreren Verbindung explizite Connection-Objekte notwendig– Beispiel:

#sql context bookmarkdb;#sql [bookmarkdb] rr ={SELECT ..FROM ..WHERE ..};

Weitere Anweisungen: Transaktionssteuerung, DDL- und DML-Befehle Keine Konstrukte für Variablendeklaration wegen enger Spracheinbettung Keine dynamischen Anweisungen


Vergleich von JDBC und SQLJ

Vorteile von JDBC (Typ 3/4): Mächtigkeit Dynamik DB-Hersteller-unabhängiges API Portierbarkeit Sicherheit (3) Lastbalancierung über Verbindungs-

Server (3) Schnelle Kommunikation

Nachteile von JDBC: Komplexe Programmierung Längere Antwortzeiten durch Umweg

über Verbindungs-Server (3) Ohne Signed Applets Beschränkung

bzgl. Plazierung des DB-Servers (4) Sicherheit (4)

Vorteile von SQLJ: Einfachheit durch Einbettung in Java DB-Hersteller-unabhängige Lösung Portierbarkeit Dynamik/Mächtigkeit über Interaktion

mit JDBC Überprüfung von SQL-Anweisungen

während der Übersetzungszeit

Nachteile von JDBC: Nur statisches SQL Erfordert Präprozessor


J2EE Anwendungen

J2EE = Java 2 Platform Enterprise Edition Standard für die Entwicklung mehrschichtiger,

komponentenbasierter Java-Anwendungen Vereinfacht Entwicklung durch Definition eines

Programmiermodells auf Basis von standar-disierten und komponentenbasierten Objekten

Oracle Application Server Oracle9iAS (OC4J)– vollständige Umsetzung eines J2EE-Containers:

JSP, Java Servlets, EJB, JDBC


J2EE-Architektur

Komponenten: – Enterprise Java Beans (EJB):

Spezifikation für verteilte Java Beans zur Umsetzung von Anwendungslogik und zum Zugriff auf die Datenhaltungs-schicht

– Servlets / JSP Pages: für Erstellung von Benutzer-oberflächen dynamischer Web-Anwendungen

Container:– Laufzeitumgebung für

Komponenten, bieten zusätzliche Dienste an

Connectors:– dienen der Anbindung von

J2EE-Anwendungen an Unternehmens-IS


Java Servlets

Einordnung:– als serverseitige Applets bezeichnet– Pendant zu den Server-Erweiterungs-APIs von MS und

Netscape Voraussetzung

– Integration einer JVM in den Web-Server bzw. Kooperation mit einem Zusatzprozeß

– Voller Zugriff auf Java-API Vorteile:

– Plattform- und herstellerunabhängige Erweiterung von Web-Servern möglich (durch standardisierte Servlet-API)

– Dynamisches Binden möglich (Java-Klassenlader) Hinzufügen und Entfernen von Modulen ohne Neustart des

Servers


Web/DB-Anbindung über Java Servlets

Weitere Vorteile alle Möglichkeiten

der Sprache Java


Servlet-Engine

DB-Server

Java-Klassenbibliothek

HTTP

JVM

JDBC

gleiches Sicherheitskonzept wie Java (Security Manager),verhindert Ressourcenmißbrauch

Leistung: bleiben im Speicher des Servers, DB-Verbindung nur einmal nötig

Lastverteilung: Aufruf anderer Servlets möglich

mehr Programmieraufwand, Ent-wicklungsumgebungen verfügbar


In- und Output von Java-Http-Servlets

Quelle / Ziel: Servlet EngineServlet erhält u.a.:• Initialisierungsparameter• Externe Ressourcen• Daten von / für andere Servlets

Quelle: ClientServlet erhält u.a. • Session-ID• Http-Methode (Get / Post)• Parameter• Cookies• Username

Servlet Context

Servlet ConfigHttpServletRequest

HttpServletResponse

Java Servlet

Ziel: ClientServlet erzeugt u.a.: • Http-Status-Code• Content-Typ• Content• Cookies


Schritte zur Erstellung einer Servlet-Ausgabe

1. Auslesen (und Verarbeiten) der Daten aus dem HTTP-Request

2. Statuscode setzen, Default: SC_OK (200)3. Content-Typ setzen, Default: „text/html“4. PrintWriter oder Ausgabestream anfordern5. Rückgabe (z.B. HTML-Seite) in den

PrintWriter oder Ausgabestream schreiben6. PrintWriter oder Ausgabestream schließen


Servlet-Klassen: Packages

Importiere für die Arbeit mit Servlets folgende Packages:– java.servlet.*– javax.servlet.http.*

Sind nicht in Standard JDK enthalten, sondern nur separat oder als Teil von Java2EE


Auslesen der Parameter aus dem HttpRequest

die vom Client übergebenen Parameter sind im Http-Request codiert (je nach Methode: GET / POST)

Decodierung durch Servlet Engine Abruf der Parameter durch eine Methode

(einheitlich bei GET oder POST)


Methoden zum Einlesen von Parametern

ServletRequest.getParameterNames()– gibt die Namen der dem Servlet übergebenen Parameter in

Form einer java.util.Enumeration zurück ServletRequest.getParameter(Parametername)

– gibt den (ersten) Wert des angegebenen Parameters als String zurück (null, wenn kein Parameter existiert)

ServletRequest.getParameterValues(Parametername)

– gibt ein String-Array mit allen Werten des angegebenen Parameters zurück (bzw. null, wenn Parameter nicht existiert)


Enumerations

Erleichtern das sukzessive Abrufen einer Gruppe von Werten

Methoden von Enumeration:– Enumeration.hasMoreElements()

True, wenn noch nicht abgerufene Elemente enthalten

– Enumeration.nextElement() Gibt den Wert des nächsten Elements der Aufzählung als

Object zurück (null, wenn der Parameter nicht existiert)


MIME-Content-Typen

Content-Typ in Form eines Strings Wichtigste Content-Typen:

– „text/html“: HTML-Dokument (Default, falls kein anderer Typ gesetzt wird)

– „text/plain“: Einfaches Textfile ohne Markup oder Befehle– „text/xml“: XML-Dokument– „image/gif“: GIF-Bild– „image/jpeg“: JPEG-Bild– „application/pdf“: PDF-Datei

Setzen des Content-Typs:– HttpServletResponse.setContentType(Content-Typ)

Rückgabe des Typs als Teil des Http-Response


Http-Statuscodes

Die wichtigsten Http-Statuscodes werden durch Konstanten der Klasse HttpServlet repräsentiert.

– 200: OK (SC_OK. Default, falls kein anderer Code gesetzt wird)

– 304: Keine neuen Daten (SC_NOT_MODIFIED)– 401: Anmeldung erforderlich (SC_UNAUTHORIZED)– 404: Nicht gefunden (SC_NOT_FOUND)– 500: Interner Serverfehler

(SC_INTERNAL_SERVER_ERROR) Setzen des Statuscodes:

– HttpServletResponse.setStatus(Statuscode)


Inhalt des HttpResponse

Eigentlicher Inhalt („Body“) des HttpResponse als Zeichendaten in einen PrintWriter oder als Binärdaten in einen OutputStream schreiben

Vorher Header fertigstellen (Statuscode, Content-Typ) Methoden zum Anfordern PrintWriter / OutputStream:

– PrintWriter-Variable = HttpServletResponse.getWriter()

– OutputStream-Variable = HttpServletResponse.getOutputStream()Rückgabe eines PrintWriter bzw. OutputStream zum Schrei-ben in die HttpResponse in der angegebenen Variable zurück


Lesen und Schreiben von Daten in Java: Streams

Datenquellen und –senken durch Streams gekapselt Stream

– Kommunikationspfad zwischen Quelle und Ziel eines Informationsblockes– Entkoppeln von Quelle, Verarbeitung und Ziel der Information– Verarbeitung eines Streams ohne Kenntnis von Quelle oder Ziel

Daten-quelle

Eingabe-stream

Java-Programm

Daten-ziel

Ausgabe-stream

• File• Array• URL• Tastatur• ...

• File• Array• URL• Drucker• ...


Die Klasse PrintWriter

Klasse (aus dem Package java.io) definiert einen Ausgabestream mit Methoden, um Variablen diverser Datentypen schnell und einfach auszugeben

Generell: Schreib-Methoden werfen bei Problemen IOExceptions aus.


Ausgewählte Methoden von PrintWriter

PrintWriter.print (Wert) / print (char-Array) / print (Objekt)

PrintWriter.println (Wert) / println (char-Array) / println (Objekt)

– Schreibe einen Wert eines einfachen Datentyps, den Inhalt eines Char-Arrays oder die Repräsentation eines Objekts in den Stream. Println zusätzlich mit Zeilenumbruch

OutputStream.flush()– Erzwingt das Wegschreiben eines evtl. Puffers in das Datenziel

OutputStream.close()– Schließt den Stream und gibt die verwendeten Ressourcen frei


Java ServletsBeispielseite

package mypackage1;import javax.servlet.*;import javax.servlet.http.*;import java.io.PrintWriter;import java.io.IOException;

public class servlet_startseite extends HttpServlet { public void init(ServletConfig config) throws ServletException { super.init(config); }

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Content-Type setzen response.setContentType("text/html"); // PrintWriter initialisieren PrintWriter out = response.getWriter(); out.println("<HTML><HEAD>" + "<TITLE>Testseite als Servlet</TITLE>" +

"</HEAD><BODY>\n" + "<H1>Testseite als Servlet</H1>\n");


Java ServletsBeispielseite (Forts.)

// Wenn Parameter belegt ausgeben if ((request.getParameter("p_name") != null) && (request.getParameter("p_name").length() > 0) ) { // Name ist vorhanden out.println("Hallo " + request.getParameter("p_name") + ".<br>"); // Zugriff auf Umgebungsvariable out.println("Client-IP-Adresse: " + request.getRemoteAddr()); } // Formular ausgeben out.println("<FORM method=POST>"); out.println("Bitte Namen eingeben: "+"<INPUT NAME=p_name> "+ "<INPUT TYPE=submit>" + "</FORM>"); out.println("</BODY></HTML>"); }

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Post-Request an doGet() weiterleiten doGet(request, response); }

public void destroy() { /* leer gelassen, da beim Beenden nichts ausgeführt werden muß */ }

// Wenn Parameter belegt ausgeben if ((request.getParameter("p_name") != null) && (request.getParameter("p_name").length() > 0) ) { // Name ist vorhanden out.println("Hallo " + request.getParameter("p_name") + ".<br>"); // Zugriff auf Umgebungsvariable out.println("Client-IP-Adresse: " + request.getRemoteAddr()); } // Formular ausgeben out.println("<FORM method=POST>"); out.println("Bitte Namen eingeben: "+"<INPUT NAME=p_name> "+ "<INPUT TYPE=submit>" + "</FORM>"); out.println("</BODY></HTML>"); }

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Post-Request an doGet() weiterleiten doGet(request, response); }

public void destroy() { /* leer gelassen, da beim Beenden nichts ausgeführt werden muß */ }


Java Server Pages (JSP)

Suns Konkurrenzprodukt zu Microsofts Active Server Page Pages (ASP) Weiterentwicklung des SSI-Mechanismus und Erweiterung des Servlet-

Konzepts Sollen die Erstellung von dynamischen HTML-Seiten mit Java vereinfachen Prinzip: HTML-Seiten mit eingebetteten JSP-Direktiven und Java-Befehlen

mischt statisches HTML mit dynamischem Code (Anwendungslogik) Anwendungslogik (aufrufbar aus JSP-Seite)

– Java Beans– JDBC-Objekte– Enterprise Java Beans (EJB)– RMI-Objekte (Remote Method Invocation)

strikte Trennung von Design/Präsentation einer Seite von deren Inhalt bzw. Logik

zusätzliche JSP-Engine muß installiert werden in Dateien mit Namensendung .jsp gespeichert


Anzeige von WWW-Dokumenten mit Java Server Pages

WWW-Browser

WWW-Server mit JSP-

Engine

Datenbanken

Dateien

Meßinstrumente

Video-Systeme

Java-Compiler

1 http-Request mit Benutzereingaben

7 Http-Response (i.a. vom Servlet erzeugte HTML-Seite)

2 Übergabe der JSP an den Java-Compiler

4 Übergabe von Http-Request und ServletConfig / Context an das Servlet

3 Erstellen eines Java-Servlet

5 Ansteuerung von Serverressourcen

Java-Servlet

6 Rückgabe der Http-Response


Beziehung JSP - Servlet

JSP-Datei wird im Web-Server gespeichert

bei erster Anfrage Über-setzung in ein Servlet

Ausführung des Servlets durch die Servlet Engine

bei jedem weiteren Aufruf Ausführung des ent-sprechenden Servlets

bei Änderung der JSP-Datei erneute Übersetzung und Erzeugung des Servlets


Ablaufsteuerung in JSPs

Die Inhalte von Scriptlets werden 1:1 in das generierte Servlet übertragen.

Somit möglich:– Teile der JSP in HTML schreiben– Einbettung in Scriptlets, die Verzweigungen oder

Alternativen beinhalten Teile der JSP nur unter bestimmten Bedingungen in das

HTML einfügen Teile der JSP mehrfach in HTML einfügen


Elemente von Java Server Pages

JSP <%! Variablendefinition %>– Definieren Variablen für die Verwendung in der JSP

Ausdrücke: <%= Java-Ausdruck %>– Ergebnis des Ausdrucks an dieser Stelle in HTML eingefügt

Scriptlets: <% Java-Code %>– Angegebener Java-Code wird an dieser Stelle ausgeführt

JSP-Direktiven: <%@ JSP-Direktive %>– Ausführung der angegebenen Direktive an dieser Stelle– Include-Direktive:

<%@ page include file=“Pfadangabe“ %>– Page-Direktive:

<%@ page {attributname=“wert“}* %>


Attribute der page-Direktive

contentType = Content-Typ– Gibt an, welchen contentType der Browser übergeben

bekommen soll (i.a. txt/html) isThreadSafe = true / false

– Gibt an, ob die JSP mehrfach gleichzeitig aufgerufen werden kann, ohne daß es zu Problemen kommt

import = Java-Klasse / Paket– Importiert die angegebene Java-Klasse bzw. die Klassen im

angegebenen Java-Paket zur Verwendung in der JSP extends = Java-Klasse

– Gibt an, daß die JSP bzw. das generierte Servlet das Verhalten der angegebenen Klasse erben soll


Attribute der page-Direktive (Forts.)

errorPage = relative URL– Gibt eine JSP an, die aufgerufen werden soll, wenn

innerhalb dieser Seite ein Fehler auftritt, um diesen zu behandeln

isErrorPage = true / false– Gibt an, ob es sich bei der JSP um eine Seite, die

für andere JSPs Fehler auswertet, handelt


Vordefinierte Objekte für JSPs

Objektname Funktion

application Zugriff auf ServletContext-Funktionen, um z.B. Attribute zu setzen

config Zugriff auf ServletConfig-Funktionen, z.B. um Server-konfigurationen zu lesen

session Funktionen für sitzungsorientierte Anwendungen

out Funktionen für Ausgaben über ein JSP Writer-Objekt

exception Objekt in JSP-Fehlerseiten für die Fehlerausgabe


JSP Beispielseite<%@ page contentType="text/html;charset=windows-1252" session="false"%><html><head><meta http-equiv="Content-Type" content="text/html; charset=windows-1252"><TITLE>Testseite mit Java Server Page</TITLE></head><body><H1>Testseite mit Java Server Page</H1><%// Inhalt des Parameters p_name anzeigen, wenn belegt if ((request.getParameter("p_name") != null) && (request.getParameter("p_name").length() > 0) ) {%> Hallo <%= request.getParameter("p_name")%>. <p> Client-IP-Adresse: <%= request.getRemoteAddr()%><% }%>

<FORM method=POST> Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"> <input type="submit" name="submit" value="Submit"></FORM></body></html>

<%@ page contentType="text/html;charset=windows-1252" session="false"%><html><head><meta http-equiv="Content-Type" content="text/html; charset=windows-1252"><TITLE>Testseite mit Java Server Page</TITLE></head><body><H1>Testseite mit Java Server Page</H1><%// Inhalt des Parameters p_name anzeigen, wenn belegt if ((request.getParameter("p_name") != null) && (request.getParameter("p_name").length() > 0) ) {%> Hallo <%= request.getParameter("p_name")%>. <p> Client-IP-Adresse: <%= request.getRemoteAddr()%><% }%>

<FORM method=POST> Bitte Namen eingeben: <INPUT type="text" name="p_name" size="30"> <input type="submit" name="submit" value="Submit"></FORM></body></html>


Tag Libraries

Weitere nützliche Funktionen in spezifischen Tag Libraries implementiert

Erweitertes Event Handling Erweiterte Unterstützung für XML (z.B. Formatierung

bei der Ausgabe mittels XSLT) Java Beans für die Arbeit mit Datenbanken

– ConnBean für Erstellung einer DB-Verbindung– ConnCacheBean für Caching-Unterstützung in DB-

Verbindungen– DBBean für die Ausführung von Anfragen an die Datenbank– CursorBean für DML-Anfragen sowie Stored Procedures


Vorteile von JSP

vs. Active Server Pages (ASP)– dynamischer Teil geschrieben in Java– portabel auf andere Betriebssysteme und Webserver

vs. Reine Servlets – gleiche Funktionalität wie Servlets– bessere Wartbarkeit des Codes (Änderungen in HTML statt in

println-Befehl)– bessere Trennung von Inhalt und Präsentation

vs. Server-Side Includes (SSI)– SSI: nur einfaches Einfügen von extern definierten Teile in

eine statische Webseite– JSP mit Nutzung von Servlets besser für Verarbeitung von

Formulardaten, DB-Verbindungen u.ä.


Vorteile von JSP (Forts.)

vs. JavaScript– dynamisches HTML auf Client-Seite durch

Benutzer-Interaktion– JavaScript hat keinen Zugriff auf serverseitige

Ressourcen, z.B. Datenbanken, Kataloge– HTTP nicht verfügbar für JavaScript (nur Cookies)

vs. Statisches HTML– mit JSP einfache Erweiterung um dynamische

Anteile möglich

Documents

Architektur von Web- Datenbanksystemen. © Prof. T. Kudraß, HTWK Leipzig Schichtenarchitektur Aufteilung einer Web-DB-Anwendung in verschiedene Schichten