Internetbasierte Systeme - SS 2010 - Homepage

Transcrição

Internetbasierte Systeme
SS 2010
Michael Jäger
27. Juni 2010
1 / 446
SS 2010
Wie
entwickle ich
Software für das
Web?
http://www.w3.org
http://www.denic.de
2 / 446
Themen
Thematischer Überblick
Teil 1: Basiswissen Webprogrammierung
XML & Co
DOM – Document Object Model
XML und Java
HTML/XHTML
Cascading Stylesheets (CSS)
Javascript und Ajax
HTTP und Webbrowser
3 / 446
Themen
Teil 2: Java Enterprise Technologie – JEE
Architekturmodell
Java Server Pages (JSP) und Servlets
Java Server Faces (JSF)
Java Naming and Directory Interface (JNDI)
Java Persistenz API (JPA)
Java Enterprise Beans
4 / 446
Themen
Teil 3: Einführung in Webservices
Service-orientierte Architekturen (SOA)
Webservices, SOAP und REST
WSDL
Webservice-Erweiterungen (WS-*)
Geschäftsprozessmodellierung
Java und Webservices
5 / 446
Literatur
Literatur
„Basiswissen Web-Programmierung“ von Heide Balzert,
W3L-Verlag 2007, 25 EUR
„Java EE 5“ von Thomas Stark, Addison-Wesley/Pearson
Studium 2007, 30 EUR
Foliensammlung auf meiner WWW-Homepage (wird während
des Semesters ergänzt)
Die SELFHTML-Website: http://de.selfhtml.org
Diverse Internet-Quellen (siehe Foliensammlung)
6 / 446
XML – Extensible Markup Language
Teil II
XML
7 / 446
3
XML und Co.
Einführung
XML-Parser und andere Werkzeuge
XML Syntax
DTD - Dokumenttyp-Definitionen
4
XML Schema Language
XML Schema – Einführung
XML Schema – Namensräume
XML Schema – Typsystem
XML Schema – Import und Include
5
XSL
XSL - Extensible Stylesheet Language
XSL – XSLT
XSL – XPath
XSLT
XSLT – Push- und Pull-Verarbeitung
XSLT – Textblöcke
XSLT – Default-Aktionen
XSLT – Kontrollstrukturen
XSLT – Kopieren von Strukturen
6
XML und Java
Überblick
JAXP - DOM
JDOM und DOM4J
JAXP - SAX
JAXP Transformationen
8 / 446
XML und Co.
XML & Co
XML
XPath
XSLT
DTD
XML Schema
XPointer
9 / 446
XML und Co.
Einführung
Markupsprache
Meta-Sprache
Standard des
WWW-Konsortiums (W3C)
Weiterentwickelt aus SGML
Versionen: 1.0 (1998), 1.1
(2004)
(Quelle: http://www.wikipedia.de)
10 / 446
XML und Co.
Einführung
XML-Familie
Strukturspezifikation mit DTD und Schema
XML-Schema
zur Spezifikation der XML-Dokumentstruktur
komplexes Typsystem
Syntax XML-basiert
DTD - Document Type Definition
Technisch überholter Vorgängerstandard von XML-Schema
rudimentäres Typsystem
spezielle Syntax
aber: DTDs noch sehr verbreitet
11 / 446
XML und Co.
Einführung
XML-Familie
XSL – Transformation und Präsentation von XML
XSL – XML Stylesheet Language
Sprachfamilie: Oberbegriff für XSLT und Co.
XSLT – XSL Transformations
Regelbasierte Sprache zur Transformation von XML-Dokumenten
XPath
Sprache zur Selektion von Dokumenten-Substrukturen
XSL-FO – Formatting Objekts
Formatspezifikationen zur Erzeugung von Printmedien
12 / 446
XML und Co.
Einführung
Beispiel für ein XML-Dokument
<?xml version="1.0"
encoding="UTF-8"
standalone="yes"?>
<buch autor="Wilhelm Busch">
<titel> Max und Moritz
</titel>
<kapitel id="1">
Erster Streich.
</kapitel>
<kapitel id="2">
Zweiter Streich.
</kapitel>
</buch>
Syntax:
Verarbeitungsanweisungen
Tags (Auszeichnungen)
Elemente
Attribute
13 / 446
XML und Co.
Einführung
Syntax, Wohlgeformtheit und Gültigkeit
Element- und Attributnamen frei wählbar
keine vordefinierte Bedeutung (im Gegensatz zu HTML!).
Wohlgeformtes Dokument: Tag-Schreibweise und
Klammerstruktur stimmen
Gültiges Dokument: Aufbau entspricht Schema bzw. DTD
14 / 446
XML und Co.
XML-Parser: Strukturanalyse von XML-Dokumenten I
Aufgaben
Wohlgeformtheit und Gültigkeit gegen Schema/DTD prüfen
Methoden zur Weiterverarbeitung bereitstellen
Basis für XSLT
Ausprägungen:
Standalone-Parser
integriert in Webbrowser (z.B. „Expat“ in Firefox)
integriert in Entwicklungsumgebung
in Programmiersprachen-Bibliotheken als API-Komponente
15 / 446
XML und Co.
XML-Parser: Strukturanalyse von XML-Dokumenten II
Analysetechnik
DOM-Parser erzeugen DOM-Baum
SAX-Parser feuern Ereignisse
Stream-Parser (ereignis- und programmgetriebene Analyse)
16 / 446
XML und Co.
XML-Editoren und -Entwicklungsumgebungen
unterstützen Erstellung von XML, DTD, Schema
Unterstützung für XSLT und CSS
Beispiel: „netbeans“
integrierte Open-Source Entwicklungsumgebung mit guter
XML-Funktionalität (http://netbeans.org)
17 / 446
XML und Co.
Sonstige XML-Werkzeuge
XSLT-Prozessoren: Regelbasierte Transformation von
Dokumenten
serversseitig: z.B. saxon, Apache Xalan
Webbrowser: z.B. Firefox-Komponente TransforMiiX
FOP-Prozessoren: Erzeugung von PDF, Postscript, PCL
z.B. Apache FOP (Formatting Objects Processor)
XML-Toolkit: XML-Verarbeitung auf Kommandozeile
(http://xmltk.sourceforge.net)
18 / 446
XML und Co.
XML Syntax
Syntax: Bestandteile des XML-Dokuments
XML-Deklaration
sonstige Verarbeitungsanweisungen (optional)
Wurzelement
Kern des Dokuments
repräsentiert „fachliche Nutzdaten“
beliebig komplex
Kommentare (optional)
19 / 446
XML und Co.
XML Syntax
XML-Deklaration und andere Verarbeitungsanweisungen
XML-Deklaration: Metainformationen für XML-Parser
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
Metainformationen für XSLT-Transformation
<?xml-stylesheet type="text/xsl" href="adressbuch.xsl"?>
20 / 446
XML und Co.
XML Syntax
XML-Element
Bestandteile: Start-Tag, Inhalt, End-Tag
<buch isbn="2-675-54877-X"> ... </buch>
Element-Inhalt:
leer
einfacher Text
Unterelemente
gemischter Inhalt
<br></br> oder <br />
<name>Harry Hirsch</name>
<name><vn>Harry</vn><nn>Hirsch</nn></name>
Start-Tag: Elementname, beliebige Attribute
Attributwerte immer in Apostrophen
Groß-/Kleinschreibung wird unterschieden
leeres Element = Element mit leeren Inhalt
21 / 446
XML und Co.
XML Syntax
Textinhalt mit XML-Sonderzeichen
Problem
XML-Sonderzeichen im Textinhalt verwirren Parser
Lösung: Ersatzdarstellung
Ersatzdarstellung
&
'
"
<
>
Sonderzeichen
&
’
"
<
>
englische Bezeichnung
„ampersand“
„apostrophe“
„quotation mark“
„less than“
„greater than“
22 / 446
XML und Co.
XML Syntax
Textinhalt mit XML-Sonderzeichen
CDATA-Abschnitte
Problem
Lange Text-Inhalte mit vielen XML-Sonderzeichen
Lösung: CDATA-Blöcke
<![CDATA[ Dieses <Tag> wird nicht als Tag interpretiert ]]>
23 / 446
XML und Co.
XML Syntax
Kommentare im XML-Dokument
Syntax-Beispiel

An welcher Stelle?
außerhalb des Wurzelements
im Wurzelement: überall, wo Text-Inhalt erlaubt ist
ein- oder mehrzeilig
gehören logisch nicht zum Dokument
Prozessor darf Kommentare „verschlucken“
24 / 446
XML und Co.
XML Syntax
Adressbuch-Beispiel I
Datei: adressbuch.xml 1/2
<?xml version="1.0" encoding="UTF-8" ?>

<adressbuch aktualisiert="1.4.2008" version="2">
<adresse>
<vorname>Hugo</vorname>
<nachname>Meier</nachname>
<strasse>Waldweg 7</strasse>
<plz>35231</plz>
<ort>Dinkelsdorf</ort>
<email>[email protected]</email>
<tel typ="mobil">0160/987654</tel>
</adresse>
25 / 446
XML und Co.
XML Syntax
Adressbuch-Beispiel II
Datei: adressbuch.xml 2/2
<adresse>
<titel>Sir</titel>
<vorname>Edward</vorname>
<nachname>McDonerty</nachname>
<strasse>Bergstrasse 13a</strasse>
<plz>76522</plz>
<ort>Burgstadt</ort>
<tel typ="zuhause">08945/23456</tel>
<privatkontakt />
</adresse>
</adressbuch>
26 / 446
XML und Co.
DTD definiert syntaktische Struktur eines Dokuments
Pro Element: zulässige Attribute
Pro Element: Struktur (leer, einfach, Unterelemente)
DTD direkt im XML-Dokument
DTD als separate Datei
DTD verwendet spezielle Syntax, d.h. keine XML-Syntax
27 / 446
XML und Co.
DTD-Beispiel: Adressbuch

<!ELEMENT adressbuch (adresse+)>
<!ATTLIST adressbuch stand CDATA #REQUIRED
version CDATA #IMPLIED>
<!ELEMENT adresse (titel?, vorname, nachname, strasse,
plz, ort, email?, tel+, privatkontakt?)>
<!ELEMENT titel
(#PCDATA)>
<!ELEMENT vorname (#PCDATA)>
<!ELEMENT nachname (#PCDATA)>
<!ELEMENT strasse (#PCDATA)>
<!ELEMENT plz
(#PCDATA)>
<!ELEMENT ort
(#PCDATA)>
<!ELEMENT email
(#PCDATA)>
<!ELEMENT tel
(#PCDATA)>
<!ATTLIST tel typ CDATA #REQUIRED>
<!ELEMENT privatkontakt EMPTY>
28 / 446
XML und Co.
Elementstruktur in der DTD
Syntax:
<!ELEMENT
Elementname Strukturspezifikation >
Varianten der Strukturspezifikation:
leere Elemente:
EMPTY
einfache Elemente: (#PCDATA)
(„parsed character data“ = einfacher Text)
strukturierte Elemente: Liste mit Strukturspezifikationen für
direkte Unterelemente
<!ELEMENT adresse (titel?, vorname, nachname, strasse,
plz, ort, email?, tel+, privatkontakt?)>
29 / 446
XML und Co.
DTD-Syntax für strukturierte Elemente
Elementname = genau ein Element
Elementname? = Element ist optional
Elementname* = beliebige Sequenz von Elementen (ggf.
leer)
Elementname+ = nichtleere Sequenz von Elementen
Syntaktische Alternativen: |-Operator, z.B.
<!ELEMENT postadresse (wohnadresse | postfach)>
<!ELEMENT wohnadresse (strasse, hausnummer) >
<!ELEMENT postfach (#PCDATA)>
30 / 446
XML und Co.
Attribute in der DTD
Pro Element: beliebig viele Attribut-Definitionen
<!ATTLIST
Elementname Attribute >
Attribute: Sequenz von Attributdefinitionen mit
Attributname
Typ (z.B. CDATA)
ggf. Zusatzangaben (z.B. #REQUIRED)
Beispiel:
<!ATTLIST adressbuch stand
CDATA #REQUIRED
version CDATA #IMPLIED>
Reihenfolge der Attribute spielt keine Rolle!
31 / 446
XML und Co.
Attributtypen
Zeichenketten: CDATA
Aufzählungstypen, z.B.
<!ATTLIST adresse kategorie (freunde | beruf | golfclub)>
NOTATION-Typen für externe Formate (z.B. Bildformate)
<!ATTLIST person icon NOTATION (gif | jpg) #IMPLIED>
ID, IDREF, IDREFS für eindeutige Bezeichner
ENTITY, ENTITIES – für die Verwendung von Makros
NMTOKEN, NMTOKENS – Zeichenketten mit erweitertem
Zeichenvorrat (gegenüber CDATA)
32 / 446
XML und Co.
Zusatzangaben in der Attributdefinition
#REQUIRED
(Pflichtattribut)
#IMPLIED
(optionales Attribut, Standard)
Attributwert
(Defaultwert)
#FIXED Attributwert
(fester Wert)
33 / 446
XML und Co.
Beispiel: DTD und passendes Dokument
<!ELEMENT buchbestand (buch+)>
<!ATTLIST buchbestand
version CDATA #FIXED
"1.0"
sprache CDATA "deutsch">
<!ELEMENT buch (autor, titel, inhalt)>
<!ATTLIST buch kategorie (Sachbuch | Fachbuch | Roman) "Fachbuch"
isbn
ID
#REQUIRED
neuauflageVon IDREF "null">
<buchbestand sprache="spanisch">
<buch isbn="2-675-54877-X"> ... </buch>
<buch isbn="2-675-54856-X" neuauflageVon="2-675-54877-X"> ...
<buch kategorie="Roman" isbn="3-456-98982-X"> ... </buch>
...
34 / 446
XML und Co.
Beispiel: DTD direkt im XML-Dokument
DOCTYPE-Deklaration enthält DTD
<!DOCTYPE adressbuch [
<!ELEMENT adressbuch ...
<!ATTLIST adressbuch ...
<!ELEMENT adresse ...
...
]>
<adressbuch ...
<adresse ...
...
</adressbuch>
35 / 446
XML und Co.
Trennung von DTD und Dokument
DTD: adressbuch.dtd
<!ELEMENT adressbuch ...
<!ATTLIST adressbuch ...
<!ELEMENT adresse ...
...
Dokument: adressbuch.xml
DOCTYPE-Deklaration verweist auf DTD
<!DOCTYPE adressbuch SYSTEM "adressbuch.dtd">

<adressbuch ...
<adresse ...
...
</adressbuch>
36 / 446
XML Schema Language
XML Schema
XML Schema: Universell verwendete Metasprache
XML Schema ist die eigentliche Metasprache innerhalb der XML-Familie.
Anwendungsbereich
Mit XML Schema definiert man Syntax und Typen für Dokumenten-,
Daten- und Dateiformate, domänenspezifische Sprachen,
Programmiersprachen.
37 / 446
XML Schema Language
XML-Schema: Anwendungsbeispiele
Definition domänenspezifischer Sprachen
XHTML, JSP (Java Server Pages), BPEL (Geschäftsprozessmodellierung)
Geschäftsdokumente
Auftrag, Lieferschein, Rechnung, Kundenkontakt,
„Elektronische Patientenakte“ (Klinikinformationssystem)
Technische Anwendungen
Nachrichtenformat (SOAP), Vektorgraphikformat (SVG),
Speicherformat für Office-Dokumente (OpenOffice),
Deployment-Deskriptoren (JEE/Tomcat)
38 / 446
XML Schema Language
Schema – Grundlegende Merkmale
Ein Schema definiert komplexe Datenstrukturen
Typsystem mit vordefinierten und benutzerdefinierten Typen
XML-Syntax: Schema ist selbst XML-Dokument
Wiederverwendbarkeits- und Modularisierungskonzepte
W3C-Standard (http://www.w3.org/XML/Schema)
Nutzung mehrerer Schemas im selben XML-Dokument
Tutorial
http://www.w3.org/TR/xmlschema-0
39 / 446
XML Schema Language
Aufbau eines Schemas
Ein Schema ist eine Definitionssammlung
Ein Schema ist eine Sammlung globaler Definitionen: Elemente, Typen
und Attribute.
Ein Schema ist ein Namensraum
Die Definitionen eines Schemas bilden in der Regel(!) einen weltweit
eindeutigen Namensraum
Ein Schema ist selbst ein XML-Dokument
„flachere Lernkurve“ durch bekannte einfache Basissyntax
Einsatz von XML-Tools
(validieren, visualisieren, in Datenbanken abspeichern . . . )
40 / 446
XML Schema Language
Struktur und Verwendung eines Schema-Dokuments
Schema:
adressbuch.xsd
<?xml version="1.0" encoding="utf-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
...
Definitionen
</xsd:schema>
Verwendung:
adressbuch.xml:
<adressbuch
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="adressbuch.xsd">
...
</adressbuch>
41 / 446
XML Schema Language
Mit XML Schema definiert man Namensräume
Problem: Namenskollisionen in einem XML Dokument
Ein Schema ist ein separat entwickelte Komponente
Ein Dokument benutzt mehrere Schemas
(Import und Nutzung von Element- und Attributdefinitionen)
Eindeutigkeit aller Element- und Attributnamen im Dokument nötig
Ohne modulares Sichtbarkeitskonzept: Kollisionen unvermeidbar
42 / 446
XML Schema Language
Kollisions-Szenario
Schema A definiert „Kunde“ mit Unterelement „Nummer“
(Kundennummer)
Schema B definiert „Auftrag“ mit Unterelement „Nummer“
(Auftragsnummer)
„Rechnung“ benutzt beides
Namenskonflikt zwischen beiden „Nummer“-Elementen
Lösung: Benannte Namensräume / qualifizierte Bezeichner
<kunde:nummer>
... </kunde:nummer>
...
<auftrag:nummer> ... </auftrag:nummer>
43 / 446
XML Schema Language
Merkmale von XML-Namensräumen
Namensraum-Definition
Definition durch Schema als „target namespace“
Sammlung von Definitionen (Elemente, Attribute, Typen)
Namensraum-Import und -Nutzung
Verwendung in jedem XML-Dokument (→ auch in einem Schema!)
Jedes Element kann Namensräume importieren und nutzen
Element vererbt seine Namensräume an seine Kinder und Attribute
Import-Deklaration: Pseudoattribut „xmlns“
44 / 446
XML Schema Language
Verwendungsbeispiel SOAP
SOAP: XML-basiertes Transportprotokoll für Webservices
Webservices kommunizieren mittels SOAP-Nachrichten
W3C definiert Nachrichtenformat als Namensraum
"http://www.w3.org/2003/05/soap-envelope"
SOAP-Nachricht
<env:Envelope
xmlns:env="http://www.w3.org/2003/05/soap-envelope">
<env:Header>
...
</env:Header>
<env:Body>
...
</env:Body>
</env:Envelope>
45 / 446
XML Schema Language
Beispiel zur Verwendung zweier Namensräume
<bestellung xmlns:produkt="http://localhost/XML/produkt"
xmlns:kunde="http://localhost/XML/kunde" >
<produkt:nummer>p49393</produkt:nummer>
<produkt:name>JXY Rasierer VC100</produkt:name>
<produkt:menge>1</produkt:menge>
<produkt:preis waehrung="Euro">69,--</produkt:preis>
<kunde:nummer>k2029</kunde:nummer>
<kunde:name>Meier, Fritz</kunde:name>
<kunde:lieferadresse>Hauptstr. 4, 80111 Hof
</kunde:lieferadresse>
</bestellung>
Namensraum-URI: http://localhost/XML/produkt
Kurzname: „produkt“
„bestellung“ gehört zu keinem Namensraum
46 / 446
XML Schema Language
Namensraumbezeichner
Namensraumbezeichner ist ein eindeutiger URI
Verwendungsstelle definiert Kurznamen zum URI
Kurzname redefinierbar und löschbar
reservierte Kurznamen mit Sonderfunktion:
beginnen mit „xml“ (z.B. xmlns)
Kurznamen-Konventionen für Standardnamensräume
Beispiel: xsd - Namensraumkürzel für Schema-Definitionen
47 / 446
XML Schema Language
Default-Namensraum: Weglassen des Namensraumkürzels
Schreibvereinfachung für einen Namensraum
Jedes Element kann einen Default-Namensraum definieren
Syntax: xmlns=Namensraum-URI
Elementnamen ohne Namensraum-Angabe: Default-Namensraum
Attributnamen ohne Namensraum-Angabe: kein Namensraum
Begriff: Qualifizierter Name
Qualifiziert = „gehört zu einem Namensraum“
Explizit: durch Namensraumkürzel
Implizit: durch Default-Namensraum
48 / 446
XML Schema Language
Beispiel für Default-Namensraum: „produkt“
<bestellung xmlns="http://localhost/XML/produkt"
xmlns:kunde="http://localhost/XML/kunde">
<nummer>p49393</nummer>
<name>JXY Rasierer VC100</name>
<menge>1</menge>
<preis waehrung="Euro">69,--</preis>
<kunde:nummer>k2029</kunde:nummer>
<kunde:name>Meier, Fritz</kunde:name>
<kunde:lieferadresse>Donnerbalkenstr.14,
80111 München </kunde:lieferadresse>
</bestellung>
Namensraum-URI: http://localhost/XML/produkt
Kurzname fehlt → Default-Namensraum
„bestellung“ gehört zum Default-Namensraum
49 / 446
XML Schema Language
Redefinieren und Löschen des Default-Namensraums
<Vectra xmlns="http://www.opel.com/">
<Karosserie>...</Karosserie>
<Motor xmlns="http://www.generalmotors.com/">

...
</Motor>

<Rad>...</Rad>
</Vectra>
<Vectra xmlns="http://www.opel.com/">
<Karosserie>...</Karosserie>
<Motor xmlns="">

...
</Motor>
...
50 / 446
XML Schema Language
Definition eines Namensraums
Namensraum-Definition: „targetNamespace“
Schema-Wurzelement xsd:schema hat optionales Attribut
„targetNamespace“
Attributwert: Namensraum-URI des vom Schema definierten
Namensraums
Namensraum beinhaltet: Alle globalen Definition des Schemas
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.meyer.com/my"> ...
Weiterführender Artikel:
http://www.oracle.com/technology/pub/articles/srivastava_namespaces.html
51 / 446
XML Schema Language
Schema-Adressen im Dokument
Validierung von Dokumenten: Schema-Adresse?
Namensraum-URI ist keine Schema-Adresse!
Schema-Adresse wird separat angegeben (optional)
Schema-Adresse ermöglicht Validierung
52 / 446
XML Schema Language
Attribut xsi:schemaLocation
String, repräsentiert eine Liste von Paaren:
Namensraum-URI (identisch zum URI im xmlns-Attribut)
Adresse des zugehörigen Schemas (URI oder Dateipfad)
<adressbuch
xmlns:="http://www.meinedomaene.de/schema/adressbuch"
xsi:schemaLocation=
"http://www.meinedomaene.de/schema/adressbuch
adressbuch.xsd">
...
</adressbuch>
Attribut xsi:noNamespaceSchemaLocation
Schema-Adresse für Namensraum-freie Bezeichner
53 / 446
XML Schema Language
Qualifikation von Namen aus Namensraum
Namensräume: Qualifikationspflicht für globale Namen
Die Toplevel-Definitionen eines Schemas heißen „global“,
die anderen „lokal“
Globale Namen müssen immer qualifiziert werden:
explizit: durch Namensraumkürzel oder
implizit: durch Zugehörigkeit zum Default-Namensraum
54 / 446
XML Schema Language
Schema bestimmt Qualifikationspflicht für lokale Namen
lokale Namen: Namensraum kann aus übergeodnetem Element
bestimmt werden
Schema fordert oder verbietet Qualifikation:
einheitlich für alle Elemente:
einheitlich für alle Attribute:
(elementFormDefault= . . . )
(attributeFormDefault= . . . )
<?xml version="1.0" encoding="US-ASCII"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://www.library.com"
targetNamespace="http://www.library.com"
elementFormDefault="qualified"
attributeFormDefault="unqualified">
55 / 446
XML Schema Language
Merkmale des Typsystems
Typen für Elemente und Attribute
einfache und komplexe Typen
vordefinierte und benutzerdefinierte Typen
Einfache und komplexe Typen
Attribut: einfacher Typ
Element mit Attributen: komplexer Typ
Element mit Unterelementen: komplexer Typ
56 / 446
XML Schema Language
Element-Definition
Definition eines Elements mit anonymem komplexen Typ
<xsd:element name="adresse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="titel" type="xsd:string"
minOccurs="0" maxOccurs="1">
<xsd:element name="vorname" type="xsd:string" />
<xsd:element name="nachname" type="xsd:string" />
...
</xsd:sequence>
</xsd:complexType>
</xsd:element>
57 / 446
XML Schema Language
Typdefinition und Verwendung
Typdefinition
<xsd:complexType name="adressTyp">
<xsd:sequence>
<xsd:element name="titel" type="xsd:string"
minOccurs="0" maxOccurs="1" />
<xsd:element name="vorname" type="xsd:string" />
<xsd:element name="nachname" type="xsd:string" />
...
</xsd:sequence>
</xsd:complexType>
Verwendung
<xsd:element name="adresse" type="adressTyp">
58 / 446
XML Schema Language
Attribut-Definitionen
Adressbuch mit 3 Attributen
<xsd:element name="adressbuch">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="adresse" type="adressTyp"
maxOccurs="unbounded">
</xsd:sequence>
<xsd:attribute name="aktualisiert" type="xsd:date"
use="required" />
<xsd:attribute name="version" type="xsd:string"
use="default" value="1.0" />
<xsd:attribute name="sprache" type="xsd:language"
use="optional" />
</xsd:complexType>
</xsd:element>
59 / 446
XML Schema Language
Verwendungsstellen von Typen
Element-Definitionen
Attribut-Definitionen (nur einfache Typen!)
Typdefinitionen (z.B. als „extension“-Basistyp)
60 / 446
XML Schema Language
Vordefinierte Typen für XML-Schemata (Auswahl)
xsd:string
anyURI: Uniform Resource Identifier (URI)
xsd:decimal
language: Sprachbezeichnung (de-DE, en-US, fr)
xsd:integer
ID: eindeutiger Bezeichner (Identifier)
xsd:float
IDREF: Verweis auf ID
xsd:boolean
xsd:date
xsd:time
61 / 446
XML Schema Language
Wichtige Konstruktoren für benutzerdefinierte Typen
einfache Typen
xsd:list
xsd:restriction
xsd:enumeration
xsd:union
Werteliste
Wertebereich einschränken
Aufzählungstyp
Vereinigung von Wertemengen
komplexe Typen
xsd:sequence
xsd:all
xsd:choice
Unterelemente in fester Reihenfolge
Unterelemente mit beliebiger Reihenfolge
Varianten für Unterelemente
62 / 446
XML Schema Language
Definition einfacher Typen: Einschränkungen
Einschränkung des Wertebereichs
<xsd:simpleType name="SmallIntTyp">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="1" />
<xsd:maxInclusive value="100" />
</xsd:restriction>
</xsd:simpleType>
Einschränkung durch regulären Ausdruck
<xsd:simpleType name="ArtikelNrTyp">
<xsd:restriction base="xsd:string">
<xsd:pattern value="[X|Y|Z]\s\d{3}-\d{5}" />
</xsd:restriction>
</xsd:simpleType>
63 / 446
XML Schema Language
Definition einfacher Typen: Aufzählungstypen
Aufzählung mit xsd:restriction
<xsd:simpleType name="FarbeTyp">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="rot" />
<xsd:enumeration value="gelb" />
<xsd:enumeration value="blau" />
</xsd:restriction>
</xsd:simpleType>
64 / 446
XML Schema Language
Definition einfacher Typen: Wertelisten
Listentyp
<xsd:simpleType name="FarblisteTyp">
<xsd:list itemType="FarbeTyp" />
</xsd:simpleType>
eingeschränkter Listentyp
<xsd:simpleType name="DreiFarbenTyp">
<xsd:restriction base="FarblisteTyp">
<xsd:length value="3" />
</xsd:restriction>
</xsd:simpleType>
65 / 446
XML Schema Language
Definition einfacher Typen: Vereinigung von Wertemengen
union-Typ
<xsd:simpleType name="IntOderDecimalTyp">
<xsd:union memberTypes="int decimal" />
</xsd:simpleType>
66 / 446
XML Schema Language
Abgeleitete komplexe Typen
Einschränkung und Erweiterung
Restriction
Restrictions repräsentieren immer Teilmengen des Basistyps
Diverse Einschränkungen möglich, z.B.
Komponententyp einschränken
optionale Komponenten weglassen
min/max-Occurs einschränken
Alle Komponenten (Subelemente, Attribute) des neuen Typs explizit
deklarieren!
67 / 446
XML Schema Language
Abgeleitete komplexe Typen
Einschränkung und Erweiterung
Extension
Hinzufügen von Elementen/Attributen
Basistyp kann simpler oder komplexer Typ sein
Extension eines einfachen Typs: komplexer Typ, falls Attribute
dazukommen
Bei Extension nur zusätzliche Attribute und Elemente deklarieren!
68 / 446
XML Schema Language
Komplexer Restriction-Typ
Basistyp
abgeleiteter Typ
<xsd:complexType name="Fahrzeug">
<xsd:sequence>
<xsd:element name="ps"
type="xsd:positiveInteger"/>
<xsd:element name="geschw"
<xsd:/sequence>
<xsd:/complexType>
<xsd:complexType name="LKW">
<xsd:complexContent>
<xsd:extension base="Fahrzeug">
<xsd:sequence>
<xsd:element name="nutzlast"
....
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
69 / 446
XML Schema Language
Typen im Instanzdokument: xsi:type
XML-Dokument verwendet Schema-Typen
<auto:lieferliste
xmlns:auto="http://www.autofabrik.com/auto"
datum="2009-12-12">
<lieferung xsi:type="auto:PKWTyp"> ... </lieferung>
<lieferung xsi:type="auto:LKWTyp"> ... </lieferung>
</auto:lieferliste>
Generischer Typ im Schema, abgeleiteter Typ im Dokument
Typ im Schema: „lieferung“ hat generischen Typ
z.B. „FahrzeugTyp“ oder „xsd:anyType“
Typ im Dokument: „lieferung“ hat abgeleiteten Typ:
„PKWTyp“ bzw. „LKWTyp“
70 / 446
XML Schema Language
Ausblick: XML-Vererbungskonzepte
Abgeleitete Typen und xsi:type (siehe oben)
Substitutionsgruppen (substitutionGroup-Attribut)
(zur Modellierung von Vererbungsbeziehung zwischen Klassen)
Abstrakte Elemente (abstract-Attribut)
(zur Modellierung abstrakter Klassen)
Finale Elemente und Typen (final-Attribut)
(Einschränkung von Ableitungen)
Substitutionsverbote (block-Attribut)
71 / 446
XML Schema Language
Modularisiertes Schema: Import und Include
include – Ein Namensraum auf mehrere Dateien verteilt
Umfangreiche Namensräume: auf mehrere Dateien verteilen
Zusammenfügen: include-Element in übergeordneter Schema-Datei
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:pcParts="http://www.example.de/pcParts"
targetNamespace="http://www.example.de/pcParts">
...
<xsd:include schemaLocation="http://www.example.de/schema/harddisk.xsd"/>
<xsd:include schemaLocation="http://www.example.de/schema/ram.xsd"/>
...
</xsd:schema>
72 / 446
XML Schema Language
Modularisiertes Schema: Include
import – mehrere zusammengehörige Namensräume
Schema-Module, die eigene Namensräume definieren
Zusammenfügen: import-Element in übergeordneter Schema-Datei
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:pcParts="http://www.example.de/pcParts"
targetNamespace="http://www.example.de/parts">
...
<xsd:import namespace="http://www.example.de/pcParts"
schemaLocation="pcParts.xsd"/>
...
<...
<xsd:attribute name="weight" type="pcParts:weightType"/>
.../>
...
</xsd:schema>
73 / 446
XSL
Sprachfamilie zur Visualisierung von XML-Dokumenten:
XSLT (XSL-Transformations)
Muster-basierte Transformationsregeln für XML-Dokumente
XPath (XML Path Language)
Selektion von Elementen und Attributen
XSL-FO (XSL Formatting Objekts)
Layout für Printmedien
XPointer
Verweise auf externe Dokumente
74 / 446
XSL
XSL – XSLT
XSLT – Transformationen mit XSL-Stylesheets
XSLT-Stylesheet: Transformationsregeln für XML-Dokument
Zielsprachen: XML, HTML, XHTML, Text, PDF und andere
Ziel- und Quelldokument können beliebig voneinander abweichen!
75 / 446
XSL
XSL – XSLT
XSLT-Transformationen sind baumorientiert
Stylesheet
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="..."> ... </xsl:template>
.
.
Transformationsregeln
.
<xsl:template match="..."> ... </xsl:template>
</xsl:stylesheet>
(statt xsl:stylesheet kann auch xsl:transform stehen)
76 / 446
XSL
XSL – XSLT
Transformationsregeln
xsl:template
XSL-Stylesheet = Liste von Transformationsregeln
Regel: Selektor + Aktion
Selektor: XPath-Ausdruck
bestimmt, für welche Elemente des die Regel gilt
Aktion: statischer Ausgabetext und/oder Kommandos zur
dynamischen Erzeugung von Ausgabetext
77 / 446
XSL
XSL – XSLT
Referenzierung von XSL-Stylesheets
Stylesheets: lokale Dateien oder Internet
Adressierung im XML-Dokument: Dateipfad oder URL
Stylesheet-URL in Verarbeitungsanweisung
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="adressbuch.xsl"?>
<adressbuch ...
...
78 / 446
XSL
XSL – XSLT
Beispiel: XML → HTML
Adressbuch → E-Mail-Verzeichnis
adressbuch.xml
<adressbuch aktualisiert="1.4.2008" version="2">
<adresse>
<vorname> Hugo </vorname>
<nachname> Meier </nachname>
<strasse> Waldweg 7 </strasse>
<plz>
35231
</plz>
<ort>
Dinkelsdorf </ort>
<email> [email protected] </email>
<tel typ="mobil">
0160/987654 </tel>
</adresse>
...
79 / 446
XSL
XSL – XSLT
adressbuch.xsl
<?xml version="1.0"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/..."
version="1.0">
<xsl:template match="/">
<html>
<body>
<h1> E-Mail-Verzeichnis </h1>
<table border="4">
<tr><th>Vorname</th>
<th>Nachname</th>
<th>E-Mail</th>
</tr>
<xsl:template match="adresse">
<tr>
<td>
<xsl:value-of select="vorname" />
</td>
<td>
<xsl:value-of select="nachname" />
</td>
<td>
<xsl:value-of select="email" />
</td>
</tr>
</xsl:template>
</xsl:stylesheet>
<xsl:apply-templates />
</table>
</body>
</html>
</xsl:template>
80 / 446
XSL
XSL – XSLT
Regel für Wurzelement
<xsl:template match="/"> ...
Regeln auf Kinder anwenden
Im Beispiel: HTML-Tabellen-Gerüst für E-Mail-Adressen erzeugen
Regel für Adressen
<xsl:template match="adresse"> ...
Im Beispiel: HTML-Tabellenzeile erzeugen
Elementwert
<xsl:value-of select="..."> ...
81 / 446
XSL
XSL – XSLT
Ausführen der Transformation
Ausführen in Apache Xalan
xalan -HTML -IN adressbuch.xml -XSL adressbuch2email.xsl -OUT email.html
Ausführung im Webbrowser: automatisch
lädt XML-Dokument
findet <?xml-stylesheet ...>-Verarbeitungsanweisung
lädt Stylesheet
führt Transformation aus
zeigt resultierende HTML-Datei an
Nicht jeder Browser unterstützt XSLT!
82 / 446
XSL
XSL – XSLT
Ausführung in der Entwicklungsumgebung
83 / 446
XSL
XSL – XPath
XPath: Baum- bzw. DOM-orientierte Sprache
XPath-Ausdruck: „Pfad“
selektiert Teile (Elemente, Attribute) eines XML-Dokuments
z.B. einen Knoten, einen Teilbaum oder eine Menge von Attributen
Selektionskriterien
komplex, benutzen u.a.
Positionen im Baum
Knotentypen
Elementnamen, Attributnamen
Attributwerte
Zum Lernen und Experimentieren: XLab (http://www.zvon.org)
84 / 446
XSL
XSL – XPath
XML-Dokument und Baum
<?xml version="1.0"
encoding="UTF-8" ?>
<Musiksammlung>
<Album>
<Titel> ...
<Interpret> ...
<Genre> ...
</Album>
<Album>
<Titel> ...
<Interpret> ...
<Genre> ...
</Album>
<Album>
<Titel> ...
<Interpret> ...
<Genre> ...
</Album>
</Musiksammlung>
85 / 446
XSL
XSL – XPath
DOM-Bäume: Knotentypen
Wurzelknoten: repräsentiert komplettes XML-Dokument
Ist Elternknoten des Wurzelelements
Elementknoten: XML-Element
Kinder: Elementknoten, Attributknoten oder
Namensraum-Knoten
Attributknoten: Attribut mit Name und Wert
Textknoten: einfacher Textinhalt
Namensraumknoten: Namensraum
(für Element oder Attribut)
Verarbeitungsanweisungsknoten: Verarbeitungsanweisung
(Kind des Wurzelknotens)
Kommentarknoten: Kommentarinhalt
86 / 446
XSL
XSL – XPath
Knotentypen im DOM-Baum
visitenkarte.xml
<?xml version="1.0"
encoding="UTF-8" ?>
<Name typ=="person">
<Vorname>
Karl
</Vorname>
<Nachname>
Schneider
</Nachname>
</Name>
87 / 446
XSL
XSL – XPath
XPath-Grundelemente
Ein (Lokalisierungs-)Pfad ist eine Sequenz von Pfadelementen
Pfadelemente werden mit / abgetrennt
relative und absolute Pfade
Pfadelemente enthalten
Achse (optional)
Knotentest
Prädikate (optional)
Syntax: achse::knotentest[ Prädikat ]
Pfade mit „|“ verknüpfbar: Vereinigung der
Elementmengen
Klammern möglich zur eindeutigen Zuordnung von
Operanden
88 / 446
XSL
XSL – XPath
Achsen und Knotentests
Eine Achse selektiert eine Knotenmenge
Achse definiert Knotenmenge über Relation zum aktuellen Knoten,
z.B. child::, parent::
Default-Achse: child:: – Menge aller Kindknoten
Zugriff auf Attribute über die Achse attribute::
Zugriff auf Namensraum über die Achse namespace::
Knotentest
Elementname selektiert passende Elemente, z.B. child::adresse
Attributname selektiert passende Attribute (aus der Attributachse),
z.B. attribute::email
„*“ selektiert alle Knoten der Achse, z.B. child::*, attribute::*
89 / 446
XSL
XSL – XPath
Prädikate
[ not(...) and (...) or ... ]
Prädikate innerhalb von Pfaden
Prädikate können Knotenmengen weiter einschränken:
child::*[2]
(2. Kindelement)
child::*[position()<3]
(Die ersten 2 Kindelemente)
descendant::*[@version]
(alle Nachkommen mit „version“-Attribut)
Pfade als Argumente von Prädikaten
Prädikate können Pfade auswerten
count(child::*)
(Anzahl der Kinder)
name(child::*[last()])
(Name des letzten Kindelements)
90 / 446
XSL
XSL – XPath
Kurznotation
Zwei äquivalente Pfade
ausführlich:
kurz:
child::adresse[1]/child::email/attribute::typ
adresse[1]/email/@typ
Bestandteile
child::
adresse
[1]
attribute::
typ
Default-Achse, in der Kurznotation weggelassen
Knotentest: selektiert „adresse“-Elemente
Prädikat (hier: Index), selektiert 1. Element
Attribut-Achse, kurz: @
Knotentest: selektiert Attribut „typ“
91 / 446
XSL
XSL – XPath
Beispiele für Achsen
Auf den folgenden Folien: Baumdarstellungen für Achsen
(aus selfhtml.org)
aktueller Knoten; blau markiert
durch die Achse ausgewählte Knoten: nummeriert
92 / 446
XSL
XSL – XPath
child:: – alle Kindknoten
parent:: – Elternknoten
93 / 446
XSL
XSL – XPath
descendant:: alle Nachkommen
ancestor:: Alle Vorfahren
94 / 446
XSL
XSL – XPath
following:: im Dokument
dahinter stehende Elemente
preceding:: im Dokument
davor stehende Elemente
95 / 446
XSL
XSL – XPath
following-sibling:: im
Dokument dahinter stehende
Geschwisterelemente
preceding-sibling:: im
Dokument davor stehende
Geschwisterelemente
96 / 446
XSL
XSL – XPath
self:: Der Knoten selbst
descendant-or-self:: Knoten
selbst und alle Nachkommen
97 / 446
XSL
XSL – XPath
ancestor-or-self:: Knoten
selbst und alle Vorgänger
98 / 446
XSL
XSL – XPath
Achsen, Filter und Prädikate
Kurznotation für Achsen
/
.
..
//
@
Wurzelknoten
aktuelles Element
übergeordnetes Element
Kompletter
Baum
(descendant_or_self)
Attributknoten
bzw.
Teilbaum
Knotentest als Filter
Elementnamen oder „*“ (für alle Elemente)
Attributnamen
99 / 446
XSL
XSL – XPath
Prädikate als Filter
Prädikate schränken die selektierte Knotenmenge weiter ein
viele vordefinierte Prädikate
mit Operatoren zu komplexen Prädikaten verknüpfbar
Syntax: [ Ausdruck ]
Prädikat: Filterung nach Anzahl der Knoten
//buch[count(Seite)<=100 and count(Seite)>=10]
selektiert alle „buch“-Elemente mit 10-100 „Seite“-Kindelementen
100 / 446
XSL
XSL – XPath
Ausgewählte XPath-Beispiele
adresse
alle Kinder mit Namen „adresse“
adresse|*/adresse
alle Kinder und Enkel mit Namen „adresse“
adresse[3] | */*[last()-1]
3. Kind mit Namen „adresse“ und vorletzter Enkel
//vorname
alle Elemente mit Namen „vorname“
..|../*[1]
übergeordneter Knoten und dessen 1. Kind
../@*
alle Attribute des übergeordneten Knotens
../@*[2]
2. Attribut des übergeordneten Knotens
../attribute::waehrung
Attribut „waehrung“ des übergeordneten Knotens
../@waehrung
Attribut „waehrung“ des übergeordneten Knotens
.//kunde/*/auftrag[1]
zu allen Kunden im Teilbaum des aktuellen Knotens
das erste auftrag-Enkelelement
kunde[@kundenTyp]
kunde-Kind-Elemente mit „kundenTyp-“-Attribut
kunde[@id="275"]
kunde-Kind-Elemente mit „id-“-Attributwert 275
101 / 446
XSL
XSL – XPath
Ausgewählte XPath-Funktionen
boolean
ceiling
concat
contains
count
current
document
element-available
false
floor
format-number
function-available
generate-id
id
key
lang
last
Prädikat auswerten
aufrunden
Konkatenation
Teilzeichenkette
Anzahl Knoten
aktueller Knoten
Zugriff auf anderes XML-Dokument
Prozessor-Support für Element testen
„falsch“
abrunden
Zahl → String
Prozessor-Support für Funktion testen
ID generieren
Element zu ID
Elemente zu Key
Sprachcode
Index des letzten Knotens
102 / 446
XSL
XSL – XPath
Ausgewählte XPath-Funktionen II
local-name
name
namespace-uri
normalize-space
not
number
position
round
starts-with
string
string-length
substring
substring-after
substring-before
sum
system-property
translate
true
Name ohne Präfix
Name
Namensraum-URI
Leerzeichen vorne/hinten entfernen
Negation
in Zahl umwandeln
Index aktueller Knoten
auf- oder abrunden
Präfixtest
in Zeichenkette umwandeln
Länge
Substring extrahieren
Summe
Systemeigenschaft (z.B. XSLT-Version)
Suchen und Ersetzen
„wahr“
103 / 446
XSL
XSLT
Anwenden von Templates
xsl:apply-templates
veranlasst Regelanwendung für Kindknoten
mit select: Anwendung nur für explizit selektierte Substrukturen
Regelanwendung für explizit selektierte Kinder
<xsl:template match="adressbuch">
<html><body>
<table border="4">
<th>Nachname</th>
<th>E-Mail</th>
</tr>
<xsl:apply-templates select="*[count(email)>0]"/>
</table>
</body></html>
</xsl:template>
104 / 446
XSL
XSLT
Auf Inhalte zugreifen
Auf Textinhalte und Attributwerte zugreifen: xsl:value-of
Syntax:
<xsl:value-of select="..." />
Ergebnis:
bei Textknoten und Elementknoten: Text-Inhalt
bei Attributknoten: Attributwert
105 / 446
XSL
Entwurfsmuster für XSLT
PUSH-Verarbeitung
Ausgabe-Erzeugung mit elementspezifischen Regeln
Regelanwendung durch <xsl:apply-templates>
PULL-Verarbeitung
Im Template eines Elements wird die Verarbeitung der
Substrukturen explizit programmiert
Extremfall: nur ein Template für das Wurzelement.
Zugriff auf die Teilbäume mit
<xsl:value-of select=...> und <xsl:foreach>
Bessere Wartbarkeit ist i.A. bei PUSH-Stil gegeben.
106 / 446
XSL
XSL-Stylesheet für Adressbuch – PUSH-Stil
5 Transformationsregeln
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="adressbuch">
.
. wie oben
.
</xsl:template>
<tr>
</tr>
</xsl:template>
107 / 446
XSL
<xsl:template match="vorname">
<td><xsl:value-of select="." /></td>
</xsl:template>
<xsl:template match="nachname">
</xsl:template>
<xsl:template match="email">
</xsl:template>
</xsl:stylesheet>
108 / 446
XSL
XSL-Stylesheet für Adressbuch – PULL-Stil
<xsl:stylesheet xmlns:xsl="http://www.w3.org/...">
<html> <body>
<table border="4">
<th>Nachname</th>
<th>E-Mail</th>
</tr>
<xsl:for-each select="*">
<tr>
<td><xsl:value-of select="vorname" /></td>
<td><xsl:value-of select="nachname" /></td>
<td><xsl:value-of select="email" /></td>
</tr>
</xsl:for-each>
</table>
</body> </html>
</xsl:template>
109 / 446
XSL
XSLT – Textblöcke
Textblöcke unverändert ausgeben: xsl:text
Problem: Sonderzeichen im Ausgabetext
<xsl:text> Sei x>0 und x<10. </xsl:text>
Sonderzeichen-Ersatzdarstellung im Ausgabedokument
<xsl:text disable-output-escaping="no">
Sei x>0 und x<10.
</xsl:text>
Ausgabe:
Sei x>0 und x<10
110 / 446
XSL
XSLT – Default-Aktionen
Default-Aktionen
Standardaktionen abhängig vom Knotentyp
Knotentyp
Element
Text
Komentar
Verarbeitungsanweisung
Attribut
Namensraum
Wurzel
Standardaktion
Templates für Kindknoten anwenden
in den Ausgabebaum kopieren
ignorieren
ignorieren
Wert in den Ausgabebaum kopieren
ignorieren
Templates für Kindknoten anwenden
Beispiel: Stylesheet völlig ohne Templates kopiert alle Textinhalte
(aber keine Attribute)
111 / 446
XSL
Bedingte Verarbeitung in XSLT
xsl:if
<xsl:if test="...">
... </xsl:if>
xsl:choose: mehrere Alternativen
<xsl:choose>
<xsl:when test="...">
.
.
.
<xsl:when test="...">
<xsl:otherwise>
</xsl:choose>
... </xsl:when>
... </xsl:when>
... </xsl:otherwise>
112 / 446
XSL
Listentrenner-Beispiel für xsl:if
<html><body>
<h2>CD-Sammlung</h2>
<p>Titel:
<xsl:for-each select="cdkatalog/cd">
<xsl:value-of select="titel"/>
<xsl:if test="position() < last()-1">
<xsl:text>, </xsl:text>
</xsl:if>
<xsl:if test="position()=last()-1">
<xsl:text> und </xsl:text>
</xsl:if>
<xsl:if test="position()=last()">
<xsl:text>!</xsl:text>
</xsl:if>
</xsl:for-each>
</p>
</body></html>
</xsl:template>
113 / 446
XSL
Iterator für Knotenmengen
xsl:for-each
expliziter Iterator für Knotenmengen
xsl:sort
Sortierung einer Knotenmenge
114 / 446
XSL
Iteration und Sortieren einer Knotenmenge
auftraege.xml
<?xml-stylesheet type="text/xsl" href="auftrag.xsl"?>
<auftraege typ="tiefbau">
<auftrag datum="2008-04-11">
<kunde> Karl Dall
</kunde>
<auftragsposition> 10 Bagger </auftragsposition>
<auftragsposition> 1 Bauzaun </auftragsposition>
</auftrag>
<auftrag datum="2007-09-21">
<kunde> Hubert Winzig </kunde>
<auftragsposition> 7 Bagger
</auftragsposition>
<auftragsposition> 1 Kran
</auftragsposition>
</auftrag>
</auftraege>
115 / 446
XSL
Stylesheet dazu
auftraege.xsl (1/2)
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="auftraege">
<html><body>
<xsl:for-each select="auftrag">
<xsl:sort select="@datum" />
<hr/>
<b> Auftrag vom <xsl:value-of select="@datum" />: </b><p>
<xsl:apply-templates select="auftragsposition" />
<br /> Oben stehende Auftraege sind von
<b> <xsl:apply-templates select="kunde" /> </b></p>
</xsl:for-each>
</body></html>
</xsl:template>
116 / 446
XSL
Stylesheet II
auftraege.xsl (2/2)
<xsl:template match="auftragsposition">
Auftragsposition:
<xsl:apply-templates /> <br/>
</xsl:template>
</xsl:stylesheet>
117 / 446
XSL
Ausgabe im Browser
118 / 446
XSL
Kopieren von Baumknoten
Flaches Kopieren eines Elements
<xsl:copy> ... </xsl:copy>
kopiert aktuellen Knoten ohne Inhalt und Attribute
Inhalt des xsl:copy-Elements bestimmt den Inhalt des kopierten
Knotens
Attribute können mit xsl:attribute hinzugefügt werden
Kopieren beliebiger Strukturen
<xsl:copy-of select=" ... " />
kopiert alle mit select ausgewählten Daten
119 / 446
XSL
Vergleich unterschiedlicher Kopieraktionen
Adressbuch mit drei Adressen
Adresse 1 wird mit xsl:copy-of kopiert
Adresse 2 wird mit xsl:value-of kopiert
Adresse 3 wird mit rekursivem xsl:copy kopiert
Man achte auf die Attribute!
120 / 446
XSL
<adressbuch stand="1.4.2010">
<adresse>
<plz>35231</plz>
<ort>Dinkelsdorf </ort>
</adresse>
<adresse>
<titel art="adelstitel">Sir</titel>
<vorname>Edward</vorname>
<nachname>McDonerty</nachname>
<strasse>Bergstrasse 13a</strasse>
<plz>76522</plz>
<ort>Burgstadt</ort>
<privatkontakt/>
</adresse>
<adresse>
<titel art="akademisch">Msc.</titel>
<vorname>Alex</vorname>
<nachname>Hacker</nachname>
<strasse>xmlweg 17</strasse>
<plz>98754</plz>
<ort>webstadt</ort>
<privatkontakt/>
</adresse>
</adressbuch>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="adresse[vorname=’Hugo’]">
--------- copy-of ----------<xsl:copy-of select="."/>
</xsl:template>
<xsl:template match="adresse[vorname=’Edward’]">
--------- value-of ---------<xsl:value-of select="."/>
</xsl:template>
--------- deep-copy ---------<xsl:call-template name="deepCopy" />
</xsl:template>
<xsl:template name="deepCopy" match="*">
<xsl:copy>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
121 / 446
XSL
Ausgabe dazu:
--------- copy-of ----------<adresse>
<plz>35231</plz>
<ort>Dinkelsdorf </ort>
</adresse>
--------- value-of ---------Sir
Edward
McDonerty
Bergstrasse 13a
76522
Burgstadt
08945/23456
--------- deep-copy ---------<adresse>
<titel>Msc.</titel>
<vorname>Alex</vorname>
<nachname>Hacker</nachname>
<strasse>xmlweg 17</strasse>
<plz>98754</plz>
<ort>webstadt</ort>
<privatkontakt/>
<tel>0151/223456</tel>
<tel>05432/9879995</tel>
</adresse>
122 / 446
XSL
Beispiel: XML→XML, Selektion von Tabellenzeilen,
xsl:copy
<xsl:template match="/adressbuch">
<xsl:copy>
<xsl:for-each select="//adresse[nachname=’Schmidt’]">
<xsl:copy>
</xsl:copy>
</xsl:for-each>
</xsl:copy>
</xsl:template>
<xsl:copy>
</xsl:copy>
</xsl:template>
123 / 446
XSL
Beispiel: XML→XML, Selektion von Tabellenspalten
<xsl:copy>
<xsl:copy>
<xsl:apply-templates select="vorname"/>
<xsl:apply-templates select="nachname"/>
<xsl:apply-templates select="email"/>
</xsl:copy>
</xsl:for-each>
</xsl:copy>
</xsl:template>
<xsl:copy>
</xsl:copy>
</xsl:template>
124 / 446
XSL
Expliziter Regelaufruf
Problem: mehrere passende Regeln bei apply-templates
Auswahl nach Prioritäten
expliziter Regelaufruf
Expliziter Regelaufruf: adresse-Knoten kopieren
<xsl:copy>
<xsl:copy>
<xsl:call-template name="deepCopy" />
</xsl:copy>
</xsl:for-each>
</xsl:copy>
</xsl:template>
125 / 446
XML und Java
Überblick
XML-Verarbeitung in Java
Optimale Unterstützung
Mehrere stabile Standard-APIs (z.B. JAXP, JAXB)
Mehrere ausgereifte Nonstandard-APIs (z.B. JDOM, StAX)
Ausgereifte, performante Tools (z.B. validierende Parser,
XSLT-Prozessoren)
Frameworks für komplexe XML-Projekte (z.B. Cocoon)
Hervorragende Dokumentation (Bücher und Internet)
Problem eines Anwendungsentwicklers
Überblick im „Dschungel der Möglichkeiten“?
126 / 446
XML und Java
Überblick
Alternative API-Frameworks: JAXP und JAXB
JAXP – Java API for XML Processing
API(s) zum Validieren, Parsen, Generieren und Transformieren
DOM-API: Erstellung und Auswertung von DOM-Bäumen
SAX: Ereignis-getriebener XML-Parser
StaX: Streaming-Parser
Transform-API: XSLT, Serialisierung, Deserialisierung und mehr
JAXB – Java XML Binding Framework
Standardisiertes Mapping zwischen Java und XML
Programmierer arbeitet rein objektorientiert
Umwandlung Java ↔ XML automatisch
127 / 446
XML und Java
Überblick
XML-Parser: DOM- und SAX-Parser
DOM-Parser
Parser liest XML-Text und konstruiert DOM-Baum dazu
Dokument (Baum) komplett im Hauptspeicher
Speicher- und Geschwindigkeitsprobleme bei großen Dokumenten
SAX-Parser: Ereignis-getriebene Alternative
erzeugen Ereignisse wie startElement
anwendungsspezifische Callback-Methoden verarbeiten Ereignisse
Vorteil: schnell, geringer Speicherbedarf, beliebig große Dokumente
Nachteil: Knoten-Kontext steht der Callback-Methode nicht zur
Verfügung. Anwendung muss Speicherung von Kontextinfo bei
Bedarf selbst organisieren
128 / 446
XML und Java
JAXP - DOM
DOM Standard des W3C
Überblick
Standard: W3C-Recommendation: http://www.w3.org/DOM
Verwendung: XML, HTML, XHTML, Javascript, CSS u.a.
Programmiersprachen- und Plattform-unabhängig
Inhalt:
Begriffsdefinitionen
Dokument, Knoten, Knotentyp, Element, Attribut, . . .
Baumstruktur: Wie sieht der Baum zu einem Dokument aus?
Abstrakte Operationen
(Knoten erzeugen/kopieren/löschen, Kindknoten anfügen, . . . )
129 / 446
XML und Java
JAXP - DOM
Merkmale
Spezifikation in IDL (Interface Definition Language)
3 Versionen („Levels“) des Standards, aktuell: „Level 3“.
modularisiert:
DOM Core
DOM HTML
DOM Style and Formatting – Verarbeitung von Stylesheets
DOM Events – Basis für Javascript-Eventmodell
DOM Traversal and Range
XPath
...
Java-Implementierung
DOM-API ist Teil von JAXP
JavaSE (Java Platform Standard Edition) enthält JAXP
130 / 446
XML und Java
JAXP - DOM
Wichtige W3C-DOM-Methoden
für Knoten und Subklassen
appendChild()
appendData()
cloneNode()
deleteData()
getAttribute()
getAttributeNode()
getElementsByTagName()
hasChildNodes()
insertBefore()
insertData()
removeAttribute()
removeAttributeNode()
removeChild()
replaceChild()
replaceData()
setAttribute()
setAttributeNode()
Kindknoten hinzufügen
Zeichendaten hinzufügen
Knoten kopieren
Zeichendaten löschen
Wert eines Attributknotens ermitteln
Attributknoten ermitteln
Zugriff auf Kindelemente über den Elementnamen
auf Kindknoten prüfen
Knoten einfügen
Zeichendaten einfügen
Attribut löschen
Attributknoten löschen
Knoten löschen
Kindknoten ersetzen
Zeichendaten ersetzen
Wert eines Attributknotens setzen
Attributknoten erzeugen
131 / 446
XML und Java
JAXP - DOM
DOM-Beispiel: Adressbuch
Adressbuch-Beispiel: adressbuch.xml
<adressbuch aktualisiert="1.4.2010">
<adresse>
<telefon typ="mobil">
0160/987654
</telefon>
</adresse>
</adressbuch>
132 / 446
XML und Java
JAXP - DOM
Baumaufbau mit W3C-DOM
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class XmlDocBeispiel {
static public void main(String [] args ){
XmlDocBeispiel adressbuchDoc = new XmlDocBeispiel();
Document doc = adressbuchDoc.createAdressBuch();
}
public Document createAdressBuch(){
DocumentBuilderFactory factory;
DocumentBuilder domParser;
Document doc = null;
try { factory = DocumentBuilderFactory.newInstance();
domParser = factory.newDocumentBuilder();
doc = domParser.newDocument(); }
catch( Exception e ){
System.out.println("Dokument konnte nicht erzeugt werden");
}
133 / 446
XML und Java
JAXP - DOM
if (doc != null) {
Element adressbuch = doc.createElement("adressbuch");
adressbuch.setAttribute("aktualisiert", "1.4.2010");
Element adresse = doc.createElement("adresse");
Element vorname = doc.createElement("vorname");
vorname.appendChild(doc.createTextNode("Hugo"));
adresse.appendChild(vorname);
Element nachname = doc.createElement("nachname");
nachname.appendChild(doc.createTextNode("Meier"));
adresse.appendChild(nachname);
Element telefon = doc.createElement("telefon");
telefon.setAttribute("typ", "mobil");
telefon.appendChild(doc.createTextNode("0160/987654"));
adresse.appendChild(telefon);
adressbuch.appendChild(adresse);
doc.appendChild(adressbuch);
}
return doc;
}
}
134 / 446
XML und Java
JAXP - DOM
Großes DOM-Beispiel: XML-Text → DOM → XML-Text
Alle wichtigen DOM-API-Elemente in einem Beispiel:
XML-Texte parsen und Baumaufbau mit dem DOM-Parser
Traversierung von DOM-Bäumen mit der DOM-API
Zentrale Methoden
DOMBaumBeispiel.erzeugeDOM() konstruiert DOM-Baum zu
XML-Text (URI)
DOMBaumBeispiel.main()
erzeugt DOM-Baum mit erzeugeDOM()
serialisiert den Baum wieder mittels DOMSerializer-Instanz
DOMSerializer.serialize() serialisiert den Baum
DOMSerializer.serializeNode() serialisiert Teilbaum rekursiv
135 / 446
XML und Java
JAXP - DOM
DOMBaumBeispiel – Analyse mit DOM-Parser
DOMBaumBeispiel.erzeugeDOM
import
import
import
import
org.w3c.dom.Document;
javax.xml.parsers.DocumentBuilder;
javax.xml.parsers.DocumentBuilderFactory;
org.xml.sax.SAXParseException;
public class DOMBaumBeispiel {
private Document erzeugeDOM (String uri) {
Document doc = null;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder domBuilder = factory.newDocumentBuilder();
try {
Document doc = domBuilder.parse (uri);
}
catch (SAXParseException e) {
...
}
136 / 446
XML und Java
JAXP - DOM
DOMBaumBeispiel.main
public static void main (String[] args) {
if (args.length != 2) {
System.out.println("usage: java DOMAusgabe [XML URI] OutputFilename");
System.exit (0);
}
/** Baum erzeugen */
DOMBaumBeispiel b = new DOMBaumBeispiel();
Document doc = b.erzeugeDOM(args[0]);
/** Baum in Textform ausgeben */
try {
BufferedWriter out = new BufferedWriter(new FileWriter(args[1]));
DOMSerializer serializer = new DOMSerializer();
serializer.serialize(doc,out);
} catch (IOException e) {
e.printStackTrace();
}
}
137 / 446
XML und Java
JAXP - DOM
Die andere Richtung: DOMSerializer
import java.io.*;
import org.w3c.dom.*;
public class DOMSerializer {
public static void serialize(Document doc, BufferedWriter writer)
throws IOException {
// Rekursive Ausgabe ohne Einrückung starten.
serializeNode(doc, writer, "");
writer.flush();
}
private static void serializeNode(Node node, BufferedWriter writer,
String indentLevel)
throws IOException {
// Fallunterscheidung über alle Knotentypen
switch (node.getNodeType()) {
case Node.DOCUMENT_NODE:
writer.write("<?xml version=\"1.0\"?>");
writer.newLine();
// rekursiver Aufruf für jedes Kind
NodeList nodes = node.getChildNodes();
for (int i = 0; i < nodes.getLength(); ++i)
serializeNode(nodes.item(i), writer, "");
break;
138 / 446
XML und Java
JAXP - DOM
case Node.DOCUMENT_TYPE_NODE:
DocumentType docType = (DocumentType)node;
writer.write("<!DOCTYPE " + docType.getName());
if (docType.getPublicId() != null)
writer.write(" PUBLIC \"" + docType.getPublicId() + "\" ");
else
writer.write(" SYSTEM ");
writer.write("\"" + docType.getSystemId() + "\">");
writer.newLine();
break;
case Node.COMMENT_NODE:
writer.write("");
writer.newLine();
break;
case Node.PROCESSING_INSTRUCTION_NODE:
writer.write("<?" + node.getNodeName() +
" " + node.getNodeValue() + "?>");
writer.newLine();
break;
139 / 446
XML und Java
JAXP - DOM
case Node.ELEMENT_NODE:
String name = node.getNodeName();
writer.write(indentLevel + "<" + name);
NamedNodeMap attributes = node.getAttributes();
for (int i = 0; i < attributes.getLength(); ++i) {
Node current = attributes.item(i);
writer.write(" " + current.getNodeName() +
"=\"" + current.getNodeValue() + "\"");
}
writer.write(">");
// rekursiver Aufruf für jedes Kind
// für ELEMENT-Knoten -> Inhalt eingerückt auf Folgezeile(n)
// für TEXT- oder CDATA-Knoten -> gleiche Zeile, hinter dem Start-Tag
NodeList children = node.getChildNodes();
if (children.getLength() != 0 &&
children.item(0).getNodeType() == Node.ELEMENT_NODE)
writer.newLine();
for (int i = 0; i < children.getLength(); ++i)
serializeNode(children.item(i), writer, indentLevel + INDENT);
if (children.getLength() != 0 &&
children.item(children.getLength()-1).getNodeType() ==
Node.ELEMENT_NODE)
writer.write(indentLevel);
writer.write("</" + name + ">");
writer.newLine();
break;
140 / 446
XML und Java
JAXP - DOM
case Node.TEXT_NODE:
writer.write(node.getNodeValue());
break;
case Node.CDATA_SECTION_NODE:
writer.write("<![CDATA[" + node.getNodeValue() + "]]>");
break;
case Node.ENTITY_REFERENCE_NODE:
writer.write("&" + node.getNodeName() + ";");
break;
}
}
/** Einrückung. */
private static final String INDENT = "
";
}
141 / 446
XML und Java
JAXP - DOM
Validieren mit dem DOM-Parser
Unterschiedliche Möglichkeiten, Konfiguration über
DocumentBuilderFactory-Objekt
Beispiele
factory.setNamespaceAware(true);
factory.setValidating(true);
factory.setFeature("http://xml.org/sax/features/validation", true);
factory.setFeature("http://xml.org/sax/features/namespaces", true);
Weitere Features
"http://apache.org/xml/features/validation/schema"
"http://apache.org/xml/features/validation/schema-full-checking"
"http://apache.org/xml/features/continue-after-fatal-error"
"http://apache.org/xml/features/validation/dynamic"
142 / 446
XML und Java
JAXP - DOM
Schema-Validierung mit/ohne schemaLocation
mit schemaLocation im Dokument:
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware( true);
factory.setValidating( true);
factory.setProperty(
"http://java.sun.com/xml/jaxp/properties/schemaLanguage",
"http://www.w3.org/2001/XMLSchema");
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse( new Inputsource( "test.xml"));
ohne schemaLocation
factory.setProperty(
"http://java.sun.com/xml/jaxp/properties/schemaSource",
"file:adressen.xsd");
143 / 446
XML und Java
JAXP - DOM
Alternative: Validieren mit javax.xml.validation
import javax.xml.XMLConstants;
import javax.xml.transform.*
import javax.xml.validation.*
import org.xml.sax.SAXParseException;
...
try {
SchemaFactory schemaFactory =
SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Source schemaFile = new StreamSource( new File(schemaFileName) );
Schema schema = schemaFactory.newSchema( schemaFile );
Validator validator = schema.newValidator();
StreamSource streamSource = new StreamSource( xmlFile );
validator.validate( streamSource ); }
catch (SAXParseException e )
{ String errStr = e.getMessage()
+ "\nFile: " + e.getSystemId()
+ "\nLine: " + e.getLineNumber();
System.err.println( errStr ); ...
144 / 446
XML und Java
JDOM und DOM4J
DOM-Alternativen: JDOM und DOM4J
JDOM-API für Java
Open-Source API für XML-Verarbeitung in Java
Funktionalität mit DOM vergleichbar, aber einfacher zu benutzen
Standardisierungsprozess JSR-102 „steckengeblieben“
integriert beim Parser die DOM- und SAX-APIs
Installation: Binär-Distribution herunterladen (www.jdom.org) und
jdom.jar in den CLASSPATH aufnehmen
DOM4J
Weitere Open-Source API: siehe www.dom4j.org
Funktionalität mit JDOM vergleichbar
145 / 446
XML und Java
JDOM und DOM4J
Baumaufbau mit JDOM
import org.jdom.Element;
import org.jdom.Document;
Adressbuch-Beispiel
public class CreateDocument {
public static void main(String[] args) {
<adressbuch aktualisiert="1.4.2008">
<adresse>
<telefon typ="mobil">
0160/987654
</telefon>
</adresse>
</adressbuch>
Element vorname = new Element("vorname");
vorname.addContent("Hugo");
Element nachname = new Element("nachname");
nachname.addContent("Meier");
Element telefon = new Element("telefon");
telefon.setAttribute("typ", "mobil");
telefon.addContent("0160/987654");
Element adresse = new Element("adresse");
adresse.addContent(vorname);
adresse.addContent(nachname);
adresse.addContent(telefon);
Element adressbuch = new Element("adressbuch");
adressbuch.setAttribute("aktualisiert","1.4.2008");
adressbuch.addContent(adresse);
Document doc = new Document(adressbuch);
}
}
146 / 446
XML und Java
JDOM und DOM4J
Chaining in JDOM
Verkettung der Methodenaufrufe
Methoden (addContent, setAttribute, setText usw.)
liefern Referenz auf das Element zurück
Mehrere Aufrufe der Methoden verkettbar („chaining“)
Ohne Chaining
Element adressbuch = new Element("adressbuch");
adressbuch.setAttribute("aktualisiert", "1.4.2008");
adressbuch.addContent(adresse);
Mit Chaining
Element adressbuch = new Element("adressbuch")
.setAttribute("aktualisiert", "1.4.2008")
.addContent(adresse);
147 / 446
XML und Java
JDOM und DOM4J
Kurzform des Beispiels
Document doc =
new Document(
new Element ("adressbuch")
.setAttribute("aktualisiert", "1.4.2008")
.addContent(
(Element) new Element("adresse")
.addContent(
(Element) new Element("vorname")
.addContent("Hugo"))
.addContent(
(Element) new Element("nachname")
.addContent("Meier"))
.addContent(
(Element) new Element("telefon")
.setAttribute("typ", "mobil")
.addContent("0160/987654"))))
}
148 / 446
XML und Java
JAXP - SAX
SAX – Simple API for XML
SAX definiert Java-Schnittstellen
XMLReader
ContentHandler
ErrorHandler
Implementierung der Schnittstellen
SAX-Parser implementiert:
XMLReader
Anwendung implementiert
ContentHandler: Methoden für normale Ereignisse
ErrorHandler: Methoden für Fehlerereignisse
149 / 446
XML und Java
JAXP - SAX
Verwendungsmuster
XML-Analyse und Verarbeitung sind verzahnt:
Anwendung
erzeugt Parser-Instanz
schaltet ggf. die Validierung ein
registriert Content- und Fehler-Behandlungsmethoden beim Parser
aktiviert Parser mit einem Dokument
Parser
analysiert Dokument
ruft dabei die Behandlungsmethoden auf
150 / 446
XML und Java
JAXP - SAX
XML und SAX-Ereignisse
<?xml version="1.0" encoding="ISO-8859-1"?>
<wurzel>
<kind alter="20">Hallo</kind>
<?mark ACHTUNG ?>
</wurzel>
SAX-Ereignisse mit Parametern
startDocument
startElement
ignorableWhitespace
startElement
characters
endElement
ignorableWhitespace
processingInstruction
ignorableWhitespace
endElement
endDocument
(wurzel)
(Zeilenumbruch und " ")
("kind", alter=20)
("Hallo")
("kind")
(Zeilenumbruch und " ")
("mark","ACHTUNG ")
(Zeilenumbruch)
("wurzel")
151 / 446
XML und Java
JAXP - SAX
SAX-Parser in Java
Gesamtstruktur
// allgemeine Java-Klassen
import java.io.IOException;
// SAX
import
import
import
import
import
import
mit Hilfsklassen
org.xml.sax.XMLReader;
org.xml.sax.ContentHandler;
org.xml.sax.ErrorHandler;
org.xml.sax.SAXException;
org.xml.sax.SAXParseException;
org.xml.sax.InputSource;
import org.xml.sax.helpers.XMLReaderFactory;
// Content-Callback-Schnittstelle definieren:
class MeinContentHandler implements ContentHandler {...}
// Fehler-Callback-Schnittstelle implementieren:
class MeinErrorHandler implements ErrorHandler {...}
152 / 446
XML und Java
JAXP - SAX
Der Kern der Verarbeitung: ContentHandler
Pro Ereignisklasse eine Methode
class MeinContentHandler implements ContentHandler {
private Locator locator;
public void setDocumentLocator (Locator locator) {
/** locator enthaelt die aktuelle Position im Dokument */
this.locator = locator;
}
public void startDocument() throws SAXException { ... }
public void endDocument()
throws SAXException { ... }
public void startElement (String namespaceURI, String localName,
String rawName, Attributes atts) ...
public void endElement
(String namespaceURI, String localName,
String rawName) ...
public void processingInstruction (String target, String data) ...
public void characters (char[] ch, int start, int length) ...
.
.
jedes Ereignis muss behandelt werden
.
153 / 446
XML und Java
JAXP - SAX
ErrorHandler: Drei Fehlerarten
class MeinErrorHandler implements ErrorHandler {
/** Warnung ausgeben */
public void warning(SAXParseException exception) {
System.err.println("**Parsing Warning**\n" +
" Line:
" + exception.getLineNumber() + "\n" +
" URI:
" + exception.getSystemId() + "\n" +
" Message: " + exception.getMessage());
}
/** Fehlermeldung ausgeben: Dokument wohlgeformt, nicht gültig
public void error(SAXParseException exception) {
System.err.println(...);
}
*/
/** Fehlermeldung bei fatalem Fehler ausgeben. Dokument unbrauchbar
public void fatalError(SAXParseException exception) {
System.err.println(...);
}
}
*/
154 / 446
XML und Java
JAXP - SAX
Anwendungsunabhängig: Initialisierung
public class MeinSAXParser {
public void verarbeite (String uri) {
try {
XMLReader parser = XMLReaderFactory.createXMLReader();
parser.setContentHandler (new MeinContentHandler());
parser.setErrorHandler
(new MeinErrorHandler());
// gegen Schema validieren:
parser.setFeature("http://xml.org/sax/features/validation", true);
parser.setFeature(
"http://apache.org/xml/features/validation/schema",true);
parser.parse(uri);
System.out.println("Error reading uri: " + e.getMessage());
} catch (SAXException e) {
System.out.println("Error parsing uri: " + e.getMessage());
}
}
155 / 446
XML und Java
JAXP - SAX
public static void main (String[] args) {
if (args.length != 1) {
System.out.println("usage: java MeinSAXParser [XML URI]\n");
System.exit(0);
}
String uri = args[0];
MeinSAXParser meinSaxParser = new MeinSAXParser ();
meinSaxParser.verarbeite (uri);
}
}
156 / 446
XML und Java
JAXP - SAX
ContentHandler einfacher: DefaultHandler beerben
org.xml.sax.helpers.DefaultHandler
implementiert ContentHandler
ignoriert alle Ereignisse
Verwendung:
beerbe DefaultHandler
implementiere nur die für die Anwendung wesentlichen
Ereignisse
DefaultHandler Verwendungsmuster
import org.xml.sax.helpers.DefaultHandler;
class MeinContentHandler extends DefaultHandler { ... }
157 / 446
XML und Java
JAXP - SAX
Ausblick: SAX-Filterketten
Mit Filterketten lassen sich mehrere ContentHandler zu
einer Pipeline verketten.
Ein Filter-Modul implementiert die XMLFilter-Schnittstelle.
Der Nachfolger in der Kette wird als Parent-Filter bezeichnet.
Ein XMLFilter agiert wie ein XMLReader, als
Eingabe-Schnittstelle wird aber eine Sequenz von
SAX-Ereignissen erwartet
Die Hilfsklasse XMLFilterImpl ist ein Default-Filter, der die
Ereignisse einfach durchreicht (analog zu DefaultHandler ).
XML
XMLReader
XMLFilter
XMLFilter
ContentHandler
ContentHandler
SAX−Ereignisse
SAX−Ereignisse
SAX−Ereignisse
158 / 446
XML und Java
Java Transformation API (TrAX): XSLT und mehr
Der Clou dieser APIs:
API unterstützt XSLT-Transformationen
API unterstützt mehrere XML-Repräsentations-Formate:
Text-Format (StreamSource, StreamResult)
DOM-Baum (DOMSource, DOMResult)
SAX-Ereignissequenz (SAXSource, SAXResult)
Quellformat und Zielformat sind unabhängig voneinander
API unterstützt Format-Transformationen
XSLT und Format-Transformation beliebig kombinierbar
Transformationen ohne Stylesheets als „Format-Adapter“:
Serialisierung, W3C-DOM → JDOM, . . .
159 / 446
XML und Java
Beispiel: SAX-DOM-Adapter
Document doc = domparser.parse(new File("data.xml"));
// Quellformat: DOM source
Source xmlsource = new DOMSource(doc);
// SAX-ContentHandler instanzieren
ContentHandler handler = new MyHandler();
// ContentHandler als Transformationsziel einbinden
Result result = new SAXResult(handler);
// Transformator erzeugen
TransformerFactory xfactory = TransformerFactory.newInstance();
Transformer xformer = xfactory.newTransformer();
// Transformation: ruft die Callback-Methoden von MyHandler auf
xformer.transform(xmlsource, result);
160 / 446
XML und Java
XSLT-Transformation
XSLT-Stylesheet anwenden: transform007.xsl
// XSLT-Stylesheet-Objekt aus Datei erzeugen
Source xslsource = new StreamSource(new File("transform007.xsl"));
// Transformator-Objekt mit XSLT-Transformation erzeugen
Transformer xformer = xfactory.newTransformer(xslsource);
...
ansonsten wie oben ...
Verwendung eines im XML-Dokument referenzierten Stylesheet
Source xslsource = xfactory.getAssociatedStylesheet(doc,null,null,null);
161 / 446
XML und Java
Komplettes Beispiel für XSLT
import
import
import
import
import
import
import
import
java.io.File;
javax.xml.transform.Source;
javax.xml.transform.Result;
javax.xml.transform.Transformer;
javax.xml.transform.TransformerFactory;
javax.xml.transform.TransformerException;
javax.xml.transform.stream.StreamSource;
javax.xml.transform.stream.StreamResult;
public class SimpleTransformer {
SimpleTransformer xslTransformer = new SimpleTransformer();
xslTransformer.transform();
}
162 / 446
XML und Java
public void transform() {
try {
TransformerFactory tFactory TransformerFactory.newInstance();
Source stylesheet =
new StreamSource(new File("xsl/simpleStyle.xsl"));
Transformer transformer = tFactory.newTransformer(stylesheet);
Source inputDoc = new StreamSource(new File("xml/book.xml"));
Result outputDoc = new StreamResult(new File("result/book.html"));
transformer.transform(inputDoc, outputDoc);
} catch (TransformerException tex) {
tex.printStackTrace();
}
}
}
163 / 446
XML und Java
StAX-Parser (Pull-Parser, Stream-Parser)
Merkmale
StAX = „Streaming API for XML“
Modernste XML-Parser-Technologie (vgl. JSR 173), ab Java 6
API zum Lesen und Erzeugen von XML
Explizite Steuerung des Parsers durch die Anwendung
(„Pull“-Modell)
Zwei Nutzungsmodelle, beides Iteratoren
„Event“ (XMLEventReader): next liefert „Event“-Objekt
„Cursor“ (XMLStreamReader): next liefert Ereignisklasse
Info: http://www.xml.com/pub/a/2003/09/17/stax.html
Referenzimplementierung: http://stax.codehaus.org
164 / 446
XML und Java
StAX-Anwendung mit „Event“-Modell
import javax.xml.stream.*;
import java.net.URL;
import java.io.*;
public class XHTMLOutliner {
if (args.length == 0) {
System.err.println("Usage: java XHTMLOutliner url" );
return;
}
String input = args[0];
try {
URL u = new URL(input);
InputStream in = u.openStream();
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader parser = factory.createXMLStreamReader(in);
165 / 446
XML und Java
int inHeader = 0;
for (int event = parser.next();
event != XMLStreamConstants.END_DOCUMENT;
event = parser.next()) {
switch (event) {
case XMLStreamConstants.START_ELEMENT:
if (isHeader(parser.getLocalName())) {
inHeader++;
}
break;
case XMLStreamConstants.END_ELEMENT:
if (isHeader(parser.getLocalName())) {
inHeader--;
if (inHeader == 0) System.out.println();
}
break;
case XMLStreamConstants.CHARACTERS:
if (inHeader > 0) System.out.print(parser.getText());
break;
case XMLStreamConstants.CDATA:
if (inHeader > 0) System.out.print(parser.getText());
break;
} // end switch
} // end while
parser.close();
}
catch (XMLStreamException ex) {
System.out.println(ex);
}
catch (IOException ex) {
System.out.println("IOException while parsing " + input);
}
}
166 / 446
WWW-Grundlagen
Teil III
WWW-Grundlagen
167 / 446
WWW-Grundlagen
7
Einführung
HTTP, HTML, Browser
8
9
HTTP
XHTML / HTML
HTML – Block- und Inline-Elemente
HTML – Universalattribute
HTML – Anker und Hyperlinks
HTML – Listen
HTML – Bilder
HTML – Tabellen
HTML – Formulare
HTML – Frames und iFrames
10
CSS – Cascading Stylesheets
Überblick
Formatdefinitionen
Schriften
Listen
Klassen
Vererbung und Konfliktauflösung
Boxenmodell
Tabellen
Seitengestaltung
Mozilla Firebug
11
Javascript
Überblick
Sprachelemente
Prototypen
Felder
DOM
Ereignisse
Beispiele
Ajax
12
Webserver
168 / 446
WWW-Grundlagen
Einführung
HTTP, HTML, Browser
WWW-Grundlagen: HTTP, HTML, Browser
Client-Server-Kommunikationsmuster im WWW
WWW-Server
reagiert auf Client-Requests (HTTP-Requests: GET, POST, . . . )
liefert beliebige Informationen: Hypertext-Dokumente, Bilder,
Videos, Software usw.
Hypertextdokumente sind meist HTML-Dokumente
WWW-Client
fordert Informationen per Request an
nimmt die Informationen vom Server entgegen
verarbeitet empfangene Informationen abhängig von deren Typ
Client-Typen: WWW-Browser, Download-Manager, Crawler usw.
169 / 446
WWW-Grundlagen
Einführung
HTTP, HTML, Browser
Begriffe: Webseite, Homepage, Portal, Website
Webseite („web page“): ein einzelnes HTML-Dokument
Website („Webangebot“, „Webpräsenz“, „Internetpräsenz“):
Der komplette Internetauftritt einer Firma, Behörde,
Kommune, Institution, . . . oder auch einer Privatperson
Homepage: Einstiegsseite einer Website
Einführungsseite: Eine der Homepage vorgelagerte Seite mit
geringem Informationsgehalt (oft Flash-Spielereien)
Webportal: Eine Webseite, die als Einstiegspunkt und
Integrationsmechanismus für die Nutzung gebündelter Dienste
dient
170 / 446
WWW-Grundlagen
HTTP
HTTP - Hypertext-Transfer-Protokoll
Merkmale
Kommunikationsmuster: Client-Request – Server-Response
Zweck: Übertragung von „Multimedia-Inhalten“
(und sonstigen Informationen)
HTTP-Server zustandslos: vergisst alle Anfrage-Daten nach
Beantwortung
Nachrichtenformat (Request- und Response-Nachrichten)
Klartext-Nachrichten
Nachricht besteht aus Kopf und Rumpf
Kopf: Metainformationen (Attributname/Attributwert-Paare)
Rumpf: Nutzlast oder leer
171 / 446
WWW-Grundlagen
HTTP
Kommunikation im WWW
172 / 446
WWW-Grundlagen
HTTP
HTTP im Protokollstack
Transportprotokolle auf verschiedenen Ebenen
HTTP nach ISO-OSI-Modell „Anwendungsschicht“, aber:
HTTP ist ein „höheres“ Transportprotokoll
benutzt selbst TCP als niedere Transportschicht
dient für noch „höhere“ Transportprotokolle (z.B. SOAP) als
Basis-Transport
Kombination HTTP mit SSL/TLS (HTTPS) möglich:
Verschlüsselung und Authentifizierung
173 / 446
WWW-Grundlagen
HTTP
HTTP mit und ohne SSL
174 / 446
WWW-Grundlagen
HTTP
HTTP und Erweiterungen
Requesttypen
Wichtige Requesttypen: GET, POST
Sonstige Requesttypen:
HEAD, PUT, DELETE, TRACE, OPTIONS, CONNECT
Erweiterungen
WebDAV (Web-based Distributed Authoring and Versioning)
Standard zur Verwaltung von Dateien auf dem WWW-Server
XMLHttpRequest
Javascript-API zur Übertragung von XML-Daten über HTTP
Ajax (Asynchronous JavaScript and XML)
Dynamisches Nachladen von partiellen Webseiten per
XMLHttpRequest
175 / 446
WWW-Grundlagen
HTTP
HTTP-Adressen: URL, URI und Co.
URL – Uniform Resource Locator
identifiziert eine Web-Ressource (Dokument, Dienst, . . . )
Speicherort der Ressource ergibt sich aus URL
Mehrere Varianten: pro Transport ein URL-Schema
(http, ftp, https usw.)
URL-Beispiele
http://www.example.org/praesentation.html
http://www.google.com/search?hl=de&q=billiges+katzenfutter
ftp://www.example.org/praesentation.pdf
http://192.168.78.10:8082
https://www.studentenbank.de/homebanking
mailto:[email protected]
file:///home/hg52/docs
176 / 446
WWW-Grundlagen
HTTP
HTTP-URL und seine Bestandteile
Aufbau eines URL am Beispiel
Schema
Rechnername
Port
serverseitiger Pfad
http://
www.fh-giessen.de
:80
/index.html
URL mit Aufruf einer serverseitigen Funktion
http://www.google.de/search?hl=de&q=URL+URI&client=iceweasel
Funktion
search
Parameter
?
hl=de
Parameter
&
q=URL+URI
Parameter
&
client=iceweasel
177 / 446
WWW-Grundlagen
HTTP
URN – Uniform Resource Name
Ortsunabhängiger Name einer Ressource
Als XML-Namespace gebräuchlich
Bsp.: urn:oasis:names:tc:SAML:2.0:protocol
URI – Uniform Resource Identifier
Oberbegriff für URL und URN
Oft keine Unterscheidung zwischen URI und URL
IRI – Internationalized Resource Identifier
Zeichensatzerweiterung auf den „Universal Character Set“
(entspricht etwa dem Unicode-Zeichensatz)
178 / 446
WWW-Grundlagen
HTTP
URLs und DNS
Domain Name Service (DNS): weltweit verteilter Verzeichnisdienst.
Bestimmung der Transportadressen aus URL mittels DNS
Aus HTTP-Adresse (URL) muss Transportadresse bestimmt werden,
z.B. IP-Nummer + TCP-Portnummer
URLs mit Rechnernamen (www2.meinedomain.de):
DNS-Verzeichnisdienst liefert IP-Nummer
mailto-URLs: DNS liefert Adresse der zuständigen Mailserver
URL enthält Portnummer, falls nicht Standardport des Schemas
(http: 80, https: 443, mailto: 25, usw.)
179 / 446
WWW-Grundlagen
HTTP
URLs und DNS
180 / 446
WWW-Grundlagen
HTTP
HTTP-GET: Google-Suchanfrage nach „XML parser“
Anfrage-Header
GET /search?q=XML+parser HTTP/1.0
User-Agent: keinBesonderer
Host: www.google.de
Antwort-Header
HTTP/1.0 200 OK
Cache-Control: private
Content-Type: text/html; charset=ISO-8859-1
Set-Cookie: PREF=ID=f4000a82f78b4425:TM=1208976322:LM=1208976322
expires=Fri, 23-Apr-2010 18:45:22 GMT;
path=/; domain=.google.de
Set-Cookie: SS=Q0=eGVyY2VzIGRvd25sb2Fk; path=/search
Date: Wed, 23 Apr 2008 18:45:22 GMT
Server: gws
Connection: Close
181 / 446
WWW-Grundlagen
HTTP
Anfrage-Rumpf: bei GET leer!
Antwort-Rumpf: HTML-Dokument
<html>
<head>
<meta http-equiv=content-type content="text/html;charset=ISO-8859-1">
<title>XML parser - Google-Suche</title>
</head>
<body>
...
</body>
<html>
182 / 446
WWW-Grundlagen
HTTP
GET-Request versus POST-Request
GET-Variante: Parameter im URL
Kopf:
GET /wiki/Spezial:Search?search=Katzen&go=Artikel HTTP/1.0
Host: de.wikipedia.org
POST-Variante: Parameter im Rumpf
Kopf:
POST /wiki/Spezial:Search HTTP/1.0
Host: de.wikipedia.org
Content-Type: application/x-www-form-urlencoded
Content-Length: 24
Rumpf:
search=Katzen&go=Artikel
183 / 446
WWW-Grundlagen
HTTP
HTTP-Analyse mit „Firebug“
184 / 446
WWW-Grundlagen
HTTP
Statuscodes in der HTTP-Antwort
Server liefert in jeder Antwort Statuscode
1xx
Informationen
Bearbeitung der Anfrage läuft noch
2xx
Erfolgreiche
Operation
Bearbeitung der Anfrage normal ausgeführt
3xx
Umleitung
weitere Schritte des Clients erforderlich
4xx
Client-Fehler
Fehler im Verantwortungsbereich des Clients
5xx
Server-Fehler
Fehler im Verantwortungsbereich des Servers
185 / 446
WWW-Grundlagen
HTTP
Cookies: Request-übergreifende Info für den Server
Problem: HTTP-Server braucht Request-Zuordnung
zu einer Sitzung (Konversation mit mehreren HTTP-Nachrichten)
zu einem Benutzerkonto (Benutzerdaten-Zuordnung ohne Login)
zu einem Warenkorb (Onlineshop)
Lösung: Identifizierende Cookies hin- und herschicken
Server generiert Cookie (z.B. eindeutige Sitzungsnummer)
schickt Cookie im Kopf der HTTP-Antwort
Browser speichert Cookie permanent (Dateisystem)
schickt Cookie bei jedem Folgerequest wieder an den Server zurück
Server kann anhand des Cookies den Request zuordnen
(z.B. zu einer aktiven Sitzung)
186 / 446
WWW-Grundlagen
HTTP
Aufbau von Cookies
Cookie = Name + Wert + Attribute
Wert: beliebige Zeichenkette (bis zu 4 KB Länge)
Optionale Attribute (Auswahl):
Verfallszeit: Max-Age, expires
Gültigkeits-Domäne: Domain
Gültigkeits-Pfad: Path
Beispiel einer HTTP-Antwort mit Cookie
HTTP/1.0 200 OK
Set-Cookie: SessionID="19878906646543";
expires=Tue, 29-Mar-2010 19:30:42 GMT;
Max-Age=2471000;
Path=/servlet/warenkorb;
Version="1"
187 / 446
WWW-Grundlagen
HTTP
WWW-Kommunikation mit Umleitung und Nachladen
188 / 446
WWW-Grundlagen
HTTP
Abwicklung eines HTTP-Request durch Webbrowser
„Einfacher“ Abruf eines HTML-Dokuments
Cache prüfen, ob Dokument schon vorhanden
Ziel-URL parsen und Cookie-Datenbasis durchsuchen:
Welche Cookies passen bzgl. Domäne und Pfad zum Ziel-URL?
Verfalldatum der Cookies beachten
Kopf-Daten mit Cookies zusammenstellen
Kopf-Daten und ggf. Anfrage-Rumpf an Server verschicken
Antwort lesen, ggf. Fehlerbehandlung abhängig vom Antwort-Status
Bei Status „URL-Umleitung“: erneute Anfrage
189 / 446
WWW-Grundlagen
HTTP
nach Empfang des HTML-Dokuments:
HTML-Dokument parsen
benötigte weitere Daten nachladen
(jeweils Cache und Cookies prüfen):
CSS-Formatvorlagen
integrierte Bilder
separate JavaScript-Dateien
...
Javascript onload-Aktionen ausführen,
dabei Benutzereinstellungen wie URL- oder Domänen-spezifische
Popup-Verbote berücksichtigen
Formatvorlagen parsen und interpretieren, Konflikte auflösen
Inhalt rendern
190 / 446
WWW-Grundlagen
HTTP
Zusätzliche Komplexität möglich:
SSL-gesicherte Verbindungen: Zertifikatsprüfung, Sperrlistenprüfung
Login-Vorgang bei beschränkt zugänglichen Ressourcen abwickeln
asynchrone Aktivitäten (AJAX)
Client-seitige DOM-Modifikationen: XSLT-Transformationen,
Javascript
Applet-Ausführung
...
Ein HTML-Download ist in der Regel keine einfache Aktion!
191 / 446
WWW-Grundlagen
XHTML / HTML
XHTML/HTML – Hypertext Markup Language
XHTML und HTML sind W3C-Standards
XHTML
XML-Sprache
striktere Syntaxanforderungen als HTML
Versionen und Varianten
HTML 4: sehr weit verbreitet, seit 1997, derzeit Version 4.01
XHTML 1: verbreitet, Weiterentwicklung von HTML 4.01, derzeit
Version 1.1
XHTML 2: Entwicklung 2009 eingestellt
HTML 5: zukünftiger Standard, nicht fertig, soll Unterschiede
zwischen HTML und XHTML verringern
192 / 446
WWW-Grundlagen
XHTML / HTML
XHTML-Beispiel
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Meine Homepage</title>
</head>
<body>
<h1> Überschrift </h1>
<p> Ein Text-Abschnitt. </p>
<p> Ein weiterer Text-Abschnitt. </p>
<ul>
<li> Ein Listenelement. </li>
<li> Und noch eines. </li>
</ul>
</body>
</html>
193 / 446
WWW-Grundlagen
XHTML / HTML
Unterschiede XHTML / HTML (1/2)
MIME-Typen für korrekte Interpretation:
HTML:
text/html
XHTML: application/xhtml+xml
XML-Deklaration am Anfang:
<?xml version="1.0" encoding="..." ?>
DTD-Referenz für XHTML 1.0:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
Namensraum für html-Element zwingend:
...
</html>
194 / 446
WWW-Grundlagen
XHTML / HTML
Unterschiede XHTML / HTML (2/2)
bei XHTML Kleinschreibung von Element- und Attributnamen
head- und body-Elemente zwingend
Bei allen Elementen Abschluss-Tags erforderlich
(z.B. img, br, li, p, body)
Attributwerte immer in Anführungszeichen
Bei Verweisen statt name-Attribut id-Attribut verwenden
195 / 446
WWW-Grundlagen
XHTML / HTML
XHTML oder HTML ?
Vorteile durch XML-Konformität
Verarbeitung mit XML-Software möglich
Einbettung in andere XML-Daten möglich
(„Dateninsel“, siehe nachfolgendes Beispiel)
Nachteile von XHTML
Mehr Schreibaufwand durch striktere Syntax
Kompatibilität mit HTML 5 noch unklar
196 / 446
WWW-Grundlagen
XHTML / HTML
Beispiel: XHTML-Dateninsel in einem XML-Dokument
<?xml version="1.0" encoding="ISO-8859-1" ?>
<buch xmlns="http://www.meinserver.de/XML/buch">
<kapitel nummer="1">
<head><title>Einleitung</title></head>
<body>
<h1>Einleitung</h1>
<p>Das Buch beginnt mit diesem Text...</p>
</body>
</html>
</kapitel>
</buch>
197 / 446
WWW-Grundlagen
XHTML / HTML
HTML-Dokumentstruktur
DOCTYPE-Deklaration (optional)
Angabe zur verwendeten HTML-Version
(zur Validierung gegen die Versions-spezifische DTD)
Kopf (<head>)
Titel des Dokuments (<title>)
z.B. vom Browser genutzt als
Fenstertitel/Reiterbeschriftung/Lesezeichen
von Suchmaschinen für Index-Eintrag genutzt
Dokumentenbasis-URL (<base>)
Meta-Informationen (<meta>)
Information für Suchmaschinen
HTTP-Konfiguration
Rumpf (body)
Inhalt: Text mit eingebetteten Bildern und Hyperlinks
198 / 446
WWW-Grundlagen
XHTML / HTML
Meta-Tags im HTML-Kopf
<meta ... /> – Suchmaschinen-Info, HTTP-Konfiguration
<head>
<title> Johannes Brahms Homepage </title>
<base href="http://www.brahms.de" />
<meta name="keywords" content="Johannes Brahms,Komponist,Biographie" />
<meta name="title" content="Johannes Brahms Homepage" />
<meta name="author" content="Johannes Brahms" />
<meta name="description" content="Lebensdaten von Johannes Brahms. " />
<meta name="robots" content="index,nofollow" />
<meta name="revisit" content="after 7 days" />
<meta http-equiv="expires" content="86400" />
<meta http-equiv="pragma" content="no-cache" />
<meta http-equiv="refresh" content="5; url=brahms-homepage.html" />
</head>
(mehr dazu: http://de.selfhtml.org/html/kopfdaten/meta.htm)
199 / 446
WWW-Grundlagen
XHTML / HTML
HTML-Rumpf: Block- und Inline-Elemente
Blockelement
zur Strukturierung des Inhalts
erstreckt sich immer über komplette Zeilen
Beispiele: Überschrift, Paragraph, Liste, Listenlement, Tabelle, Formular
Inline-Element
Auszeichnung von Bereichen innerhalb eines Blocks bzw. einer Zeile
Beispiele: Fettschrift, Hyperlink
200 / 446
WWW-Grundlagen
XHTML / HTML
Wichtige Block-Elemente
Überschriften
<h1>, . . . , <h6>
h=heading
Zeilenumbruch
<br/>
br=break
Paragraph
<p>...</p>
p=paragraph
Vorformatierter Text
<pre> ... </pre>
pre=preformatted text
Trennlinie
<hr/>
hr=horizontal rule
Zitatblock
<blockquote>
CSS-Container
<div>
Gruppierungselement für Zuordnung von CSS-Attributen
<div>-Beispiel
<div style="background:red; font-size:10px;">
...
</div>
201 / 446
WWW-Grundlagen
XHTML / HTML
Wichtige Inline-Elemente
stark betont
<strong>
früher <b> (boldface)
betont
<em>
emphasized, früher <i> (italic)
Teletype
<tt>
nicht proportionale Schrift
hochgestellt
<sup>
superscripted
tiefgestellt
<sub>
subscripted
Inline-Zitat
<cite>
CSS-Container
<span>
„Inline-Version“ von <div>
202 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Universalattribute
Universalattribute
Ein Universalattribut ist für (fast) alle Elemente definiert
class
CSS-Klasse für Präsentationsattribute
id
Eindeutiger Bezeichner für Referenzen
style
Inline-CSS-Stil-Definition
title
Tooltip-Text
(Anzeige im Browser, wenn der Mauszeiger auf Element zeigt)
Element mit Universalattributen
<div class="addressContent" title="Lageplan und Anfahrt">
Gebäude I, Raum 122 <br/>
Wiesenstraße 14 <br/>
35390 Gießen
</div>
203 / 446
WWW-Grundlagen
XHTML / HTML
Anker-Element und Hyperlinks
Anker-Element <a>
definiert auswählbaren Verweis (Hyperlink) und/oder ein Verweisziel
Inhalt: Text oder Bild
Hyperlink
verweist auf eine durch einen URL adressierte WWW-Ressource
wird als „href“-Attribut des Anker-Elements angegeben
(href=hyper reference)
Beispiel: Anker mit Hyperlink
<a href="http://www.mni.fh-giessen.de"> Fachbereich MNI </a>
204 / 446
WWW-Grundlagen
XHTML / HTML
Hyperlinks
Hyperlink-Auswahl (z.B. Mausklick) löst Aktion aus:
bei HTTP-URL: HTTP GET-Request
bei Datei-URL (file:///home/hg52): Dateianzeige
mailto-URL: Aufruf eines Mailprogramms
ftp-URL: Aufbau einer FTP-Verbindung
Relative Pfade als URL (href="bilder/bild1.png")
beziehen sich auf die Dokumentenbasis
Basis wird aus URL des aktuellen HTML-Dokuments bestimmt
Basis kann mit <base> im Kopf explizit gesetzt werden
205 / 446
WWW-Grundlagen
XHTML / HTML
Beispiel: Anker und Dokumentenbasis
Datei: ibs/index.html
<head> ...
<base href="http://m-jaeger.de/lv/ibs" />
</head>
<body>
...
Hier finden Sie das
<a href="skript/skript.pdf" title="Skript als PDF">Skript</a>
...
Aktionen
Falls Maus auf Anker: Tooltip-Popup „Skript als PDF“
Bei Mausklick auf Anker: HTTP GET-Request mit URL
http://m-jaeger.de/lv/ibs/skript/skript.pdf
206 / 446
WWW-Grundlagen
XHTML / HTML
Anker als Verweisziel
Verweisziel-Anker und Hyperlink-Anker
<h1> <a id="kapitel_01"> Kapitel 1 - Übersicht </a> </h1>
...
<h1> <a id="kapitel_02"> Kapitel 2 - Einleitung </a> </h1>
...
<a href="#kapitel_01"> zurück zur Übersicht </a>
...
jedes Kapitel durch „id“ direkt auswählbar
URL-Syntax: Dokument-URL#Anker-ID
Anker gleichzeitig als Verweis und Verweisziel nutzbar
207 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Listen
Aufzählungen / Listen
Verschiedene Layout-Varianten: ul, ol, dl
Element
Bedeutung
englisch
Erläuterung
<ul>
unnummerierte Liste
unordered list
<ol>
nummerierte Liste
ordered list
Elemente ab 1 nummeriert
<li>
Listenelement
list item
Element von ul- ond ol-Liste
<dl>
Definitionsliste
definition list
Listenelemente jeweils: Begriff
und Erklärung
<dt>
Begriff
defined term
<dd>
Erklärung
definition data
208 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Bilder
Bilder im HTML-Dokument
Verwendung von Bildern in HTML
im normalen Textfluss
als anklickbare Hyperlinks
als Aufzählungspunkt für unnummerierte Listen
Bild-Einbettung mit <img>
<img src="bilder/landschaft.jpg" width="300px" height="200px"
alt="Landschaftsbild" title="Toskana im Sommer"/>
Unbedingt Alternativ-Text („alt“-Attr.) angeben!
(Textbrowser, Screenreader, keine Bilder wegen geringer Bandbreite, . . . )
209 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Tabellen
HTML-Tabellen
Tabellen, Zeilen und Zellen
Eine Tabelle ist eine Liste von Tabellenzeilen
Eine Tabellenzeile ist eine Liste von Zellen
Tabelle: <table>-Element
Zeile: <tr>-Elementen (tr=table row)
Zelle: <td>-Element (table data)
Spaltenüberschrift: <th>-Element (table heading) statt <td>
210 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Tabellen
Mehrzeilige und mehrspaltige Zellen
Zelle kann sich über beliebig viele Zeilen und/oder Spalten
erstrecken
Zelle über 3 Zeilen:
<td rowspan="3">
Zelle über 4 Spalten: <td colspan="4">
Tabellen-Layout
HTML-Attribute für Layout: width, border, cellspacing usw.
Bei CSS-Verwendung sind diese Attribute unnötig!
211 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Tabellen
Beispiel: Einfache Tabelle
HTML-Quelltext
<table border="1">
<tr>
<th colspan="2">
Die Menschheit besteht aus
</th>
</tr>
<tr>
<td>Eseln</td>
<td>Affen</td>
</tr>
</table>
Anzeige im Browser
Die Menschheit besteht aus
Eseln
Affen
212 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
HTML-Formulare
Ein HTML-Formular erfasst Daten für den Webserver
Übermittlung durch GET- oder POST-Requests möglich
Datenübermittlung: Liste mit „Name=Wert“-Paaren
Formular-Beispiel
<form method="GET" action="http://www.google.de/search">
<input type="hidden" name="hl" value="de" />
<input type="text"
name="q" value="" size="40" maxlength="256" />
<input type="submit" name="btnG" value="Suchen" />
</form>
HTTP-Request bei Eingabe „Katze“ und Klick auf „Suchen“:
GET http://www.google.de/search?hl=de&q=Katze&btnG=Suchen
213 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Eingabefelder in Formularen
Texteingaben
kurze Texteingaben: <input type="text">
<input type="text" name="Land" value="Deutschland" size="40" />
Passworteingaben:
<input type="password" ...>
größere Textbereiche: <textarea>-Element
<textarea name="Anmerkungen" cols="50" rows="6" />
Versteckte Felder
z.B. zur Übertragung von Sitzungsinformation (statt Cookies):
<input type="hidden" ...>
214 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Formular-Schaltflächen
Schaltflächen für Formular-Aktionen
Versenden des Formulars:
<input type="submit" ...>
Rücksetzen des Formulars:
<input type="reset" ...>
Javascript-Aktion:
<input type="button" ...>
215 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Auswahl-Elemente
Auswahllisten: <select>
Auswahl von einem oder mehreren Werten aus Liste
Vorselektion möglich
Problem: Benutzer kennt sich oft nicht mit Mehrfachselektion aus
Beispiel mit Mehrfachselektion
<select name="Lieblingsgerichte" size="3" multiple="multiple">
<option value="pizza">Pizza</option>
<option selected="selected">Linseneintopf</option>
<option selected="selected">Erbseneintopf</option>
</select>
216 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Auswahl mit Radiobuttons und Checkboxen
Radiobutton (Einfachauswahl): <input type="radio">
<input type="radio" name="Zahlung" value="Visa" />Visa<br/>
<input type="radio" name="Zahlung" value="Paypal" />Paypal<br/>
<input type="radio" name="Zahlung" value="Lastschrift" />Lastschrift<br/>
Checkbox (Mehrfachauswahl): <input type="checkbox">
<input type="checkbox" name="check1" value="Milch">Milch<br>
<input type="checkbox" name="check2" value="Butter" checked>Butter<br>
<input type="checkbox" name="check3" value="Käse">Käse<br>
217 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Beispiel-Formular mit allerlei Eingabefeldern
<html>
<head>
<meta http-equiv="content-type"
content="text/html; charset=UTF-8">
<title>Formulartest</title>
</head>
<body>
<form method="GET">
<strong>Textfeld </strong><br/>
<input type="text" name="textfeld"
value="Anfangstext" size="20" />
<p><strong>Text-Area </strong><br/>
<textarea name="Bereich" cols="20" rows="3">
Anfangstext 2
</textarea>
<p><strong>Select mit Mehrfachauswahl
</strong><br/>
<select name="Lieblingsgerichte"
size="4" multiple="multiple">
<option>Pizza</option>
<option>Nudeln</option>
<option selected="selected">Linseneintopf
</option>
<option selected="selected">Erbseneintopf
</option>
</select>
<div style="position:relative">
<strong>3 Radio-Buttons</strong><br/>
<input type="radio" name="Zahlung"
value="Visa"/>Visa<br/>
value="Paypal" />Paypal<br/>
value="Lastschrift" />Lastschrift<br/>
<div style=
"position:absolute;left:50mm;width:40mm;">
<strong>3 Checkboxen</strong><br/>
<input type="checkbox" name="check1"
value="Milch">Milch<br>
value="Butter" checked>Butter<br>
value="Käse">Käse<br>
</div>
</div>
<p>
<input type="submit" name="submit"
value="Submit-Schaltfläche" />
<input type="reset" name="reset"
value="Reset-Schaltfläche" />
</form>
</body>
</html>
218 / 446
WWW-Grundlagen
XHTML / HTML
HTML – Formulare
Beispiel-Formular in der Browseransicht
219 / 446
WWW-Grundlagen
XHTML / HTML
HTML-Frames
Frames: Aufteilung des Browserfensters
Frameset teilt Fenster in mehrere Teilbereiche
z.B Kopfbereich, Navigationsbereich, Informationsbereich
Browser verarbeiten Frames nebenläufig
Verwendung verletzt Prinzip der Trennung von Inhalt und Form
Manche Browser unterstützen Frames nicht (Smartphones)
Verweise funktionieren oft nicht richtig
(Problem: Verweis auf Frameset oder auf Einzel-Inhalt?)
Fazit: Problematisch, besser nicht verwenden!
Alternativen: <iframe>- und <div>-Elemente/CSS
220 / 446
WWW-Grundlagen
XHTML / HTML
Eingebette Frames (iframe-Element)
Eingebettete Frames ermöglichen wie Frames die integrierte
Darstellung mehrerer HTML-Seiten im selben Browserfenster
Im Gegensatz zu Frames keine starre Fensteraufteilung,
sondern Integration in den Textfluss wie bei eingebetteten
Grafiken
Typische Nutzung: Integration von Inhalten anderer Anbieter
in das Webangebot
(mehr http://de.selfhtml.org/html/frames/eingebettete.htm)
221 / 446
WWW-Grundlagen
Überblick
Cascading Stylesheets (CSS): HTML-Formatvorlagen
Motivation: Trennung von Inhalt und Präsentation
Inhalt + Struktur
Präsentationseigenschaften
→ HTML-Datei
→ CSS-Formatvorlage
CSS: Layout-Vorschriften für HTML-Elemente
Schriftart /-größe/-farbe
Hintergrundgestaltung
Positionierung von Elementen
Textfluss
Tabellen-Layout
Listengestaltung
usw.
222 / 446
WWW-Grundlagen
Überblick
Separate und eingebettete CSS-Definitionen
Wo stehen CSS-“Stylesheets“?
style-Element im HTML-Kopf (für Dokument-Layout)
style-Attribut eines Elements (Element-Layout)
separate CSS-Datei (Website-Layout)
Verwendung der selben CSS-Datei(en) für alle HTML-Dokumente
Für ein Webangebot können alternative Stylesheets angeboten
werden, z.B. für Geräte mit niedriger Auflösung wie Smartphones
223 / 446
WWW-Grundlagen
Überblick
Beispiel: CSS-Definitionen im HTML-Kopf und im Element
Schriftfarbe und Zeichengröße für Überschriften
<html ...>
<head>
<title> ... </title>
<style type="text/css">
h1 { color:red; font-size:48px; }
</style>
</head>
<body>
...
<h1> Rote Schrift </h1>
<h2 style="color:blue; font-size:32px;" > Blaue Schrift </h2>
...
</body>
</html>
224 / 446
WWW-Grundlagen
Überblick
CSS-Definitionen in separater Datei: <link>-Element
CSS-Datei: meinformat.css
h1 { color:red; font-size:48px; }
HTML-Datei
<html ...>
<head>
<title> ... </title>
<link rel="stylesheet" type="text/css" href="meinformat.css" />
</head>
<body>
...
<h1> Rote Schrift </h1>
...
</body>
</html>
225 / 446
WWW-Grundlagen
Formatdefinitionen
CSS-Formatdefinition: Selektor + Deklaration
Selektor bestimmt Anwendungsbereich
Einfache Auswahlkriterien
Elementtyp
Element-ID
Klasse
Pseudo-Klasse
h1, div, *
#einleitung
.kapitel
:first-child, :hover, :visited
Einfache Selektoren
z.B. div.kapitel, a:visited, h1#einleitung:hover.
Komplexe Selektoren mit Operatoren
z.B. ul li, td+td, p.kapitel[align="left"]
226 / 446
WWW-Grundlagen
Formatdefinitionen
Deklarationen
Deklarationen bestehen aus Paaren der Form
Attributname:Attributwert
Beispiele: { color:red; font-size:48px; }
Deklarationen können für den Fall von Konflikten als wichtig
gekennzeichnet werden, z.B.
{ font-size:1em !important; }
Mehrere Selektoren können, durch Komma getrennt, an eine
Deklaration gebunden werden
Beispiel: h1, h2 { color:red; font-size:48px; }
227 / 446
WWW-Grundlagen
Formatdefinitionen
CSS-Beispiel
<html ...>
<head> <title>
...
</title>

<link rel="stylesheet" type="text/css" href="formate.css">

body { background-color:#FFFFCC; margin-left:100px; }
*
{ color:blue; }
h1
{ font-size:300%; color:#FF0000;
font-style:italic;
border-bottom:solid thin black; }
p,li { font-size:110%; line-height:140%;
font-family:Helvetica,Arial,sans-serif;
letter-spacing:0.1em; word-spacing:0.3em; }
</style>
</head>
<body> ... </body>
</html>
228 / 446
WWW-Grundlagen
Formatdefinitionen
Selektoren-Beispiele
Selektor
selektierte Elemente
div p
div > p
div + p
div>*>*>p
p[align]
p[align=center]
body:first-child
td:first-child + td
#myid
form#myid
td[abbr~=Berlin]
*[lang|=en]
.kapitel
div.kapitel
:hover
p-Element im Teilbaum unterhalb von div-Element
p-Element als Kind eines div-Elements
p-Element direkt hinter div-Element
p-Element drei Ebenen unterhalb von div-Element
p-Element mit align-Attribut
p-Element mit align=center
erstes Kind-Element eines body-Elements
td-Elemente in der 2. Spalte einer Tabelle
jedes Element mit der ID myid
form-Element mit der ID myid
td-Element, Berlin kommt im abbr-Attribut vor
beliebiges Element, Attribut lang beginnt mit „en“
alle Elemente der benutzerdefinierten Klasse kapitel
alle div-Elemente der benutzerdefinierten Klasse kapitel
Pseudo-Klasse für alle Elemente unter Mauszeiger
229 / 446
WWW-Grundlagen
Schriften
Gestaltungselemente: Schriften
Serifenschriften
haben unten rechts an den Buchstaben kleine Häkchen
sind für hohe Auflösung (Bücher, Zeitungen) gut geeignet
Beispiele: „Times“, „Times New Roman“, „Georgia“
Serifenlose Schriften
sind auf Bildschirmen mit niedriger Auflösung besser lesbar
Beispiele: „Helvetica“, „Arial“, „Verdana“
Monospace-Schriften (im Gegensatz zu Proportionalschriften)
haben für jedes Zeichen die gleiche Breite
werden z.B. für Programmtexte gerne verwendet
Beispiel: „Courier“
230 / 446
WWW-Grundlagen
Schriften
Schriften in CSS
Attribut
Bedeutung
Beispiele
font-family
font-size
font-weight
font-style
color
Schriftfamilie, -art
Größe
Gewicht („Fettigkeit“)
Neigung
Farbe
sans-serif, helvetica
xx-large, smaller, 120%, 11pt
bold, lighter, 200
italic, oblique, normal
blue, #c33b00
Angabe von Alternativ-Schriften möglich, z.B.
font-family: verdana, helvetica, arial, sans-serif;
(mehr dazu: http://de.selfhtml.org/css/eigenschaften/schrift.htm)
231 / 446
WWW-Grundlagen
Schriften
Beispiel:
Paragraphen in Verdana
p
{ font-size:
font-family:
font-weight:
font-style:
}
small;
Verdana, sans-serif;
bolder;
italic;
Kurzschreibweise (festgelegte Reihenfolge der Attribute)
p
{ font: italic bolder small Verdana, sans-serif; }
232 / 446
WWW-Grundlagen
Listen
Gestaltungselemente: <ul>-Listen
Listentrenner
Standard: gefüllte schwarze Kreise
Andere Symbole: list-style-type:
circle, disc, square, none
Grafik: list-style-image
(Symbol als Ersatzdarstellung möglich)
Beispiel
ul
{ list-style-image:url("bilder/kleines-herz.gif");
list-style-type:square; }
Kurzform
ul
{ list-style:url("bilder/kleines-herz.gif") square; }
233 / 446
WWW-Grundlagen
Klassen
Benutzerdefinierte CSS-Klassen
Universalattribut „class“
.NeueSeite { ... }
h1.Hinweis { ... }
...
</style>
...
<h1 class="NeueSeite Hinweis">
CSS-Klassen des <h1>-Elements:
NeueSeite
globale Klasse für alle Elemente
h1.Hinweis
Unterklasse für <h1>-Elemente
234 / 446
WWW-Grundlagen
Vererbung von Attributen
CSS-Attribute eines Elements werden prinzipiell an die
Nachfolger im Dokumentenbaum vererbt
Ein Element kann geerbte Attribute aber überschreiben:
<div style="color:red;">
<ul> <li> Schriftfarbe rot, vom div-Element geerbt</li>
<li style="color:green;"> Schriftfarbe grün </li>
</ul>
</div>
Die genauen Vererbungsregeln sind recht komplex
(mehr dazu: http://www.thestyleworks.de/basics/inheritance.shtml)
235 / 446
WWW-Grundlagen
Konfliktauflösung / Kaskadenmodell
Neben serversseitigen CSS-Definitionen des Web-Autors
(Autoren-Stylesheet) berücksichtigt ein Browser
Benutzer-Stylesheets (z.B. Firefox: userChrome.css)
Benutzer-Voreinstellungen, sogenannte Browser-Stylesheets
Falls auf ein Element mehrere Selektoren zutreffen, kann es zu
widersprüchlichen Attribut-Deklarationen kommen.
Der Algorithmus zur Konfliktauflösung heißt „Kaskade“.
236 / 446
WWW-Grundlagen
Prinzipien des Kaskade-Algorithmus
Quelle der Deklaration und „important“-Kennzeichnung
Priorität
höchste
geringste
Quelle der Deklaration
Benutzer-Stylesheet
Autoren-Stylesheet
Autoren-Stylesheet
Benutzer-Stylesheet
Browser-Stylesheet
Art der Deklaration
!important
!important
normal
normal
–
Spezifischer Selektor vor einem allgemeineren
h1.kapitel ist spezifischer als
h1 oder .kapitel
h1#kapitel1 ist wegen der ID spezifischer als h1.kapitel
(mehr dazu in http://de.selfhtml.org/css/formate/kaskade.htm)
237 / 446
WWW-Grundlagen
Boxenmodell
Boxenmodell für Blockelemente
Jedes Blockelement belegt Rechteck im
Browserfenster
besteht aus Rahmen und Inhaltsbereich.
Größe des Inhaltsbereichs: width und height
Innenabstand (padding): Abstand zwischen
Rahmen und Inhaltsbereich.
Außenabstand (margin): Abstand des
Blockelements zu seiner Umgebung
Abstände und Rahmenbreite für jede Seite
separat spezifizierbar (border-left,
margin-bottom, padding-top usw.)
Bei angrenzenden Blöcken wird der jeweils
größere Außenabstand verwendet
238 / 446
WWW-Grundlagen
Boxenmodell
Beispiel
Gelb unterlegte Paragraphen mit blauen Rahmen
p { border:5px dotted blue;
padding: 10px;
margin: 10px;
background: yellow;
width: 150mm;
}
Rahmendefinition ist Kurzform von
border-size:5px; border-style:dotted; border-color:blue;
239 / 446
WWW-Grundlagen
Tabellen
Tabellen-Gestaltung
CSS-Attribute für <table>-Element
Rahmen, Breite, Zellabstand (border-spacing)
table-layout bestimmt Spaltenbreite
fixed feste Größe
auto Anpassung an Zellinhalt
caption-side: Position der Tabellenbeschriftung
CSS-Attribute für die Zellen
Rahmen, Innenabstand, Textausrichtung
text-align – horizontale Ausrichtung
vertical-align – vertikale Ausrichtung
(mehr dazu: http://de.selfhtml.org/css/eigenschaften/tabellen.htm)
240 / 446
WWW-Grundlagen
Seitengestaltung
Seitengestaltung mit CSS
Basis für Seitengestaltung: <div>-Element
Beispiel: Seitenaufteilung in Navigationsbereich, Kopfbereich,
Fußbereich und Inhaltsbereich: 4 entsprechende <div>-Blöcke
Positionierung: position-Attribut
gemäß normalem Textfluss (position:static, Normalfall)
relativ zueinander, mit festgelegter (horizontaler und
vertikaler) Distanz: position:relative
relativ zum Container-Element und unabhängig von den
anderen Bereichen position:absolute
absolut im Browserfenster: position:fixed
Bei Überschneidungen lassen sich Sichtbarkeitsebenen definieren
(z-index-Attribut)
241 / 446
WWW-Grundlagen
Seitengestaltung
Positionierungsattribute
position
top
left
bottom
right
width
min-width
max-width
height
min-height
max-height
overflow
direction
float
clear
z-index
display
visibility
clip
Positionsart
Startposition von oben
Startposition von links
Startposition von unten
Startposition von rechts
Breite
Mindestbreite
Maximalbreite
Höhe
Mindesthöhe
Maximalhöhe
Elementbereich mit übergroßem Inhalt
Richtung
Textumfluss
Fortsetzung bei Textumfluss
Schichtposition bei Überlappung
Anzeigeart bzw. Nichtanzeige ohne Platzhalter
Anzeige bzw. Nichtanzeige mit Platzhalter
Anzeigebereich eingrenzen
242 / 446
WWW-Grundlagen
Mozilla Firebug
Entwicklungstool: Mozilla Firebug
Firebug: Browser-Plugin für Mozilla-Browser
HTTP-Debugger
HTML-Debugger
DOM-Analyse
CSS-Entwicklungswerkzeug:
berechnete Style-Attribute, Konflikte und Quellen
Box-Layout an
Stylesheet-Debugger
Javascript-Debugger
243 / 446
WWW-Grundlagen
Javascript
Überblick
Javascript
Vom WWW-Browser interpretierte Scriptsprache
Typische Verwendung:
Erweiterung der GUI-Möglichkeiten: dynamische Elemente
Prüfung von Formulareingaben vor der Übermittlung
Name/Geschichte
Entwicklung durch Netscape
Standardisierung als ECMA-Script (durch ECMA International)
Javascript ist eine Marke von Sun Microsystems
Microsoft nennt die Sprache JScript
wenig Bezug zu Java
244 / 446
WWW-Grundlagen
Javascript
Überblick
Javascript Grundkonzepte
„Sandbox“-Konzept: Kein Zugriff auf lokale Ressourcen
Interpretation im Browser abschaltbar
prozedurale und objektorientierte Elemente
Verarbeitung von XML- und HTML-Dokumenten mit
verschiedenen DOM-APIs
Vordefinierte Objekte und Operationen für
Erfragen von Umgebungsinformaionen (Browser, Uhrzeit usw.)
Ein-/Ausgabe
Fensterverwaltung
245 / 446
WWW-Grundlagen
Javascript
Überblick
Einbettung von Javascript in HTML
In HTML eingebettete Anweisungen
<script type="text/javascript"> ... Anweisungen ... </script>
Einbindung separater Skriptdateien in HTM
<script type="text/javascript" src="meinscript.js" />
Alternativer Text für nicht interpretierende Browser
<noscript> ... alternativer Text ... </noscript>
246 / 446
WWW-Grundlagen
Javascript
Überblick
Ausführungszeitpunkt
Ausführung ohne Ereignis-Bindung
Im HTML-Kopf oder -Rumpf eingebetteter Code wird vor dem Anzeigen
der Seite ausgeführt.
Ausführung bei Browser- oder GUI-Ereignissen
Beim Laden der Seite: <body onload="... Script-Code ...">
Selektion eines Links:
<a href="javascript:history.back();">zurück</a>
Absenden eines Formulars
<form onsubmit="CheckInput();"> ...
Mausklick auf ein Element
<img src="bild-klein.jpg" onclick="ZeigeVolleGroesse();">
247 / 446
WWW-Grundlagen
Javascript
Überblick
Javascript-Beispiel
Funktionsdefinition im HTML-Kopf: zeigeDatum
Aufruf durch im Rumpf eingebettetes script-Element
verändert Dokument („dynamisches“ HTML)
angezeigte Seite besteht aus
dynamisch document.write(...) erzeugter Überschrift
statischen Teil <p>Aktuelle Nachrichten ...</p>
248 / 446
WWW-Grundlagen
Javascript
Überblick
<html>
<head>
<title> Datum-Beispiel </title>
<script type="text/javascript">
function zeigeDatum () {
var datum
= new Date();
var tag
= datum.getDate();
var monat
= datum.getMonth() + 1;
var jahr
= datum.getFullYear();
var nullVorTag
= ((tag < 10) ? "0" : "");
var nullVorMonat = ((monat < 10) ? ".0" : ".");
var datumString = nullVorTag + tag +
nullVorMonat + monat + "." + jahr;
document.write("<h1>" + datumString + "<\/h1>")
}
</script>
</head>
<body>
<p>Aktuelle Nachrichten ...</p>
</body></html>
zeigeDatum();
</script>
249 / 446
WWW-Grundlagen
Javascript
Sprachelemente
Javascript-Sprachelemente
kein strenges Typsystem
prozedurale Elemente:
Funktionen
lokale und globale Variablen
Operatoren, Anweisungen, Kontrollstrukturen ähnlich Java
OO-Elemente
vordefinierte und benutzerdefinierte Objekte
vordefiniert: DOM-Klassen und Objekte (z.B. document,
Node)
sonstige vordefinierte Klassen (z.B. Object, String, Date,
Array )
keine benutzerdefinierbaren Klassen
Vererbung mit „unüblichen“ Methoden („Prototypes“,
Closures)
250 / 446
WWW-Grundlagen
Javascript
Sprachelemente
Funktionen in Javascript
Funktionen haben
Parameter (Objekte sind Referenzparameter, ansonsten
Wertparameter)
einen Resultatswert
lokale Variablen (mit var deklariert)
einen ausführbaren Rumpf
Es gibt anonyme Funktionen, z.B. function (n) { n++; }
Funktionsdefinitionen sind schachtelbar
251 / 446
WWW-Grundlagen
Javascript
Sprachelemente
Objekte in Javascript
Objekt = assoziative Liste von Attributen (Name/Wert)
Attributname ist String, Wert von beliebigem Typ
Falls Attributwert Funktion, heißt das Attribut auch
„Methode“
Objekte können mit dem new -Operator erzeugt werden, z.B.
var zaehler = new Object();
zaehler.wert
zaehler.setze
zaehler.erhoehe
zaehler.zeige
=
=
=
=
0;
function (i) { this.wert = i; };
function () { this.wert++; };
function () { alert(this.wert); };
Das Objekt zaehler hat das Attribut wert und Methoden:
setze, erhoehe, zeige
252 / 446
WWW-Grundlagen
Javascript
Sprachelemente
Konstruktoren
new erzeugt ein neues Objekt
Funktionen können in Verbindung mit new als Konstruktoren
für benutzerdefinierte Objekte genutzt werden, z.B.
function Zaehler
this.wert
=
this.setze
=
this.erhoehe =
this.zeige
=
}
(initWert) {
initWert;
function (i) { this.wert = i; };
function () { this.wert++; };
function () { alert(this.wert); };
var zaehler = new Zaehler(0);
zaehler.erhoehe();
zaehler.zeige();
253 / 446
WWW-Grundlagen
Javascript
Sprachelemente
Objekte sind assoziative Listen
Objektdefinition mit der Schreibweise assoziativer Listen
var zaehler = { wert
setze
erhoehe
zeige
:
:
:
:
0,
function (i) { this.wert = i; },
function () { this.wert++; },
function () { alert(this.wert); } };
Attribut-Zugriff (Methodenzugriff)
Assoziativ-Listen-Notation:
Standard-Notation:
zaehler["setze"](14)
zaehler.setze(14)
Objektverarbeitung mit dem Iterator für assoziative Listen
for (attr in zaehler) { alert("Name: " + attr + " Wert: " +
zaehler[attr] +
" Typ: " + typeof(attr)); }
Beachte: Mit der klassischen Schreibweise geht das nicht!
254 / 446
WWW-Grundlagen
Javascript
Prototypen
Prototypen: „Vererbung“ in Javascript
Jedes Objekt obj hat ein Attribut obj.prototype
Der Wert des Prototypen ist selbst ein beliebiges, frei
zuweisbares Objekt
obj.prototype „vererbt“ seine Attribute an obj, d.h.
Wenn obj.attr undefiniert ist, wird stattdessen
obj.prototype.attr ausgewertet
255 / 446
WWW-Grundlagen
Javascript
Prototypen
Prototypen: Beispiel
Zwei Zähler-Objekte mit individuellen wert-Attributen
var zaehlerPrototype = {
setze
: function (i) { this.wert = i; },
erhoehe : function () { this.wert++; },
zeige
: function () { alert(this.wert); }
};
var z1 = { wert : 0, prototype : zaehlerPrototype };
var z2 = { wert : 0, prototype : zaehlerPrototype };
Vorteil: Speicherplatz für die Prototype-Attribute wird gemeinsam
benutzt
256 / 446
WWW-Grundlagen
Javascript
Felder
Felder in Javascript
Felder sind Objekte der Klasse Array
Sie bestehen aus einer dynamisch veränderbaren Anzahl von
Elementen
Die einzelnen Elemente können unterschiedliche Typen haben
Die Elemente werden durch Index selektiert (ab 0 aufwärts)
Die Deklaration erfolgt mit dem new -Operator oder durch ein
Literal, z.B.
feld1 = new Array(3);
feld2 = new Array();
feld3 = ["rot", "gruen", 127];
uninitialisierte Feldelemente haben den Wert undefined
257 / 446
WWW-Grundlagen
Javascript
DOM
Javascript-DOM
Mit Javascript kann man u.a.
Browserfenster öffnen und schließen
Web-Seiten laden
beliebige Teile von HTML-Dokumenten selektieren
HTML-Dokumente verändern
Grundlage ist das Javascript-DOM-Modell mit den Objekten
window, window.document, window.navigator
HTML-Dokumente lassen manipulieren:
auf der Baum-Ebene
durch Methodenaufrufe, z.B.
element.appendChild(...)
durch Wertzuweisungen an die DOM-Objekte, z.B.
document.body.firstChild = neuerParagraph
durch Schreiben von HTML-Text mit
document.write(...)
258 / 446
WWW-Grundlagen
Javascript
DOM
Problemfall: Verschiedene DOM-Modelle und
DOM-Versionen
mehrere DOM-Varianten aus historischen Gründen, dadurch
alternative Codierungsmöglichkeiten
Das W3C-DOM für XML
modernstes DOM
einheitliche Verarbeitung von HTML und XML
wird von alten Browsern nicht unterstützt
Das einfachere HTML-DOM (ebenfalls ein W3C-Standard)
stark verbreitet und von den meisten Browsern unterstützt
eingeschränkte Baumknoten-Selektion
erlaubt oft etwas kürzeren Code
Die Microsoft-DOM-API
erlaubt oft etwas kürzeren Code
ist nicht standardisiert
wird nicht von allen Browsern implementiert
259 / 446
WWW-Grundlagen
Javascript
DOM
Das aktuelle DOM: XML-W3C-DOM level 3 in Javascript
Attribute von Node-Objekten
childNodes
data
firstChild
lastChild
nextSibling
nodeName
nodeType
nodeValue
parentNode
previousSibling
Kindknoten
Zeichendaten
erster Kindknoten
letzter Kindknoten
nächster Knoten auf derselben Ebene
Name des Knotens
Knotentyp
Wert/Inhalt des Knotens
Elternknoten
vorheriger Knoten auf derselben Ebene
260 / 446
WWW-Grundlagen
Javascript
DOM
DOM-Mix in Javascript: problematisch, aber üblich
Beispiel:
alert(window.document.body.firstChild.innerHTML);
Die Objekte window und window.document sind
Javascript-Standardobjekte
Das body-Attribut gehört zum HTML-DOM.
Das firstChild-Attribut gehört zum XML-DOM
Die XML-DOM-Notation für document.body ist
document.getElementsByTagName("body")[0]
Das innerHTML-Attribut ist eine nicht standardisierte
Microsoft-Erweiterung
Ein standardisiertes direktes Äquivalent gibt es nicht!
Fazit: Komplexer Javascript-Code erfordert Browser-abhängige
Varianten
261 / 446
WWW-Grundlagen
Javascript
DOM
Wurzel der DOM-Hierarchie: globales Objekt „window“
repräsentiert Browser-Fenster
Attribute: name, outerHeight, status, . . .
Methoden (Auswahl):
open
alert
confirm
home
moveTo
neues Fenster öffnen
Meldung anzeigen
Bestätigung holen
zur Startseite
verschieben
Unterobjekte (Auswahl):
document
navigator
history
event
location
DOM-Baum der aktuellen Seite
Browser-Objekt
Liste besuchter Seiten
Details zu Tastatur- oder Mausereignis
URI des Dokuments
262 / 446
WWW-Grundlagen
Javascript
DOM
Beispiel: window-Objekt
<html>
<head>
<title> Test </title>
function FensterOeffnen (URL) {
MeinFenster = window.open(URL, "Zweitfenster",
"width=300,height=200,scrollbars=yes");
MeinFenster.focus();
}
</script>
</head>
<body>
<a href="datei2.htm" onclick="FensterOeffnen(this.href);
return false">
Neues Fenster
</a>
</body>
</html>
263 / 446
WWW-Grundlagen
Javascript
DOM
DOM-Objekt „window.document“
document repräsentiert die aktuelle HTML-Seite
Mit vordefinierten Methoden können Knoten im DOM-Baum
selektiert und der Baum verändert werden
<html>
<head> <title>Test</title> </head>
<body>
<div id="Bereich" style="border:1px black solid; padding:10px"></div>
var ueberschrift = document.createElement("h1");
var text = document.createTextNode("dynamische Seite");
ueberschrift.appendChild(text);
var ausgabebereich = document.getElementById("Bereich");
ausgabebereich.appendChild(ueberschrift);
</script>
</body>
</html>
264 / 446
WWW-Grundlagen
Javascript
DOM
DOM-Beispiel: HTML-Tabelle aufbauen
function start() {
var body = document.getElementsByTagName("body")[0];
var tbl = document.createElement("table");
for (var j = 0; j < 2; j++) {
var row = document.createElement("tr");
for (var i = 0; i < 2; i++) {
var cell = document.createElement("td");
var cellText = document.createTextNode("Zelle["+j+", "+i+"]");
cell.appendChild(cellText);
row.appendChild(cell);
}
tbl.appendChild(row);
}
body.appendChild(tbl);
tbl.setAttribute("border", "2");
}
265 / 446
WWW-Grundlagen
Javascript
DOM
Wichtige Methoden von window.document
document.write
Anstatt mit den Baumfunktionen dynamischen Inhalt zu
erzeugen, kann man mit dieser Methode HTML-Code
dynamisch einfügen
document.writeln("<ul><li> dynamisch eingefuegte Liste </li></ul>");
document.getElementById
Element über eindeutiges ID-Attribut selektieren
document.getElementsByTagName
Element über Elementtyp selektieren, liefert ein Feld
266 / 446
WWW-Grundlagen
Javascript
DOM
Beispiel zur Elementselektion
<html> <head> ... </head>
<body>
<div id="einleitung" title="Einleitung">
Dies ist die Einleitung
</div>
</body>
Folgende Ausdrücke sind austauschbare Selektionen dieses
div-Elements:
document.getElementById("einleitung")
document.getElementsByTagName("div")[0]
document.getElementsByTagName("body")[0].firstChild
267 / 446
WWW-Grundlagen
Javascript
DOM
HTML-DOM: HTML-Element-Objekte
HTML-DOM ist HTML-spezifisch, lässt sich also nicht für
XML verwenden
Methoden/Attribute dieses DOM erkennt man an
HTML-spezifischen Namen
Ein HTML-Elementobjekt hat universelle und
Element-spezifische Attribute und/oder Methoden
268 / 446
WWW-Grundlagen
Javascript
DOM
Beispiele für HTML-DOM
Elementtyp
alle
html
h1
img
input
form
a
Attribut-Beispiele
id, title, className
version
align
height, border, src
value, form, type
method, action
href
Methoden-Beispiele
select, click
submit, reset
focus
269 / 446
WWW-Grundlagen
Javascript
DOM
Selektion von HTML-Elementobjekte über Elementtyp
oder name-Attribut
Elemente werden oft gemäß HTML-DOM mit dem
Elementtyp selektiert, z.B. document.body
Achtung: Dies geht nur bei einigen Elementtypen
Elemente werden oft gemäß HTML-DOM mit dem Wert des
name-Attributs selektiert, z.B. formular.vorname
Achtung:
das Name-Attribut muss nicht eindeutig sein
seine Verwendung wird ab XHTML 1.1 sehr eingeschränkt
besser: formular.getElementsByName("vorname")[0]
noch besser: id verwenden
270 / 446
WWW-Grundlagen
Javascript
DOM
Beispiel für Attributzugriff: Tooltip-Text (title-Attribut)
HTML-DOM
function aendereTooltip (element, neuerText) {
var alterText = element.title;
element.title = neuerText;
return alterText;
}
W3C-XML-DOM
function aendereTooltip (element, neuerText) {
var alterText = element.getAttribute("title");
element.setAttributeNode("title",neuerText);
return alterText;
}
271 / 446
WWW-Grundlagen
Javascript
Ereignisse
Ereignisse zur Anbindung von Javascript-Aktionen
onabort
onblur
onchange
onclick
ondblclick
onerror
onfocus
onkeydown
onkeypress
onkeyup
onload
onmousedown
onmousemove
onmouseout
onmouseover
onmouseup
onreset
onselect
onsubmit
onunload
bei Abbruch des Ladevorgangs
beim Verlassen des aktiven Elements
bei erfolgter Änderung eines Formularfelds
beim Anklicken eines Elements
bei doppeltem Anklicken
im Fehlerfall (beim Laden von Bildern)
beim Aktivieren (Formularfelder, Links)
beim Herunterdrücken einer Taste
bei Drücken einer Taste
bei Loslassen einer Taste
beim Laden einer Datei
bei gedrückter Maustaste
bei weiterbewegter Maus
beim Verlassen des Elements mit der Maus
beim Überfahren des Elements mit der Maus
bei losgelassener Maustaste
beim Zurücksetzen des Formulars
beim Selektieren von Text
beim Absenden des Formulars
beim Verlassen der Datei
272 / 446
WWW-Grundlagen
Javascript
Beispiele
Beispiel: CSS-Stil dynamisch ändern
<html>
<head>
<title>Test</title>
.hinterlegt { background-color:green }
</style>
function stilAendern () {
var elemente = document.getElementsByTagName("li");
for (var i = 0; i < elemente.length; i++)
if (i % 2 != 0) {
elemente[i].className = "hinterlegt";
elemente[i].type = "I"; // römische Ziffern
}
}
</script>
</head>
273 / 446
WWW-Grundlagen
Javascript
Beispiele
<body>
<ol>
<li>Ein
<li>Ein
<li>Ein
<li>Ein
<li>Ein
<li>Ein
</ol>
ungerader Listenpunkt</li>
gerader Listenpunkt</li>
<a href="javascript:stilAendern()">gerade Listenpunkte hinterlegen!</a>
</body>
</html>
274 / 446
WWW-Grundlagen
Javascript
Beispiele
Beispiel: Dynamische Längenanpassung eines Eingabefelds
<html>
<head>
<title>Test</title>
var Breite = 3;
function erweitern () {
Breite += 1;
document.getElementById("Eingabe").size = Breite; }
</script>
</head>
<body>
<form id="Formular">
Geben Sie Text ein:<br>
<input type="text" size="3" id="Eingabe" onkeypress="erweitern();">
</form>
</body>
</html>
275 / 446
WWW-Grundlagen
Javascript
Beispiele
Beispiel: Formular-Validierung
<html><head> <title>Formulareingaben überprüfen</title>
function pruefe (form) {
if (form.Name.value == "") {
alert("Bitte Ihren Namen eingeben!");
form.Name.focus(); return false; }
if (form.Mail.value.indexOf("@") == -1) {
alert("Keine E-Mail-Adresse!");
form.Mail.focus(); return false; }
var alter=form.Alter.value;
if (parseInt(alter) != alter ) {
alert("Altersangabe fehlt oder ist keine Zahl!");
form.Alter.focus(); return false;
}
}
</script>
</head>
276 / 446
WWW-Grundlagen
Javascript
Beispiele
<body>
<h1>Formular</h1>
<form id="Formular"
action="http://de.selfhtml.org/cgi-bin/formview.pl"
method="post"
onsubmit="return pruefe(this)"
>
<pre>
Name:
<input type="text" size="40" name="Name">
E-Mail:
<input type="text" size="40" name="Mail">
Alter:
<input type="text" size="40" name="Alter">
Formular: <input type="submit" value="Absenden">
<input type="reset" value="Abbrechen">
</pre>
</form>
</body>
</html>
277 / 446
WWW-Grundlagen
Javascript
Beispiele
Javascript-Beispiel mit Objektdefinition
<html><head><title>Test</title>
function Farbe (rot, gruen, blau) {
this.r = rot;
this.g = gruen;
this.b = blau;
this.toString = function (){ return "#"+this.r+this.g+this.b; }
}
function farbeWechseln () {
var hellgruen = new Farbe("E0", "FF", "E0");
document.bgColor = hellgruen.toString();
}
</script></head>
<body bgcolor="#FFFFFF">
<h1>Das eigene Farb-Objekt mit JavaScript</h1>
<a href="javascript:farbeWechseln()">Hintergrundfarbe wechseln</a>
</body>
</html>
278 / 446
WWW-Grundlagen
Javascript
Beispiele
Cookies in Javascript
vordefiniertes document-Attribut: cookie
var ablauf = new Date();
var infuenfTagen = ablauf.getTime() + (5 * 24 * 60 * 60 * 1000);
ablauf.setTime(infuenfTagen);
if (navigator.cookieEnabled){
document.cookie = "name=SELFHTML; expires="
+ ablauf.toGMTString();
alert(document.cookie);
}
</script>
279 / 446
WWW-Grundlagen
Javascript
Ajax
Ajax
„Asynchroneous Javascript + CSS + DOM + XMLHttpRequest“
Sammlung von Techniken, um WWW-GUI agiler zu gestalten
übliches WWW-Kommunikationsschema:
Formular abschicken
neue HTML-Dokument empfangen
Bildschirm neu aufbauen
WWW-Interaktion mit Ajax
feinkörniges Laden von Daten im Hintergrund
(typisch: einzelne HTML-Elemente als XML-DOM-Baum)
partielle Seitenaktualiserung nach Empfang
(mit den Javascript-DOM-Operationen)
Bekannte Anwendungen:
Google Suggest/Maps/Mail/Calendar
280 / 446
WWW-Grundlagen
Javascript
Ajax
Beispiel: Online-Landkarten
Szenario
Webanwendung zeigt Kartenausschnitt: Bilddatei
Benutzer verschiebt Karte
Neuer Ausschnitt muss angezeigt werden
Klassische WWW-Interaktion
Mit einem GET-Request
neue Koordinaten an Server übertragen
neuen Kartenausschnitt (Bilddatei) laden und anzeigen
(Beispiel: Wanderwege Tirol,
http://gis2.tirol.gv.at/scripts/esrimap.dll?Name=wander&Cmd=Start)
281 / 446
WWW-Grundlagen
Javascript
Ajax
Ajax: Kartenbild ist in kleine Kacheln zerlegen
Beim Verschieben benötigte Kacheln im Hintergrund nachladen.
Die CSS-Positionsattribute aller Teilbilder werden angepasst und
damit das Boxmodell des neuen Kartenausschnitt konstruiert.
Nach Empfang eines Teilbilds wird es in den DOM-Baum eingefügt
und per CSS sichtbar gemacht.
Dies hat keine Auswirkungen auf den Rest des Browserfensters.
282 / 446
WWW-Grundlagen
Javascript
Ajax
XMLHttpRequest
Javascript-Objekt zum Laden von Daten im Hintergrund
Übertragungsvorgang hat 4 Zustände (request.readyState)
Zustandsänderung: Aufruf einer vorher zu registrierenden
Callback-Funktion (request.onreadystatechange)
Callback-Funktion kann nach Erhalt der Daten den
DOM-Baum modifizieren
Serverdaten als Text und als XML-DOM-Baum verfügbar
(request.responseText, request.responseXML)
283 / 446
WWW-Grundlagen
Javascript
Ajax
Beispiel für XMLHttpRequest
<script type="text/javascript" language="javascript">
function sendeRequest(url) {
if (window.XMLHttpRequest) { // Mozilla, Safari,...
http_request = new XMLHttpRequest();
http_request.onreadystatechange = reagiere;
http_request.open(’GET’, url, true);
http_request.send(null);
else if (window.ActiveXObject) {
... Code für Internet Explorer ...
}
}
284 / 446
WWW-Grundlagen
Javascript
Ajax
function reagiere () {
if (http_request.readyState == 4) {
if (http_request.status == 200) {
alert(http_request.responseText);
} else {
alert(’Bei dem Request ist ein Problem aufgetreten.’);
}
}
}
</script>
<span
style="cursor: pointer; text-decoration: underline; color: blue"
onclick="sendeRequest(’test.html’)">Einen Request absetzen
</span>
Codierung teilweise Browser-abhängig
Nachladen nur vom Server, der die aktuelle Seite geliefert hat
285 / 446
WWW-Grundlagen
Javascript
Ajax
Attribute und Methoden des XMLHttpRequest
Methoden
open(HTTP-Methode, URL, asyncFlag)
send( requestAttribute )
abort()
setRequestHeader( key, value )
getResponseHeader( key )
getAllResponseHeaders()
initialisieren
absenden, Parameter bei GET-Request:
null
Bricht eine aktuell laufende Anfrage ab
Attribute
onreadystatechange
readyState
status, statusText
responseText
responseXML
Handler-Callback-Methode
0=uninitialized, 1=loading, 2=loaded,
4=complete
HTTP-Status
Serverantwort als Text-String
Serverantwort XML-Dokument
3=interactive,
286 / 446
WWW-Grundlagen
Javascript
Ajax
Javascript-/Ajax-Frameworks
Viele Web-Anwendungen sind „rich clients“
Benutzeroberfläche / Interaktionsverhalten ähnelt klassischer GUI
Ajax für inkrementelle Aktualisierung der Benutzersicht
Problem
Javascript-Code wegen vieler Browser-Fallunterscheidungen unhandlich
Javascript-/Ajax-Framework
ist eine Sammlung wiederverwendbarer Javascript-Definitionen
versteckt Browser-Fallunterscheidungen
erleichtert DOM-Operationen
erleichtert Ajax-Requests
definiert ggf. GUI-Bausteine („widget sets“)
Beispiele: prototype, dojo, jquery, extjs, Google Web Toolkit (GWT)
287 / 446
WWW-Grundlagen
Webserver
Webserver
Merkmale
Webserver kann ein sehr einfaches, kleines Programm sein
Oft in netzwerkfähigen Geräten vorhanden (Drucker, Router,
Telefonanlage), ermöglicht dann Konfiguration per Browser
Grundfunktion: HTTP Requests beantworten
Statische Ressourcen (HTML-Dokumente, Bilder, . . . ) aus dem
Dateisystem verschicken
externe Programme aufrufen, die HTTP-Antwort dynamisch
erzeugen (CGI-Schnittstelle)
288 / 446
WWW-Grundlagen
Webserver
Erweiterte Funktionen eines Webservers
Zuordnung zwischen logischen und realen Pfaden verwalten
Zugriffsrechte verwalten/prüfen
Zugriffsprotokoll führen
Scripting direkt unterstützen (z.B. PHP-Plugin)
289 / 446
WWW-Grundlagen
Webserver
CGI – Common Gateway Interface
CGI - Common Gateway Interface
CGI: einfache serverseitige Technik zur Beantwortung von
HTTP-Requests.
Prinzip
Webserver assoziiert mit einem URL ein Programm oder Script
Programmiersprache: beliebig
Standardeingabe: HTTP-Request-Rumpf
Sonstige Request-Daten: Umgebungsvariablen
Standardausgabe: HTTP-Antwortrumpf
290 / 446
WWW-Grundlagen
Webserver
CGI Umgebungsvariablen
Umgebungsvariablen für CGI (Auswahl)
QUERY_STRING
CONTENT_LENGTH
REQUEST_METHOD
HTTP_HOST
HTTP_COOKIE
HTTP_REFERER
HTTP_USER_AGENT
PATH_INFO
SERVER_NAME
SERVER_PORT
SCRIPT_NAME
kompletter URL
Größe des Request-Rumpfs in Byte
HTTP-Methode
Adresse des HTTP-Client
HTTP-Cookies
URL des ursprünglichen HTML-Dokuments
Name und Version des Browsers
Pfad-Anteil des URL hinter CGI-Adresse
Name und IP des Webservers
Request TCP Port
Pfadanteil von Server-Root zum Script
weitere Variablen: http://de.selfhtml.org/servercgi/cgi/umgebungsvariablen.htm
291 / 446
WWW-Grundlagen
Webserver
Umgebungsvariablen („Environment“)
Was sind Umgebungsvariablen?
Betriebssystemkonzept: Jeder Prozess hat einen Speicherbereich für
Umgebungsvariablen
Übergabemöglichkeiten von Informationen bei Programmaufruf:
Parameterübergabe
Umgebungsvariablen
Umgebungsvariablen sind Zeichenketten der Form NAME=WERT
Zugriff auf Umgebungsvariablen abhängig von Programmiersprache
292 / 446
WWW-Grundlagen
Webserver
Zugriff auf Betriebssystem-Umgebungsvariablen in Java
Umgebungszugriff mit System.getenv()
import java.util.*;
public class Umgebung {
public static void liste () {
Map systemUmgebung = System.getenv();
Set namen = systemUmgebung.keySet();
for (Iterator i=namen.iterator(); i.hasNext(); ) {
Object name = i.next();
Object wert = systemUmgebung.get(name);
System.out.println(String.format("%s = %s", name, wert));
}
}
}
293 / 446
JEE
Teil IV
JEE – Java Enterprise Technologie
294 / 446
JEE
13
Überblick
APIs
Architekturmodelle
Komponentenmodell
14
Java Server Pages
Scriptlets
JSP-Ausdrücke
Deklarationen
Vordefinierte Objekte
Sitzungen
Scope und Lebensdauer
Direktiven
JSP und Beans
JSPX
Eliminierung von Java-Code
Expression Language
Tags
JSTL
15
16
Servlets
17
18
JNDI
Java-Frameworks für Webapplikationen
Model View Controller
Struts und JSF
Java Server Faces
Enterprise Java Beans
Fallbeispiel
Applikationsserver
Persistenz
Session Bean
Message Driven Bean
EJB-Schnittstellen
EJB-Alternativen
295 / 446
JEE
Überblick
Java Enterprise
Merkmale
Framework zur Entwicklung der Serverseite von Web-Anwendungen
Entwicklungsplattform „Java Platform Enterprise Edition“ (JEE)
vor allem für größere Projekte mit hohen Anforderungen an
Sicherheit, Performanz und Stabilität
umfangreich und komplex!
296 / 446
JEE
Überblick
Wie sieht JEE konkret aus?
Architekturmodelle (3-tier, 4-tier)
Spezielle Entwurfsmuster (z.B. „front controller“)
APIs (z.B. JDBC, EJB, JNDI)
Bibliotheken (z.B. JSTL, Klassenbibliotheken für die APIs)
Entwicklungswerkzeuge (z.B. Eclipse-Plugins)
Spezielle Laufzeitumgebungen (z.B. Tomcat, JBOSS, Glassfish)
Frameworks (z.B. Struts, Java Server Faces)
297 / 446
JEE
Überblick
Grundlegende JEE-Begriffe und Techniken
Servlet
universell einsetzbare Komponente
zur dynamischen HTML-Erzeugung
zur Interaktionssteuerung
zur Kapselung von Geschäftslogik
JSP (Java Server Page): dynamische HTML-Erzeugung
JSP-Tag-Bibliothek: Tags zum Verstecken von Code
Daten-Bean: Container für Anwendungsdaten
EJBs (Enterprise Java Bean): kapselt Sitzungslogik, Daten,
Nachrichten
Servlet-Container: Ausführung von Servlets und JSPs
JEE-Applikationsserver: Ausführung von EJBs
298 / 446
JEE
Überblick
APIs
Wichtige JEE-APIs
JDBC (Java Database Connectivity)
Datenbankzugriff per SQL
JNDI (Java Naming and Directory Interface)
Zugriff auf Verzeichnisdienste
JPA (Java Persistence API)
Speicherung von Java-Objekten in SQL-Datenbanken
JAX-WS
Implementierung und Nutzung von Webservices
JMS (Java Messaging Service)
Zugriff auf MOM-Nachrichten-Server
JAXP (Java API for XML Processing)
JAXB (Java XML Binding)
299 / 446
JEE
Überblick
Architekturmodelle
JEE-Architekturmodell mit 4 Ebenen („tiers“)
Quelle: http://java.sun.com/javaee/5/docs/tutorial
300 / 446
JEE
Überblick
Architekturmodelle
Kommunikationsmodell für Java- und Web-Applikationen
301 / 446
JEE
Überblick
Architekturmodelle
JEE-Architekturmodell mit EJBs in der Geschäftsebene
302 / 446
JEE
Überblick
Architekturmodelle
APIs im JEE-Architekturmodell
303 / 446
JEE
Überblick
Komponentenmodell
Komponenten und Container
JEE-Komponente
enthält fachliche Funktionen („Geschäftslogik“)
ist kein für sich alleine lauffähiges Programm
benötigt einen Container als Laufzeitumgebung
Container
liefert anwendungsunabhängige „technische“ Funktionen
(z.B. Transaktionssteuerung, Lastverteilung, Verzeichnisdienst)
Containertypen:
Servlet-Container für Servlets und JSPs
Applikationsserver (für EJBs und alle anderen Arten)
Integration einer Komponente in den Container: „Deployment“
(„Bereitstellung“)
304 / 446
JEE
Java Server Pages
Java Server Pages – JSP
Eine JSP ist ein HTML-Dokument mit dynamischen Anteilen.
Wie sehen die „dynamischen Anteile“ aus?
früher: beliebiger Java-Code (problematisch!)
moderne Variante: JSP-Tags + „Unified Expression Language“
JSP-Tag: XML-Tag, hinter dem sich Java-Code verbirgt
Unified EL: Repräsentation von Werten, für JSP und JSF
Konstruktion des HTML-Dokuments
JSP wird in ein Servlet übersetzt
Servlet wird bei HTTP-Request aufgerufen
Servlet erzeugt HTML-Dokument
Kontrolle des Prozesses: Servlet-Container
305 / 446
JEE
Java Server Pages
Grundlagen der JSP- und Servlet-Verarbeitung
Servlet-Klasse und service-Methode
Servlet definiert eine Servlet-Klasse mit einem Objekt
service-Methode der Servlet-Klasse bearbeitet HTTP-Request
Deployment
JSP wird vom JSP-Compiler in ein Servlet transformiert
Administrator vergibt für das Servlet einen URL
Laufzeit: HTTP-Request
Container lädt Servlet-Klasse bei erstem Zugriff
Container ruft bei Request service-Methode auf, übergibt
Request-Objekt für die Request-Daten
Response-Objekt für die Antwort-Daten
306 / 446
JEE
Java Server Pages
Einfaches JSP-Beispiel:
datum.jsp
<html>
<title> JSP-Beispiel </title>
<body>
Dies ist eine dynamische JavaServer Page. <br/>
Datum und Uhrzeit:
<%= new java.util.Date() %>
</body>
</html>
service-Methode des daraus generierten Servlets
...
out.println
out.println
...
out.println
out.println
...
("<html>");
(" <title> JSP-Beispiel </title>");
("
Datum und Uhrzeit: ");
(new java.util.Date());
307 / 446
JEE
Java Server Pages
Scriptlets
JSP-Scriptlets
Java-Fragment mit Variablendefinitionen und Anweisungen
Syntax:
<%
. . . Java-Code . . . %>
Code wird in den Rumpf der service-Methode eingebettet
Variablen sind lokale Variablen der service-Methode (nicht
Request-übergreifend verfügbar)
Ausgaben des Scriptlets:
keine automatische HTML-Erzeugung
für HTML-Antwort: vordefiniertes PrintWriter -Objekt out
System.out: Protokolldatei oder Konsole des Containers
308 / 446
JEE
Java Server Pages
JSP-Ausdrücke
JSP-Ausdrücke: Werte berechnen und ausgeben
Java-Fragment für einen Wert, automatische Ausgabe
Syntax:
<%=
. . . Java-Ausdruck . . .
%>
Jeder JSP-Ausdruck beinhaltet einen Java-Ausdruck.
Ausdruck wird bei Request-Bearbeitung ausgewertet
Wert wird anstelle des JSP-Ausdrucks in HTML-Ausgabe
geschrieben
309 / 446
JEE
Java Server Pages
JSP-Ausdrücke
Beispiel: BMI-Rechner
<%-- hier kommt ein Scriptlet:
<%
--%>
float gewicht=83.5, groesse=1.81, bmi;
bmi = gewicht / (groesse * groesse);
%>
<html>
<title> BMI-Berechnung mit festen Werten </title>
<body>
<p> Bei einem Gewicht von <%= gewicht %> kg und einer Größe
von <%= groesse %> cm ist der BMI <%= bmi %>.
</p>
<p> Wenn dein BMI über 24 liegt, bist du zu schwer! </p>
</body>
</html>
310 / 446
JEE
Java Server Pages
Deklarationen
JSP-Deklarationen
Eine JSP-Deklaration erweitert die Servlet-Klasse
Syntax:
<%!
. . . Java-Deklarationen . . .
%>
Variablen und Methoden kommen in die Servlet-Klassendefinition
Variablen Request-übergreifend und von Clients gemeinsam benutzt
Beispiel: Webseite mit Zugriffszähler
<%! int zaehler = 1; %>
<html>
<head><title> Zugriffszähler </title></head>
<body>
Sie sind der <%= zaehler++ %>. Besucher dieser JSP.
</body>
</html>
311 / 446
JEE
Java Server Pages
Vordefinierte JSP-Objekte
Objekt
out
Typ und Verwendung
javax.servlet.jsp.JSPWriter
request
zum Schreiben des Inhalts der HTTP-Antwort
javax.servlet.http.ServletRequest
response
zum Auslesen aller Request-Daten
javax.servlet.http.ServletResponse
session
zum Erzeugen der Antwort
javax.servlet.http.HttpSession
application
zur Sitzungsverwaltung
javax.servlet.ServletContext
config
Anwendungskontext (z.B. Version der Servlet-API)
javax.servlet.http.ServletConfig
pageContext
Zugriff auf Container-Konfiguration
javax.servlet.jsp.PageContext
Zugriff auf die anderen vordefinierten Objekte
312 / 446
JEE
Java Server Pages
Requestdaten auslesen
Methoden des vordefinierten Objekts „request“
getParameterNames()
getParameter(name)
getHeaderNames()
getHeader(name)
getMethod()
getRequestURI()
getContentType()
getCookies()
getLocales()
Namen aller Parameter
Wert eines Parameters
Namen aller HTTP-Header
Wert eines HTTP-Headers
Requesttyp
Request-URI
MIME-Typ des Requestrumpfs
Namen der Cookies
bevorzugte Sprachen
313 / 446
JEE
Java Server Pages
Beispiel: Schema zur Verarbeitung der Parameter
Auslesen aller Request-Parameter
<%
java.util.Enumeration paramNamen = request.getParameterNames();
while (paramNamen.hasMoreElements()) {
String name = (String) paramNamen.nextElement();
String wert = request.getParameter(name);
// Verarbeitung von name und wert
...
}
%>
HTTP-Header und Cookies werden in gleicher Weise verarbeitet
Expression Language bietet kürzere Notationen, z.B.
${param} statt request.getParameterNames()
314 / 446
JEE
Java Server Pages
Beispiel: Schema für Browser-spezifische Antwort
Browsertyp und -version im HTTP-Header „User-Agent“
<%
String userAgent = request.getHeader("User-Agent");
if (userAgent != null)
if (userAgent.indexOf("MSIE") != -1)
....
else if (userAgent.indexOf("Safari") != -1)
...
%>
315 / 446
JEE
Java Server Pages
Sitzungen
Web-Sitzungen
Problem
Bei Webanwendungen häufig Dialoge über mehrere Requests
HTTP hat kein Sitzungskonzept
Technische Realisierungsmöglichkeiten
Server erzeugt Sitzungsnummer für ersten (sitzungslosen) Request
Die Nummer wird so an den Browser übermittelt, dass dieser sie bei
allen Folge-Requests wieder zurückschickt:
als Cookie (Standardverfahren, nur wenn Browser Cookies
akzeptiert)
im URL codiert („URL-Rewriting“)
als verstecktes Formularfeld
SSL-Sitzungen: SSL-Sitzungskonzept verwendbar
316 / 446
JEE
Java Server Pages
Sitzungen
Sitzungsdaten speichern mit dem JSP Session-Objekt
JSP-Objekt session
Sitzungsnummern auf der Basis von Cookies oder URL-Rewriting
automatisierter Cookie-Mechanismus
mit Sitzungsnummer-Cookie „JSESSIONID“
URL-Rewriting erfordert explizite Programmierung
mit response.encodeURL( String )
Schnittstelle für die Sitzungsattribute:
setAttribute (Name, Wert)
getAttribute (Name)
removeAttribute (Name)
317 / 446
JEE
Java Server Pages
Scope und Lebensdauer benutzerdefinierter JSP-Attribute
Page Scope
Attribute existieren nur für die Dauer der Request-Bearbeitung
nur innerhalb einer JSP-Seite verwendbar
technisch: lokale Objekte der service-Methode
Request Scope
Attribute existieren nur für die Dauer der Request-Bearbeitung
verwendbar in allen JSPs und Servlets, die an der Request-Bearbeitung
beteiligt sind
Session Scope
Request-übergreifend innerhalb einer Sitzung verwendbar
Application Scope
Request-übergreifend von allen Clients gemeinsam benutzbar
318 / 446
JEE
Java Server Pages
JSP-Scopes und Attribute
Vordefinierte Scope-Objekte
page, request, session, application
„Anheften“ von Attributen
void setAttribute(String name, Object wert)
Object getAttribute(String name)
void removeAttribute(String name)
Objekt-spezifische sonstige Möglichkeiten
z.B. request.getParameter
Das page-Objekt ist technisch einfach nur eine Referenz auf die
aktuelle Servlet-Instanz (also this)
319 / 446
JEE
Java Server Pages
Direktiven
JSP-Direktiven: Instruktionen für JSP-Compiler
include-Direktive
zum Einbinden gemeinsam benutzbarer JSP-Fragmente
Syntax:
<%@ include file=" ... Pfad ..." %>
taglib-Direktive
Tag-Bibliothek: Sammlung benutzerdefinierter Aktionen
Syntax:
<%@ taglib uri="..."
prefix="..." %>
Standardbibliothek: JSTL – Java Standard Tag Library
320 / 446
JEE
Java Server Pages
Direktiven
page-Direktive
verschiedene Verwendungsaspekte über Attribute konfigurierbar
Beispiel:
<%@ page contentType="text/html" session="false"
import="java.util.*, java.io.*" %>
Attribute
Attribut
Default
import
session
isThreadSafe
errorPage
contentType
pageEncoding
true
true
Verwendung
Import von Klassen und Paketen
Wird eine Sitzungsverwaltung gebraucht?
Ist nebenläufiger Zugriff möglich?
Verweis auf Fehlerbehandlungs-JSP
MIME-Typ der Antwort
Zeichencodierung
321 / 446
JEE
Java Server Pages
Direktiven
Beispiel: BMI-Rechner, Version 2
Beispiel für
Nutzung der Direktiven: page und include
Auslesen der Request-Parameter
unübersichtliche Mischung aus HTML und Script-Code
bmiBerechnung.jsp
<%!
float bmiBerechnung (float gewicht, float groesse) {
return gewicht / (groesse*groesse);
}
%>
322 / 446
JEE
Java Server Pages
Direktiven
bmi.jsp
<%@ contentType="text/html" pageEncoding="UTF-8" %>
<%@ include file="bmiBerechnung.jsp" %>
<%
float
gewicht, groesse, bmi;
boolean gueltigeParams = true;
try {
gewicht = Float.parseFloat(request.getParameter("gewicht"));
groesse = Float.parseFloat(request.getParameter("groesse"));
}
catch (Exception e)
{ gueltigeParams = false; }
323 / 446
JEE
Java Server Pages
Direktiven
if (gueltigeParams) {
bmi = bmiBerechnung (gewicht, groesse);
%>
<html> <title> Ergebnis der BMI-Berechnung </title>
<body>
<p> Bei einem Gewicht von <%= gewicht %> kg und einer Größe
von <%= groesse %> cm ist der BMI <%= bmi %>.
</p>
</body>
</html>
<%
}
else {
%>
<html> <title> Fehler bei BMI-Berechnung </title>
<body>
<p> Sie müssen in beiden Feldern Zahlen eingeben <p>
<p> <a href="..."> Zurück zum Formular </a> </p>
</body>
</html>
<%
}
%>
324 / 446
JEE
Java Server Pages
JSP und Beans
Java Beans: Datencontainer
Merkmale einer Bean-Klasse
parameterloser Konstruktor
Attribute („properties“) mit get- und/oder set-Methoden
Für ein Attribut xxx heißen die Methoden: getXxx bzw. setXxx
Beispiel
public class Bmi {
private float groesse;
private float gewicht;
public Bmi() {}
public float getGroesse() { return groesse; }
public void setGroesse(float neueGroesse) { groesse=neueGroesse; }
...
325 / 446
JEE
Java Server Pages
JSP und Beans
JSP und Java Beans: Kapselung von Formulardaten
Bean gehört zu einem JSP-Scope
automatische Übertragung von Formulardaten (inkl. Typkonversion)
Standardaktionen
Bean-Deklaration
Attribut setzen
Attribut lesen
<jsp:useBean ...
/>
<jsp:setProperty ... />
<jsp:getProperty ... />
Beispiel
<jsp:useBean id="bmiFormular" class="bmi" scope="session" />
<jsp:setProperty name="bmiFormular" property="gewicht"
value="<% request.getParameter("gewicht") %>" />
326 / 446
JEE
Java Server Pages
JSP und Beans
Vorteile der Bean-Nutzung in JSPs
Gleiche Attributnamen in Formular und Bean: automatisierte
Übertragung
<jsp:useBean id="bmiFormular" class="bmi" scope="session" />
<jsp:setProperty name="bmiFormular" property="*" />
automatisierte Typkonversionen String ↔ Attributtyp
Die JSP wird von Java-Code befreit
327 / 446
JEE
Java Server Pages
JSPX
JSPX: XML-Notation für JSP
Vegleich: Traditionelle und XML-Syntax
traditionell
<% ... %>
<%= ... %>
<%! ... %>
freier Text
XML
<jsp:scriptlet>
<jsp:expression>
<jsp:declaration>
<jsp:text>
...
...
...
...
</jsp:scriptlet>
</jsp:expression>
</jsp:declaration>
</jsp:text>
JSP auf XHTML-Basis: wohlgeformtes XML-Dokument
Container erlauben Mischung der Notationen
328 / 446
JEE
Java Server Pages
JSPX
Beispiel für JSPX-Syntax
<jsp:root xmlns="http://www.w3.org/1999/xhtml"
xmlns:jsp="http://java.sun.com/JSP/Page"
version="2.0">
<jsp:output doctype-root-element="html"
doctype-public="-//W3C//DTD XHTML 1.1//EN"
doctype-system="http://www.w3c.org/TR/xhtml11/DTD/xhtml11.dtd" />
<jsp:directive.page contentType="text/html; charset=utf-8"
language="java" />
...
</html>
</jsp:root>
329 / 446
JEE
Java Server Pages
Eliminierung von Java-Code
JSP 2: Eliminierung von Java-Code
Aktionen: JSP-Tags statt Scriptlets
JSTL-Tags oder
in JSP definierte Anwender-Tags
bei Verwendung eines Frameworks: Tags des Frameworks
Werte: Expression Language statt JSP-Expressions
mit dem JSF-Framework (Java Server Faces) gemeinsam benutzte
„Unified Expression Language“
Container unterstützen eine Mischung aus klassischer und neuer
Syntax
330 / 446
JEE
Java Server Pages
Expression Language
Unified Expression Language (EL)
Wozu EL-Ausdrücke?
Auslesen und Ändern von Daten
Request-Header
Formulardaten
Bean-Attribute
implizite Objekte
Methodenaufrufe, viele vordefinierte Operationen, benutzerdefinierte
Funktionen
Verwendung
JSP-Tags
im statischen Text
331 / 446
JEE
Java Server Pages
Expression Language
Beispiele
Verwendung im statischen Text
<irgendein:tag>
irgendein text ${expr} irgendein text
</irgendein:tag>
Verwendung in einem Tag-Attributwert
<irgendein:tag value="${expr}" />
Ausdrucks-Beispiele
${header["User-Agent"]}
${param["vorname"]}, ${param[’vorname’]}, ${param.vorname}
${!empty param.nachname}
${param.alter + 100}
${warenkorb.summe > 100}
${zahlung == "vorkasse"}
${sessionScope.warenkorb.betragSumme}
${meineFunktionen:istEmailAdresse(param.email)}
332 / 446
JEE
Java Server Pages
Expression Language
Weitere Merkmale der „Unified Expression Language“
verzögerte Auswertung von Ausdrücken ( Syntax: #{...} )
Erweiterung durch benutzerdefinierte Funktionen
Ausdrücke, die Referenzen repräsentieren („lvalue“-Expression)
Benutzerdefinierte Auswertungsalgorithmen („pluggable
resolver“)
333 / 446
JEE
Java Server Pages
Tags
JSP-Tags: XML-Tags für Aktionen
JSP-Tags
sind syntaktisch XML-Elemente
repräsentieren externen Java-Code
ersetzen Scriptlets
Vorteile:
Bessere Lesbarkeit der JSP-Seiten
Vereinfachte Wiederverwendbarkeit des Java-Codes
Tag-Definitionen
Standardbibliothek JSTL: Java Standard Tag Library
Framework-Bibliotheken (z.B. Struts-Tags)
Benutzer-definierte Tags
334 / 446
JEE
Java Server Pages
Tags
Tag-Definitionen: Tag-Bibliotheken oder Tag-Dateien
Unterschiede
Tag-Bibliotheken werden in Java implementiert, unterstützen
beliebig komplexe Tags
Tag-Dateien sind eher einfache JSP-“Makros“
In der Regel wird der Anwendungsprogrammierer vordefinierte
Bibliotheken mit selbstdefinierten Tag-Dateien kombinieren
Tag-Bibliotheken
Bestandteile:
XML-Beschreibungsdatei („tag library descriptor“)
Java-Implementierung: Tag-Handler-Klassen
JSP-Einbindung: taglib-Direktive
Deklaration in der Containerkonfigurationsdatei
335 / 446
JEE
Java Server Pages
Tags
Tag-Dateien für einfache Tags
Einfache Tags
repräsentieren wiederverwendbaren JSP-Code
sind mit Attributen parameterisierbar
werden i.d.R. ohne Java-Codierung in JSP definiert
erlauben Java-Scripting in den Attributen und im Rumpf
Deployment
Pro Tag wird eine Datei mit der Definition erstellt (.tag)
Container-Konfiguration ist nicht nötig
Der Tag-Handler wird vom JSP-Compiler automatisch erzeugt
336 / 446
JEE
Java Server Pages
Tags
Vorteile
Tag-Definition wird stark vereinfacht
Entwickler sind motiviert, eigene Tags statt Scriptlets zu schreiben
Standardbibliotheken und einfache Tags reichen meist aus
337 / 446
JEE
Java Server Pages
JSTL
Die JSTL
Die JSTL definiert JSP-Tags für häufig benötigte Funktionen, z.B.
Iteratoren und bedingte Anweisungen
String-Funktionen
URL-Verwaltung
Verarbeitung von XML-Dokumenten (Parser, XSLT, XPath)
Internationalisierung von Web-Seiten (I18N)
Datenbankzugriff mit SQL
338 / 446
JEE
Java Server Pages
JSTL
JSTL-Module und Tag-Präfixe
c
x
fmt
sql
fn
(core)
(XML)
(I18N)
(SQL)
(functions)
Grundfunktionalität
XML
Internationalisierung
DBMS-Zugriff
Hilfsfunktionen (vor allem String-Funktionen)
339 / 446
JEE
Java Server Pages
JSTL
JSTL-Beispiele: Variablen
Variable definieren und verwenden
<c:set var="farbe" value="rot" />
...
<irgendein:tag irgendeinAttribut="${farbe}" />
...
<tr> <td> Farbe: </td> <td> ${farbe} </td> </tr>
Über Variablen können Tags Daten austauschen
Variablen können in JSP-Scopes gespeichert werden
<c:set var="userid"
scope="session"
value="${param.user}" />
340 / 446
JEE
Java Server Pages
JSTL
JSP-Beispiele
Bedingte Anweisung
<c:if test="${param.kaufen}">
<strong> Danke für Ihren Auftrag! </strong><br>
</c:if>
Schleife: HTTP-Header anzeigen
<table ... >
<tr><th> Name </th> <th> Wert </th></tr>
<c:forEach var="hname" items="${pageContext.request.headerNames}">
<c:forEach var="hvalue" items="${headerValues[hname]}">
<tr><td> <c:out value="${hname}" /> </td>
<td> <c:out value="${hvalue}" /> </td>
</tr>
</c:forEach>
</c:forEach>
341 / 446
JEE
Java Server Pages
JSTL
JSP-Beispiele: XML-Verarbeitung
Eine XML-Bücherliste (booklist) wird in die JSP importiert.
(URL ist ein Init-Parameter, die XML-Datei wird ggf. mit
GET-Request geladen)
Der XML-Parser erzeugt einen DOM-Baum als
Application-Objekt.
Mit dem Request-Parameter bookId wird ein dynamischer
XPath-Ausdruck zur Selektion des Buchs konstruiert, der
Buchtitel serialisiert, und in die Antwort geschrieben.
342 / 446
JEE
Java Server Pages
JSTL
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/XML" prefix="x" %>
<c:if test="${applicationScope:booklist == null}" >
<c:import url="${initParam.booksURL}" var="xml" />
<x:parse doc="${xml}" var="booklist" scope="application" />
</c:if>
<x:set var="selectedbook"
select="${applicationScope.booklist/books/book[@id=$param:bookId]}" />
<h2><x:out select="$selectedbook/title"/></h2>
343 / 446
JEE
Java Server Pages
JSTL
Eigene JSP-Tags
Ein JSP-Tag ist syntaktisch ein XML-Element und besteht
insofern aus Start-Tag (ggf. mit Attributen), Inhalt und
Ende-Tag
JSP-Tags sind flexibel verwendbar:
Parameterisierbarkeit durch Attribute
Werte können an die aufrufende JSP zurückschickt werden
Datenaustausch der Tags untereinander möglich
Tag sind verschachtelbar
uneingeschränkter Zugrif auf implizite JSP-Objekte (request,
session, usw.)
344 / 446
JEE
Java Server Pages
JSTL
Tag-Handler
Ein Java-Tag-Handler ist eine Klasse mit mehreren Methoden,
deren Aufrufzeitpunkt an die syntaktische Struktur des Tags
gebunden ist:
Handler-Methode Aufrufzeitpunkt beim Parsen
doStartTag()
Start-Tag
doInitBody()
vor Bearbeitung des Rumpfs
doAfterBody()
nach Bearbeitung des Rumpfs
doEndTag()
Ende-Tag
Die Klasse
javax.servlet.jsp.tagext.TagSupport
definiert leere Handler-Methoden und ist als Basisklasse für
Tag-Handler gedacht
345 / 446
JEE
Java Server Pages
JSTL
Beispiel: Java-Handler für ein <datum />-Tag
package ibs;
import java.io.IOException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
public class DatumTag extends TagSupport implements Tag {
public int doStartTag() {
try {
JspWriter out = pageContext.getOut();
out.print(new java.util.Date());
}
// keine Verarbeitung des Rumpfs
return SKIP_BODY;
}
}
346 / 446
JEE
Java Server Pages
JSTL
Taglib-Deskriptor
Taglib-Deskriptor: .tld-Datei
enthält die verwendete Taglib-Version
enthält die Tag-Definitionen (Name, Attribute)
ordnet jedem Tag den zuständigen Java-Tag-Handler zu
Beispiel
<taglib xmlns="http://java.sun.com/xml/ns/javaee" ...
<tlib-version>1.0</tlib-version>
<short-name>mt</short-name>
<uri>/BeispielTags</uri>
<tag>
<name>datum</name>
<tag-class>ibs.DatumTag</tag-class>
<body-content>empty</body-content>
</tag>
</taglib>
347 / 446
JEE
Java Server Pages
JSTL
Einbindung und Nutzung
Einbinden in eine JSP durch:
<%@ taglib uri="/meineTags" prefix="mt" %>
Nutzung in der JSP durch:
<mt:datum />
348 / 446
JEE
Java Server Pages
JSTL
Beispiel: Tag-Datei für einfaches Tag mit Attributen
Definition in der Tag-Datei hallo.tag
<%@ attribute name="halloText" required="true" %>
<%@ attribute name="name"
required="true" %>
<h2 style="color:red"> ${halloText}, ${name}! </h2>
Verwendung
Der Tag-Name ergibt sich aus dem Dateinamen: hallo
Einbinden in die JSP:
alle Tag-Dateien sind im selben Verzeichnis (tagdir)
<%@ taglib tagdir="/WEB-INF/tags" prefix="meinetags" %>
keine Container-Konfiguration nötig!
349 / 446
JEE
Java Server Pages
JSTL
Verwendung des hallo-Tags in einer JSP
<%@ taglib tagdir="/WEB-INF/tags" prefix="meinetags" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head><title>Willkommen</title></head>
<body>
<c:set var="text" value="Guten Tag" />
<h1> ${text}, wie ist dein Name? </h1>
<form method="get">
<input type="text" name="username" size="25">
<input type="submit" value="Submit">
<input type="reset" value="Reset">
</form>
<c:if test="${fn:length(param.username) > 0}" >
<meinetags:hallo halloText="${text}" name="${param.username}" />
</c:if>
</body>
</html>
350 / 446
JEE
Servlets
Servlets: Interface und Klassen
<< interface >>
Servlet
Servlets implementieren Interface
javax.servlet.Servlet
Servlet-Methoden sind u.a.
init()
service()
destroy()
...
GenericServlet
init - Initialisierung
service - Request bearbeiten
destroy - beenden
GenericServlet: Basisklasse für
protokollspezifische Servlets
Subklasse HttpServlet: HTTP-Requests
{ abstract }
...
HttpServlet
{ abstract }
doGet()
doPost()
...
DatumServlet
351 / 446
JEE
Servlets
Servlets: Methoden und Objekte
service-Methode bearbeitet Web-Request
Delegation an: doGet, doPost, . . .
Servletobjekt bearbeitet mehrere Requests
Lastverteilung möglich: mehrere Instanzen
Parameter von „service“: Request, Response
Request-unabhängige Informationen: PageContext
ServletConfig-Objekt
Session-Objekt
Application-Objekt
352 / 446
JEE
Servlets
Beispiel für ein einfaches Servlet
package IBSBeispiele;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class DatumServlet extends HttpServlet {
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("<html><head><title> DatumServlet </title></head>");
out.println("<body>");
out.println("Datum: " + new java.util.Date());
out.println("</body></html>");
} finally {
out.close();
}
}
353 / 446
JEE
Servlets
public String getServletInfo() {
return "zeigt Datum und Uhrzeit";
}
}
Beispiel für ein aus JSP generiertes Servlet
package org.apache.jsp;
import javax.servlet.jsp.*;
import java.util.*;
public final class Beispiel1_jsp
extends org.apache.jasper.runtime.HttpJspBase
...
private static final JspFactory _jspxFactory =
JspFactory.getDefaultFactory();
...
public void _jspService(HttpServletRequest request,
HttpServletResponse response) throws ... {
PageContext pageContext = null; // Zugriff auf die anderen Objekte
HttpSession session = null;
// Sitzungsdaten
ServletContext application = null; // Servlet-übergreifende Daten
ServletConfig config = null;
// Konfigurationsdaten
JspWriter out = null;
// zum Schreiben der Antwortseite
Object page = this;
...
354 / 446
JEE
Servlets
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(...);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
...
out.write("<html>\n");
out.write("
<head>\n");
out.write("
<title>JSP Page</title>\n");
out.write("
</head>\n");
out.write("
<body>\n");
out.write("
Dynamische JavaServer Page. <br/>\n");
out.write("
Datum und Uhrzeit: ");
out.print( new Date());
out.write("
\n");
out.write("
</body>\n");
out.write("</html>\n");
} catch (Throwable t) {
...
355 / 446
JEE
Servlets
Die Initialisierungsmethode des Servlets: init
Schnittstellen
public void init()
throws ServletException
public void init(ServletConfig config) throws ServletException
Aufrufzeitpunkt: Nach Erzeugung des Servlet-Objekts
Typische Initialisierungsaktionen
Kontextinformation vom Container erfragen
Datenbankverbindung aufbauen
config bietet Zugriff auf die Servlet-Konfiguration, z.B.
Initialisierungsparameter aus dem Deployment-Deskriptor
Attribute im ServletContext speichern
Zugriff auf die Protokolldatei
356 / 446
JEE
Servlets
Verwendungsschema für init
public class BeispielServlet extends HttpServlet {
// ServletContext
protected ServletContext application = null;
public void init(ServletConfig conf) throws ServletException {
super.init(conf);
// Beispiel für Zugriff auf Initialisierungsparameter:
String p = conf.getInitParameter("param1");
// Kontext merken
application = conf.getServletContext();
// Attribut im Kontext speichern:
application.setAttribute("initzeit", new java.util.Date());
...
}
357 / 446
JEE
Servlets
Die Destroy-Methode des Servlets
wird vom Container bei Beendigung des Dienstes aufgerufen
bietet die Möglichkeit, Ressourcen des Servlet freizugeben
Beispiel: in der Init-Methode erzeugte Datenbankverbindung wieder
schließen
358 / 446
JEE
Servlets
Servlet-Beispiel: Simple Online-Bank
package Bank;
import java.io.*;
public class KontoServlet extends HttpServlet {
public class Konto {
private int betrag = 0;
void setBetrag(int neu) { betrag = neu; }
int getBetrag()
{ return betrag; }
}
Konto kto;
public void init(ServletConfig conf) throws ServletException {
super.init(conf);
kto = new Konto();
}
359 / 446
JEE
Servlets
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
out.println("<html><body>");
out.println("<h2> Servlet-Bank - Wir schreiben SERVICE groß</h2>");
out.println("Kontostand: <b>" + kto.getBetrag() + "</b><br>");
out.println("<form method=\"post\" action=\"" +
request.getRequestURI() + "\">");
out.println("Betrag: <input type=\"text\" name=\"betrag\"><br>");
out.println("<input type=\"submit\" name=\"abheben\"
value=\"abheben\">");
out.println("<input type=\"submit\" name=\"einzahlen\"
value=\"einzahlen\">");
out.println("</form>");
out.println("</body></html>");
out.close();
}
360 / 446
JEE
Servlets
public void doPost(HttpServletRequest request,
HttpServletResponse response)
int betrag = 0, kontostand = kto.getBetrag();
try {
betrag = Integer.parseInt(request.getParameter("betrag"));
} catch (NullPointerException e) {
} catch (NumberFormatException e) {
}
if (request.getParameter("abheben") != null &&
betrag <= kontostand)
kontostand -= betrag;
else if (request.getParameter("einzahlen") != null && betrag > 0)
kontostand += betrag;
synchronized (kto) { kto.setBetrag(kontostand); }
doGet(request, response);
}
public String getServletInfo() { return "Konto-Beispiel"; }
}
361 / 446
JEE
Servlets
Beispiel: Sitzungsmanagement mit Servlets
package shop;
import java.io.*;
public class Onlineshop extends HttpServlet {
public String getServletInfo() {
return "OnlineShop Servlet Beispiel";
}
protected void doGet(HttpServletRequest request,
out.print("<html><head><title>Online Obstladen</title>" +
"</head><body><h1>Obstladen</h1><form method=\"post\">" +
"<input type=\"submit\" name=\"apfel\" value=" +
"\"Packe einen Apfel in den Korb\"><br />" +
"<input type=\"submit\" name=\"birne\" value=" +
"\"Packe eine Birne in den Korb\"><br />" +
"<input type=\"submit\" name=\"zeige\" value=" +
"\"Zeige den Einkaufskorb\"><br />" +
"<input type=\"submit\" name=\"kaufe\" value=" +
"\"Kaufe den Korbinhalt\">" +
"</form></body></html>");
out.close();
}
362 / 446
JEE
Servlets
protected void doPost(HttpServletRequest request,
String msg;
HttpSession session = request.getSession(true);
if (session.isNew()) {
session.setAttribute("apfel", new Integer(0));
session.setAttribute("birne", new Integer(0));
}
int apfelAnzahl = (Integer) session.getAttribute("apfel");
int birneAnzahl = (Integer) session.getAttribute("birne");
if (request.getParameter("apfel") != null) {
apfelAnzahl++;
session.setAttribute("apfel", apfelAnzahl);
msg = "Apfel hinzugefügt! Du hast jetzt " + apfelAnzahl + ".";
} else if (request.getParameter("birne") != null) {
birneAnzahl++;
session.setAttribute("birne", birneAnzahl);
msg = "Birne hinzugefügt! Du hast jetzt " + birneAnzahl + ".";
} else if (request.getParameter("kaufe") != null) {
session.invalidate();
msg = "Dein Auftrag " + apfelAnzahl + " Äpfel und " + birneAnzahl +
" Birnen wurde ausgeführt. Der Korb ist wieder leer.";
} else {
msg = "Du hast " + apfelAnzahl + " Äpfel und " + birneAnzahl +
" Birnen im Einkaufskorb.";
}
363 / 446
JEE
Servlets
response.setHeader("pragma", "no-cache");
out.print("<html><head><title>Obstkorb</title></head><body>");
out.print(msg);
out.print("<hr><a href=\"");
out.print(request.getRequestURI());
out.print("\">Zurück zum Obstladen</a></body></html>");
out.close();
}
}
364 / 446
JEE
Servlets
Servlet-Filter
Filterketten mit Servlets
Jeder Filter bearbeitet Request- und Response-Objekt
Beispiele: Request-Protokollierung, Benutzerauthentifizierung
Filterketten-Spezifikation in der Container-Konfiguration
Servlet-Filter implementiert javax.servlet.filter
Request
Servlet−
Filter
Client
Servlet−
Filter
Servlet−
Filter
Servlet
Antwort
365 / 446
JEE
Struts und Java Server Faces: Frameworks für die
Web-Ebene
Vereinfachte Programmierung der Serverseite
Regel-basierte Spezifikation der Navigationslogik
vereinfachte Konstruktion von HTML-Benutzerschnittstellen
Validierung von Eingabewerten
Vereinfachte Fehlerbehandlung
Automatisierte Bean-Verwaltung („managed beans“)
Ereignisbehandlung
Internationalisierung des Webauftritts
366 / 446
JEE
MVC – Das Entwurfsmuster „Model View Controller“
Generisches Entwurfsmuster für Web-Systeme
View: Präsentationsebene, Benutzerschnittstelle
Model: Systemmodell mit Geschäftsdaten und Geschäftslogik
Controller: Interaktionsssteuerung
reagiert auf GUI-Ereignisse
sorgt für Aufrufe der zuständigen Model-Operationen
vermittelt Eingabedaten an das Model
wählt neue Benutzersicht aus
überträgt aktualisierte Geschäftsdaten in die Benutzersicht
aktualisiert die Benutzersicht
367 / 446
JEE
MVC – Folie von Sun
368 / 446
JEE
Umsetzungsbeispiel für MVC
Client
(WWW−Browser)
1
Controller
(Servlet)
4
2
Model
(Web−unabhängig)
3
View
(JSP)
Ein Front-Controller ist ein Controller, der zwischen einem
Web-basierten Frontend und einer Web-unabhängigen
Geschäftslogik („back end“) vermittelt.
369 / 446
JEE
Struts und JSF
Gemeinsame Merkmale von Struts und JSF
Die Anwendungen benutzen das MVC-Muster
Ein Servlet agiert als Front-Controller
Die Navigation wird über XML-Deskriptoren konfiguriert:
Festlegung der Einstiegsseite
Zuordnung einer Model-Aktion zum Request anhand von
Request-Parametern
Auswahl der nächsten Benutzersicht (JSP) abhängig vom
Resultat der Model-Aktion
HTML-Formulardaten werden mit Formular-Beans
synchronisiert
Für die GUI-Konstruktion gibt es JSP-Tagbibliotheken
Für die Internationalisierung gibt es Ressourcenbündel
370 / 446
JEE
Struts und JSF
Struts
Historie
Apache Open-Source Projekt,
seit 2000 ständig weiterentwickelt, stabil, weit verbreitet
aktuelle Version: 2.0
Struts-Varianten gibt es auch für PHP und C#
Merkmale einer Struts-Anwendung:
Action-Servlet und Request-Dispatcher als Front-Controller
Anwendungsprogrammierer entwickelt
JSPs (für jede HTML-Ansicht)
Pro Formular eine ActionForm-Bean zur Datenrepräsentation
Pro Formular eine Action-Klasse zur Bearbeitung
XML-Deskriptor für die Navigationslogik
371 / 446
JEE
Struts und JSF
Kontrollfluss im Struts-Modell
372 / 446
JEE
Java Server Faces
Java Server Faces
JSF-Merkmale
mehrere Implementierungen (jar-Archive): Sun, Apache, IBM, . . .
vordefinierte GUI-Komponenten + benutzerdefinierte GUI-Bausteine
serverseitiges Ereignismodell
Request-übergreifende Verwaltung von Komponentenzuständen
Formulardaten und Request-Behandlung in einer POJO-Bean
POJO = „plain old java object“: normale, vom Framework unabhängige Klasse
373 / 446
JEE
Java Server Faces
JSF-Lebenszyklus
Request
Sicht
wiederhestellen
Requestdaten
dekodieren
Ereignisse
behandeln
Cancel−Button
Validierung
Phasen der Bearbeitung von
Faces−Requests
Ereignisse
behandeln
Validierungsfehler
Model−Daten
aktualisieren
Ereignisse
behandeln
Konvertierungsfehler
Geschäftslogik
ausführen
Ereignisse
behandeln
Antwort
Model−Ereignisse
Antwortsicht
berechnen
374 / 446
JEE
Java Server Faces
JSF-Bausteine: Verwaltete Beans („managed beans“)
„Managed Bean“: Container verwaltet Lebenszyklus
für Datenspeicherung und Request-Bearbeitung zuständig
Deklaration in der Container-Konfiguration
Verarbeitung der Bean-Attribute mit EL, z.B.:
(verzögerte Auswertung!)
#{person.name}
Container kann Bean-Attribute initialisieren
Vordefinierte Java-Klassen als Beans verwendbar
375 / 446
JEE
Java Server Faces
Deklaration von Managed Beans
/WEB_INF/faces-config.xml
<managed-bean>
<managed-bean-name>person</managed-bean-name>
<managed-bean-class>
jsfBeispiel.PersonBean
</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
376 / 446
JEE
Java Server Faces
Normale Java-Klassen für Managed Beans möglich
<managed-bean>
<managed-bean-name>aufgabenliste</managed-bean-name>
<managed-bean-class>java.util.ArrayList</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
<list-entries>
<value>Einkaufen</value>
<value>Sitzung planen</value>
<value>Flug buchen</value>
</list-entries>
</managed-bean>
377 / 446
JEE
Java Server Faces
Verwendung von Managed Beans in einer JSP
3. Listenelement der Aufgabenliste
#{aufgabenliste[2]}
Einspaltige HTML-Tabelle mit dataTable-Iterator
<h:dataTable value="#{aufgabenliste}" var="eintrag" border="1">
<h:column>
<h:outputText value="#{eintrag}"/>
</h:column>
</h:dataTable>
378 / 446
JEE
Java Server Faces
JSF-Bausteine: Navigationsregeln
Beispiel für JSF-Navigationsregel (faces-config.xml)
<navigation-rule>
<from-view-id>/index.jsp</from-view-id>
<navigation-case>
<from-outcome>hallo</from-outcome>
<to-view-id>/hallo.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>tschuess</from-outcome>
<to-view-id>/tschuess.jsp</to-view-id>
</navigation-case>
</navigation-rule>
379 / 446
JEE
Java Server Faces
JSF-Bausteine: Navigationsregeln
Basiselemente der Regeln
navigation-rule
navigation-case
from-view-id
to-view-id
from-outcome
from-action
Regel
Teilregel
aktuelle Sicht
nächste Sicht
Resultat
Aktion
aktuelle Sicht −→ nächste Sicht
abhängig von Bedingung
JSP
JSP
Resultatswert der Aktion
Name der gewählten Aktion
Muster in Regeln verwendbar
<from-view-id>/hilfe/*</from-view-id>
380 / 446
JEE
Java Server Faces
JSF-Navigation: from-action und from-outcome
Wert ergibt sich aus action-Attribut einer JSF-Schaltfläche
Zwei Formen von action-Attributen:
action ist ein String
from-action: undefiniert
from-outcome: Wert von action
Beispiel:
<h:commandButton action="loginHelp" value="Login-Hilfe">
action ist Bean-Methodenaufruf
from-action: aufgerufene Methode
from-outcome: Resultat des Methodenaufrufs
Beispiel:
<h:commandButton action="#{loginBean.help}"
value="Login-Hilfe">
381 / 446
JEE
Java Server Faces
Beispiele zu from-action und from-outcome
Eine Regel für alle Aktionen, die „help“ zurückliefern, benutzt:
<from-outcome>help</from-outcome>
Eine Regel für die Aktion „abmelden“ benutzt:
<from-action>abmelden</from-action>
Aktion „bestellungAbschicken“ liefert „abbruch“ als Ergebnis:
<from-action>bestellungAbschicken</from-action>
<from-outcome>abbruch</from-outcome>
382 / 446
JEE
Java Server Faces
Ressourcenbündel für die Internationalisierung
Ein Ressourcenbündel enthält alle Strings einer Sprache
wird in Container-Konfigurationsdatei deklariert
wird mit loadBundle in die JSP eingebunden, z.B.
<f:loadBundle basename="ibg.messages" var="msg" />
Verwendungs-Beispiel: msg-Attribute
<h:outputLabel for="name" value="#{msg.userName}:" />
<h:panelGroup>
<h:inputText id="name" required="true" value="#{loginBean.loginName}"/>
<h:message for="name" />
</h:panelGroup>
<h:outputLabel for="passwort" value="#{msg.loginPassword}:" / >
<h:panelGroup>
<h:inputSecret id="passwort" required="true"
value="#{loginBean.passwort}" />
<h:message for= "passwort" />
</h:panelGroup>
383 / 446
JEE
Java Server Faces
Validierung von Formularfeldern
Vordefinierte Validierer, z.B. validateLength
Beispiel
<h:inputText id="plz" required="true" value="#{adresse.plz}">
<f:validateLength minimum="5" maximum="5"/>
</h:inputText>
<h:message for="plz" />
Benutzer-definierte Validierer
Java-Klasse mit einer validate-Methode, die bei Fehlschlag eine
ValidatorException erzeugt
Fehlermeldungen
Das <h:message>-Tag erzeugt eine Fehler-Nachricht bei
ValidatorException
384 / 446
JEE
Java Server Faces
Simples JSF-Beispiel: Einstiegsseite+Hallo+Tschuess
Funktion
In einem Formular der Einstiegsseite wird der Name erfragt und dann
eine der Aktionen hallo oder tschuess gewählt
Bean für die Formulardaten: PersonBean.java
public class PersonBean {
private String name;
public void setName(String name) { this.name = name; }
public String getName() { return this.name; }
}
Verwendung mit verzögerter Auswertung: #{person.name}
Semantik abhängig von Verarbeitungsphase
ein setName-Aufruf in der Phase „Model-Daten aktualisieren“
ein getName-Aufruf in der Phase „Antwortsicht berechnen“
385 / 446
JEE
Java Server Faces
Einstiegsseite: JSP mit JSF-Tags
Einstiegsseite: index.jsp
<html>
<%@taglib uri="http://java.sun.com/jsf/core" prefix= "f"%>
<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<f:view>
<head><title>Willkommen mit JSF</title></head>
<body>
<h:form id="halloFormular">
<h:outputLabel for="erfrageName" value="Wie heisst du?" />
<h:panelGrid columns="2">
<h:outputLabel for ="name" value="Name:"/>
<h:inputTextid ="name" value="#{person.name}"/>
<h:commandButton value="hallo"
action="hallo"/>
<h:commandButton value="tschuess" action="tschuess"/>
</h:panelGrid>
</h:form>
</body>
</f:view>
</html>
386 / 446
JEE
Java Server Faces
Hallo-Seite mit Abbruch-Button: hallo.jsp
<%@ taglib uri="http://java.sun.com/jsf/html"prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core"prefix="f"%>
<html>
<f:view>
<head><title>Willkommen</title></head>
<body>
<h:form>
<h1>Hallo,<h:outputText value="#{person.name}" /></h1>
<h:commandLink id="Abbruch" action="index" immediate="true">
<h:outputText value="Abbruch"/>
</h:commandLink>
</h:form>
</body>
</f:view>
</html>
immediate-Attribut: erzeugt in der Phase „Requestdaten dekodieren“ ein
Ereignis, das zum Überspringen der nachfolgenden Phasen führt.
387 / 446
JEE
Java Server Faces
Konfigurationsdatei: faces-config.xml (1/2)
<faces-config xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd"
version="1.2">
<navigation-rule>
<from-view-id>/index.jsp</from-view-id>
<navigation-case>
<from-outcome>hallo</from-outcome>
<to-view-id>/hallo.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>tschuess</from-outcome>
<to-view-id>/tschuess.jsp</to-view-id>
</navigation-case>
</navigation-rule>
388 / 446
JEE
Java Server Faces
Konfigurationsdatei: faces-config.xml (2/2)
<managed-bean>
<managed-bean-name>person</managed-bean-name>
<managed-bean-class>
jsfBeispiel.PersonBean
</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
<navigation-rule>
<from-view-id>*</from-view-id>
<navigation-case>
<from-outcome>index</from-outcome>
<to-view-id>/index.jsp</to-view-id>
</navigation-case>
</navigation-rule>
</faces-config>
389 / 446
JEE
Java Server Faces
Web-Container-Konfiguration: /WEB_INF/web.xml
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee ... "
version="2.5">
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.faces</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
390 / 446
JEE
JNDI
Namens- und Verzeichnisdienste
Namensdienst
Anwendungen benötigen Transportadressen entfernter Ressourcen
Prinzip der Ortstransparenz verbietet „hart kodierte“ Adressen
Ressourcen werden über „logische“ Adressen angesprochen
Namensdienst bildet logische Adressen ab auf Transportadressen
Verlagerung und Replikation von Ressourcen ohne Änderung der
Anwendung möglich
Verzeichnisdienst
Erweiterung des Namensdienst-Konzepts
verwaltet ein Verzeichnis von im Netz nutzbaren Objekten/Diensten
Verzeichnis-Eintrag kann beliebige Attribute enthalten
391 / 446
JEE
JNDI
Ressourcen-Beispiele
Pool von Datenbankverbindungen („data source“)
Web-Service
Enterprise Java Bean
392 / 446
JEE
JNDI
Namensdienst mit Lastverteilung durch Replikation
Namensdienst
Instanz
von Dienst X
suche Dienst X
Adresse
einer Instanz
von Dienst X
Registrierung
Instanz
von Dienst X
Instanz
von Dienst X
Client
nutze Dienst X
393 / 446
JEE
JNDI
JNDI – Java Naming and Directory Interface
API – Application Programming Interface
JNDI beinhaltet ein Java-API für Nutzer von Namens- und
Verzeichnisdiensten
API ermöglicht einheitlichen Zugriff auf verschiedene Dienste
SPI – Service Provider Interface
JNDI beinhaltet ein SPI für Implementierer von Verzeichnisdiensten
Diensteanbieter stellt die Funktionalität seines Dienstes durch
Implementierung der SPI-Operationen zur Verfügung.
Beispiele für Namensdienste
DNS, LDAP, NDS (Novell Directory Service), RMI, COS (CORBA
Naming Service), Dateisysteme
394 / 446
JEE
JNDI
JNDI-Merkmale
Objekte werden in hierarchisch aufgebauten Kontexten verwaltet.
Kontext
Operationen
entspricht einem „Ordner“
(z.B. in einem Dateisystem)
enthält primitive Objekte
und/oder Subkontexte
(Unterordner)
Ein „initialer Kontext“ ist die
Wurzel der Hierarchie
bind - neuen Eintrag einfügen
rebind - Eintrag
einfügen/ersetzen
unbind - Eintrag löschen
lookup - Eintrag suchen
list - Kontextinhalt auflisten
rename - Objekt umbenennen
createSubcontext Unterordner erzeugen
395 / 446
JEE
JNDI
Aufbau von Namen
Ein atomarer Name (atomic name) ist eine nicht weiter
strukturierte Zeichenkette
Ein Verbundname (compound name) ist eine Sequenz
atomarer Namen
Die konkrete Syntax ist vom Namensdienst abhängig, z.B.
java.sun.com, /produktkatalog/hilfe/index.jsp
Ein zusammengesetzter Name (composite name) ist aus
mehreren Verbundnamen gebildet, für die unterschiedliche
SPIs zuständig sind, z.B.
www.mni.fh-giessen.de/studium/master/index.html
Der erste Teil ist ein DNS-Verbundname der zweite ein
Dateipfad
396 / 446
JEE
JNDI
JNDI-Verwendungs-Beispiel: neuer Eintrag für DataSource
Eine MySQL-Datenquelle wird im Verzeichnis per JNDI
eingetragen (rebind-Methode)
Die Kontext-Variable INITIAL_CONTEXT_FACTORY liefert
Konstruktor für Root-Verzeichnis
INITIAL_CONTEXT_FACTORY ist abhängig vom Namensdienst,
hier: Dateisystem, Sun Referenzimplementierung
„com.sun.jndi.fscontext.RefFSContextFactory“
397 / 446
JEE
JNDI
import
import
import
import
import
javax.naming.Context;
javax.naming.InitialContext;
javax.naming.NamingException;
java.util.Hashtable;
javax.sql.DataSource;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
public class BindDataSource {
398 / 446
JEE
JNDI
try {
MysqlDataSource ds = new MysqlDataSource();
// Datenbank-Verbindung konfigurieren
ds.setServerName("localhost");
ds.setDatabaseName("shopdb");
ds.setPortNumber(3306);
ds.setUser("hans");
ds.setPassword("geheim!");
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
Context ctx = new InitialContext(env);
ctx.rebind("comp/env/jdbc/mysql/dataSource", dataSource);
ctx.close();
} catch (NamingException e) {
}}}
399 / 446
JEE
JNDI
Beispiel: Benutzung des DataSource-Objekts
...
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
Context ctx = new InitialContext(env);
DataSource ds = (DataSource) ctx.lookup("comp/env/jdbc/mysql/dataSource");
ctx.close();
Connection conn = ds.getConnection();
...
400 / 446
JEE
Wozu 4-Tier-Systeme für komplexe Web-Anwendungen?
Entkopplung von Geschäftslogik und Interaktionssteuerung
z.B. zur Unterstützung alternativer Front-End-Systeme
Verteilte Transaktionen, langlebige Transaktionen
Persistenzdienst für Objekte erforderlich
Hohe Skalierbarkeit:
Ressourcen-Pooling (z.B. für Datenbankverbindungen)
Lastverteilung durch Dienst-Replikation
Caching
Fehlertoleranz (z.B. automatischer Dienst-Neustart)
bedarfsorientierte Dienstaktivierung
Multiprotokoll-Kommunikation
Einbindung von Message-Servern (MOM)
401 / 446
JEE
EJB - Enterprise Java Bean
Java-Standard zur Implementierung von Tier 3 in einer verteilten
4-Tier-Architektur: Geschäftslogik
Merkmale
serverseitige Backend-Komponenten
kapseln Geschäftslogik und/oder Daten
bestehen aus mehreren Java-Klassen
implementieren mehrere Schnittstellen
brauchen zur Ausführung einen EJB-Container
kommunizieren mit CORBA/IIOP
aktueller EJB-Standard: Version 3.0
402 / 446
JEE
Beispiel-Szenario für den Einsatz der EJB-Technologie
Szenario (frei nach „Enterprise Java in a Nutshell“, O’Reilly)
Die Münchener Traditionsfirma „Weißbier- und Weißwurst-Warenhaus AG“, kurz
WWW-AG, möchte mit ihren Produkten ins lukrative Internetgeschäft einsteigen. Der
Online-Einkauf wird als 3-Tier-Architektur realisiert.
Geschäftslogik und Architektur
Ein Kunde besucht die Webseite der Firma um im Produktkatalog zu stöbern
und einzukaufen.
Der Webserver benutzt ein Servlet zur Warenkorb- und Sitzungsverwaltung, der
Warenkorb wird in einer Datenbank gespeichert
Zum Bestellen verwendet der Webserver ein weiteres Servlet, das über JDBC auf
den Warenkorb zugreift
Das Bestellservlet erfragt Kundeninformationen wie Lieferadresse und
Rechnungsadresse und speichert diese in der Kundendatenbank
403 / 446
JEE
Fallbeispiel
Integration einer proprietären Anwendung
(„legacy software“: spezielle, keinem Standard entsprechende Schnittstelle):
Das Bestellservlet sendet Rechnungsadresse und Gesamtpreis zum
Rechnungsschreibungs-Server.
Dieser wurde vor 22 Jahren in COBOL programmiert und hat eine nicht
standardisierte Schnittstelle. Er wird daher über einen Webservice-Adapter
benutzt.
Verwendung eines LDAP-Servers:
Die Firma betreibt 67 Filialen in Bayern und dem Rest der Welt. Die Filialliste
wird von einem LDAP-Verzeichnisdienst verwaltet.
Das Bestellservlet verwendet JNDI zum Zugriff auf das Filialverzeichnis, um die
dem Kunden nächstgelegene Filiale zu ermitteln.
Verwendung eines MOM-Servers:
Das Bestellservlet benutzt JMS, um einen Lieferauftrag über das
Messagingsystem an den Lieferauftragsserver der Filiale zu senden
404 / 446
JEE
Fallbeispiel
Modell des Online-Shops
405 / 446
JEE
Fallbeispiel
Einige Probleme
Rechnung, aber keine Lieferung
Manchmal wird eine Rechnung an den Rechnungsschreibungs-Server übermittelt aber
wegen eines System- oder Netzwerkfehlers wird keine Lieferung veranlaßt. Hier fehlt
ein Transaktionskonzept!
Überlastete Server
Nach einigen Monaten steigt die Kundenzahl auf 1000 pro Tag. In den Spitzenzeiten
sind einzelne Server (Web- und Persistenzschicht) so überlastet, dass
Kunden-Requests zeitweise nicht mehr bedient werden können.
System bleibt bei Fehlern hängen
Wegen Wartungsarbeiten und vereinzelter technischer Probleme bei den
Datenhaltungs-Servern ist der Onlineshop öfter nicht verfügbar.
Resultat:
Verzweifelte Kunden drohen schon mit dem Umstieg auf hessischen Handkäse und
Apfelwein. Eine Katastrophe!
406 / 446
JEE
Fallbeispiel
Was kann JEE zur Problemlösung beitragen?
Einbindung aller Bestell-Aktivitäten in verteilte Transaktion
bessere Performanz durch Ressourcen-Pooling und Caching
bessere Fehlertoleranz durch „Failover“-Mechanismen
(Dienste-Überwachung, automatischer Neustart von Diensten
nach Fehlern)
407 / 446
JEE
Fallbeispiel
Konsequenzen aus dem Einsatz einer 4-Tier-Architektur
Investition in die Server-Infrastruktur
Ein Applikationsserver muss angeschafft, installiert, betreut werden
Architekturumstellung erfordert Aufwand
Angesichts der Komplexität des Systems und der Lastabschätzung hätte
man besser von vorneherein das 4-Tier-Modell gewählt
Komplexität des Anwendungs-Code
Der Java-Code der 4-Tier-Anwendung ist einfacher:
Programmierung entfällt für:
Transaktionssteuerung
Persistenz der Objekte
Ressourcenverwaltung
EJB-Komponenten werden durch Annotationen eingebunden
408 / 446
JEE
Applikationsserver
JEE-Applikationsserver
Ein JEE-Applikationsserver beinhaltet
einen Servlet-Container (Unterstützung von Servlets und JSPs)
einen EJB-Container (Unterstützung von Enterprise Java
Beans)
Der EJB-Container verwaltet
Session Beans - Bausteine der Geschäftslogik
Entity Beans - Datenobjekte, Schnittstelle zur
Persistenzschicht
Message Beans - Nachrichtenschnittstelle zu MOM-Systemen
Beispiele für Applikationsserver:
JBoss (Open Source)
BEA Weblogic (BEA/Oracle)
IBM Websphere
Sun Glassfish (in Netbeans 6.x bereits integriert)
SAP Netweaver
409 / 446
JEE
Applikationsserver
Mehrschicht-Architektur mit EJBs
Browser
WS−Clients
HTTP
Get/Post
JSPs
JEE−
Applikations−
server
"Dicke" Clients
RMI/IIOP
SOAP
Servlets
RMI/IIOP
Web Services
RMI/IIOP
RMI/IIOP
EJBs
Konnektor
JDBC
DBMS
SOAP
Proprietäre
Systeme
Web Services
JMS
MOM−Server
410 / 446
JEE
Persistenz
Persistenz von Objekten
Problem: dauerhafte Speicherung von Geschäftsdaten
(in fast allen nicht-trivialen Web-Anwendungen)
Geschäftsdaten werden unterschiedlich repräsentiert:
Java-Komponente: Objekte, Objekt-Beziehungen, Klassen
Datenbank: Relationen, SQL-Datentypen
ORM („object relational mapping“)
definiert den Bezug zwischen Java- und
Datenbank-Repräsentation
Speicherung von (Java-)Objekten in relationalen Datenbanken
Abbildung von Objekten und Objekt-Beziehungen auf
Relationen
Objekt-Beziehungen: Vererbung, Aggregation, Komposition
usw.
Persistenz-Frameworks implementieren ORM
411 / 446
JEE
Persistenz
Historisches zu EJB und Persistenz
EJB 1.x (1997): Persistenz ist Problem des Anwendungsprogrammierers
EJB 2.x (2001): „Container Managed Persistence“ (CMP)
2001: JDO („Java Data Objects“)
2006: JPA („Java Persistence API“)
nicht auf JEE beschränkt
persistente Objekte sind POJOs
EJB 3.0 (2006): basiert auf JPA
mehrere JPA-Implementierungen:
JBoss Hibernate, Open Source, (sehr weit verbreitet)
Oracle Toplink, Open Source, (in Netbeans integriert)
BEA Kodo / Apache OpenJPA
412 / 446
JEE
Persistenz
Kommunikation mit
EJBs
EJB
EJB−Client
Geschäftslogik
EJB−Adresse
Container−Methoden:
JNDI
Interceptor
RMI
Verzeichnis−
dienst
Skeleton
Stub
Parameter
serialisieren
versenden
Transaktionslogik
Persistenz
Lebenszyklus
Ergebnis
empfangen
deserialisieren
Parameter
empfangen
deserialisieren
Container−
Konfiguration
Ergebnis
serialisieren
versenden
ORB / IIOP
EJB−Container
413 / 446
JEE
Session Bean
EJB-Typen: Session Bean
Merkmale:
implementiert Workflow
transient, kurzlebig
Client-gebunden
kann in Transaktionen eingebunden werden
modifiziert Datenbank
Anwendungs-Beispiele:
Bankautomat-Steuerung
Warenkorb im Online-Shop (nicht-persistent)
Fabrik-Objekt
Suche in einem Auktionsportal
414 / 446
JEE
Session Bean
Session-Bean-Kategorien
Zustandslos („stateless“)
kein „Gedächtnis“ über den Methodenaufruf hinweg
kann nacheinander für unterschiedliche Clients verwendet
werden
Poolbildung möglich
Zustandsvoll („stateful“)
Bean mit „Konversationsgedächtnis“
Nutzung vergleichbar mit dem Session-Objekt eines Servlets
modelliert typischerweise Sitzung eines Client
nur eine zustandsvolle Session-Bean pro Client
kein Pooling möglich, ineffizienter als stateless Beans
415 / 446
JEE
Message Driven Bean
MOM – „Message-Oriented Middleware“
Merkmale
asynchrone Client-Server-Kommunikation
„message queue“ zur Zwischenspeicherung
lose Kopplung zwischen Client und Server (gegenüber RMI)
Nachrichtenaustausch-Muster
Auftrag - Antwort
Publisher-Subscriber
Multicast
Einsatz im kommerziellen Backend-Bereich
Beispiel: IBM Websphere MQ (früher MQSeries)
JMS – „Java Message Service“
Java API zur Verwendung von MOM-Systemen
416 / 446
JEE
Message Driven Bean
EJB-Typen: Message Bean
Merkmale:
kapselt den Zugriff auf MOM-Server
bearbeitet JMS-Nachrichten
Beispiele:
nachrichtenorientierte Auftragserstellung
417 / 446
JEE
EJB-Schnittstellen
Schnittstellen von EJBs
Remote Interface: Geschäftslogik-Schnittstelle
enthält die applikationsspezifischen „Geschäftsmethoden“
Aufrufe indirekt über den EJB-Container
Local Interface: effizienter Aufruf für Clients in gleicher JVM
lokale Methodenaufrufe statt RMI → bessere Performanz
Verletzung des Ortstransparenz-Prinzips
Schnittstellen zwischen Bean und Bean-Container
Methoden zur Lebenszykluskontrolle durch EJB-Container
418 / 446
JEE
EJB-Schnittstellen
Beispiel: „Hallo Welt“-Stateless Session Bean
Remote Interface HalloWelt.java
public interface HalloWelt {
public String getBegruessungsText();
}
Remote-Interface ist POJO!
Vergleich EJB-Version 2:
public interface HalloWelt extends EJBObject { ... }
419 / 446
JEE
EJB-Schnittstellen
Beispiel: Implementierung des Remote-Interface
Implementierung: HalloWeltImpl.java
import
import
import
import
javax.ejb.Remote;
javax.ejb.Stateless;
java.rmi.RemoteException;
java.util.*;
@Stateless
@Remote(HalloWelt.class)
public class HalloWeltImpl implements HalloWelt, Serializable {
public String getBegruessungsText() throws RemoteException
{ return "Hallo Welt!"; }
}
420 / 446
JEE
EJB-Schnittstellen
Beispiel: „Hallo Welt“-Stateful Session Bean
Remote Interface HalloWeltStateful.java
public interface HalloWeltStateful {
public String getBegruessungsText();
public void setBegruessungsText(String text);
}
421 / 446
JEE
EJB-Schnittstellen
Implementierung: HalloWeltStatefulImpl.java
import
import
import
import
javax.ejb.Remote;
javax.ejb.Stateful;
java.rmi.RemoteException;
java.util.*;
@Stateful
@Remote(HalloWeltStateful.class)
public class HalloWeltStatefulImpl
implements HalloWeltStateful, Serializable {
private String begruessungsText:
public String getBegruessungsText() throws RemoteException
{ return begruessungsText; }
public void setBegruessungsText(String text) throws RemoteException
{ begruessungsText = text; }
}
422 / 446
JEE
EJB-Schnittstellen
EJB-Aufruf im Servlet
import javax.naming.*
import javax.servlet.http.*
public class HalloWeltClientServlet extend HttpServlet {
public void doGet(HttpServletRequest request,
Context ctx = new InitialContext();
HalloWelt hwEJB = (HalloWelt) ctx.lookup("HalloWelt");
String begruessungsText = hwEJB.getBegruessungsText();
ctx.close();
...
423 / 446
JEE
EJB-Alternativen
Alternative Java-Frameworks
Spring
meist als die „schlankere“ Haupt-Konkurrenz zu JEE angesehen
wird neuerdings auch mit JEE kombiniert verwendet (z.B. in BEA
Weblogic)
mehr: http://www.springframework.org
JBOSS Seam
Versuch, diverse Techniken zu verbinden
Front-End: Ajax, JSF, Portlets u.a.
Backend: Hibernate, EJB 3.0, BPM („Business Process
Management“)
mehr: http://www.seamframework.org
424 / 446
Webservices
Teil V
Webservices
425 / 446
Webservices
19
Serviceorientierte Architektur
20
Webservices
ESB
426 / 446
Webservices
SOA – Serviceorientierte Architektur
SOA ist ein IT-Paradigma, das eine
geschäftsprozessorientierte, anwendungsübergreifende Sicht
auf die IT-Landschaft eines Unternehmens favorisiert.
SOA modelliert Prozesse als Komposition von Diensten.
SOA unterstützt in besonderer Weise die Integration
heterogener, dezentral verwalteter Anwendungen auf der Basis
plattformunabhängiger Standards.
427 / 446
Webservices
SOA
Komponentenmodell für verteilte Anwendungen
Komponenten sind Dienste („Services“)
Rollen:
Dienstanbieter
Dienstnutzer
(„Service Provider“)
(„Service Requester“)
formal definierte Dienste-Schnittstelle
asynchrone Kommunikation, MOM
Service-Verzeichnisse
Kommunikationsbasis: plattformunabhängige Standards (meist
Webservices)
HTTP, XML, XML-RPC, SOAP, WSDL, UDDI, . . .
428 / 446
Webservices
Typische Probleme größerer Unternehmen
Flexibles Geschäftsprozessmanagement (BPM - Business
Process Management)
Geschäftsprozesse im Unternehmen ändern sich schneller als früher
Anforderung: Änderung und Neudefinition von Geschäftsprozessen
mit geringem Aufwand
Lösungsansatz: Geschäftsprozesse aus Diensten baukastenmäßig
zusammenstellen
Idealbild: graphischer „Prozessdesigner“ mit automatischer
Code-Erzeugung statt Refactoring von 5000 Zeilen Java-Code
429 / 446
Webservices
Integration heterogener Anwendungen (EAI - Enterprise
Application Integration)
Anwendungen berechnen und verwalten Daten, die in anderen
Anwendungen benötigt werden
Datenaustausch über gemeinsam benutzte Datenbanken oft nicht
realisierbar
Lösungsansatz: Dienste-orientierte Middleware als einheitliche
Schnittstelle zur Kommunikation zwischen vorhandenen
Anwendungen
430 / 446
Webservices
Integration externer Anwendungen
zunehmende Anzahl unternehmensübergreifender Anwendungen
Anwendungen als allgemein im Web verfügbare Dienstleistung
Kollaboration zwischen zwei Unternehmen
Lösungsansatz: externe und interne Anwendungen über
Dienste-Schnittstellen koppeln
431 / 446
Webservices
SOA – Architekturmerkmale
lose Kopplung der Komponenten
Asynchroner Nachrichtenaustausch als Kommunikationsbasis
komplexes Nachrichten-Konzept
offene Standards
Dienst als einheitliches Abstraktionskonzept
Prozesslogik (z.B. kompletten Geschäftsprozess)
Daten/Entitäten (z.B. Kunde, Auftrag)
technische Funktionen (Authentifizierung, Lastverteilung, . . . )
Schnittstelle zu einer Anwendung („Wrapper“)
432 / 446
Webservices
Webservices
Webservices
Auf offenen Standards basierende Middleware
Kernkomponenten
Nachrichten-System: SOAP, Nutzlast sind XML-Dokumente
Schnittstellenspezifikation: XML Schema und WSDL
(Webservice Description Language)
Erweiterungen: WS-* (Security, Transaction, ...)
Diensteorchestrierung mit WS-BPEL
433 / 446
Webservices
Webservices
Verantwortung für Standards und Spezifikationen
W3C
XML, XML Schema, XSLT, SOAP, WSDL, . . .
OASIS – Organization for the Advantage of Structured
Information Standards
ebXML, WS-BPEL, WS-Security, UDDI, SAML, XACML, . . .
Web Services Interoperability Organization (WS-I)
„Basic Profile“: Empfehlung für eine Zusammenstellung der
WS-Technologien und ihrer Versionen
Anwendungsmuster
Beispiel-Implementierungen
434 / 446
Webservices
Webservices
SOAP
SOAP-Nachrichten
SOAP-Envelope: enthält Header und Body
SOAP-Header: Metainformationen zur Nachricht
SOAP-Body: Nutzlast, XML-Dokument
435 / 446
Webservices
Webservices
Beispiel: Reisebuchung als SOAP-Nachricht
<?xml version=’1.0’ ?>
<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
<env:Header>
<m:reservation xmlns:m="http://travelcompany.example.org/reservation"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<m:reference>uuid:093a2da1-q345-739r-ba5d-pqff98fe8j7d</m:reference>
<m:dateAndTime>2009-11-29T13:20:00.000-05:00</m:dateAndTime>
</m:reservation>
<n:passenger xmlns:n="http://mycompany.example.com/employees"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<n:name>Karl Dall</n:name>
</n:passenger>
</env:Header>
436 / 446
Webservices
Webservices
<env:Body>
<p:itinerary
xmlns:p="http://travelcompany.example.org/reservation/travel">
<p:departure>
<p:departing>New York</p:departing>
<p:arriving>Los Angeles</p:arriving>
<p:departureDate>2009-12-14</p:departureDate>
<p:departureTime>late afternoon</p:departureTime>
</p:departure>
<p:return>
<p:departing>Los Angeles</p:departing>
<p:arriving>New York</p:arriving>
<p:departureDate>2009-12-20</p:departureDate>
<p:departureTime>mid-morning</p:departureTime>
</p:return>
</p:itinerary>
<q:lodging
xmlns:q="http://travelcompany.example.org/reservation/hotels">
<q:preference>none</q:preference>
</q:lodging>
</env:Body>
</env:Envelope>
437 / 446
Webservices
Webservices
WSDL – Webservice Description Language
XML-Sprache zur Schnittstellenbeschreibung eines Dienstes
Ein Webservice hat eine Schnittstelle
Die Schnittstelle besteht aus beliebig vielen Operationen
Eine Operation definiert eine Eingabe- und/oder eine
Ausgabe-Nachricht
benötigte Datentypen sind i.d.R. separate
Schema-Definitionen
Aufteilung der Schnittstellenbeschreibung in
abstrakte Beschreibung (portType oder interface)
konkrete Beschreibung (Transport-Endpunkte)
438 / 446
Webservices
Webservices
WS-Erweiterungen
Viele zusätzliche Leistungsmerkmale der
Kommunikations-Infrastruktur sind als WS-Erweiterungen
(WS-*) standardisiert, z.B.
WS-Transaction: verteilte Transaktionen
WS-ReliableMessaging: zuverlässige Nachrichtenübermittlung
WS-Security: Verschlüsselung, Authentifizierung u.a.
Sicherheitsfunktionen
Die Nutzung dieser Leistungsmerkmale erfolgt über
SOAP-Header
SOAP ist dadurch vergleichweise leicht erweiterbar
439 / 446
Webservices
Webservices
Webservice Baukastensystem
440 / 446
Webservices
Webservices
Beispiel für WS-Erweiterungen: Digital signierte
Dokumente
Der XML-Standard XML-Signature ermöglicht die
elektronische Signatur von XML-Dokumenten (oder einzelnen
XML-Elementen)
WS-Security nutzt diesen XML-Standard für SOAP:
XML-Nutzlast der SOAP-Nachricht wird digital signiert
Signatur und Angaben zur Auswertung werden als
SOAP-Header in die Nachricht integriert.
441 / 446
Webservices
Webservices
Web-Services
Orchestrierung
BPEL
WS−Reliable
Messaging
WS−Transaction
Dienst−
Qualität
WS−Coordination
WSDL
WS−Security
WS−Policy
SOAP
UDDI
Beschreibung
Entdeckung
Nachrichten−
Format
XML
Transportdienste: HTTP, E−Mail, TCP, ...
Transport
442 / 446
Webservices
Webservices
Web-Services und Java
Java enthält mehrere APIs für die Web-Service-Entwicklung.
Webservices und WS-Clients lassen sich auch ohne Befassung mit
der XML-Ebene (SOAP, WSDL) entwickeln.
JAXB (Java Architecture for XML Binding) ist eine API zur
Erzeugung von Java-Klassen aus WSDL-Schnittstellen und
umgekehrt
SAAJ (SOAP with Attachments API for Java) ist eine API zur
einfachen Verarbeitung von SOAP-Nachrichten
JAX-WS (Java API for XML - Web Services) ist eine API, die
zur Erzeugung von Webservices aus Java-Code mit
Annotationen dient
und weitere (JAXM, JAXR, . . . )
443 / 446
Webservices
Webservices
Java WS-APIs
WS−Erweiterungen
Security
Transaction
Reliable
Messaging
JAX−WS
WSDL
Java
JAXB
WS−Anwendung
XML−freie WS−Programmierung
SAAJ
JAXP
SOAP−Nachrichten
XML Verarbeiten
444 / 446
Webservices
Webservices
Beispiel für JAX-WS
package helloservice.endpoint;
import javax.jws.WebService;
@WebService()
public class Hello {
private String message = new String("Hello, ");
public void Hello() {}
@WebMethod()
public String sayHello(String name) {
return message + name + ".";
}
}
445 / 446
Webservices
Webservices
ESB
ESB - Enterprise Service Bus
intelligenter Nachrichtenvermittler
Aufgaben: Nachrichtenaustausch mit
API-/Protokoll-Transformation, Orchestrierungs-Engine,
dynamisches content-abhängiges Routing (z.B. für
Lastverteilung), Dienstverzeichnis, Sicherheitsdienste
Anwendung wird als Service an den ESB angebunden
Vorteil: weniger Schnittstellen gegenüber
Punkt-zu-Punkt-Kommunikation
JBI (Java Business Integration) ist ein Java-Standard für ESBs
JCA (Java Connector Architecture) ist ein Standard für
EAI-Adapter
Produkt-Beispiele: IBM Websphere ESB, JBoss ESB,
Microsoft BizTalk, Mule
In Netbeans ist der JBI-konforme OpenESB integriert
446 / 446

Internetbasierte Systeme - SS 2010 - Homepage

Transcrição

Documentos relacionados

Übungsblatt 4

Übungsblatt 11

XSL Schulung/ Seminar/ Training (FO, Apache FOP, PDF

Carte client • Kundenkarte

XSL, XSLT, FO - Einstieg für XML

anlage ref/plan zeitplan für juli und august 2015 preise

Web Services

Mise en page 1

anlage ref/plan zeitplan für november 2015 preise

baden-baden airport + shuttle