XML-Lösungen programmieren
358 45 2MB
German Pages 361 Year 2000
Recommend Papers
![Einführung in das Programmieren, II: Programmieren in einer Assemblersprache [Reprint 2018 ed.]
9783110827958, 9783110009262](https://ebin.pub/img/200x200/einfhrung-in-das-programmieren-ii-programmieren-in-einer-assemblersprache-reprint-2018nbsped-9783110827958-9783110009262.jpg)
![Programmieren lernen mit Python und Minecraft [3 ed.]](https://ebin.pub/img/200x200/programmieren-lernen-mit-python-und-minecraft-3nbsped.jpg)
File loading please wait...
Citation preview
Jake Sturm XML-Lösungen programmieren
Jake Sturm
XML-Lösungen programmieren
Dieses Buch ist eine deutsche Übersetzung von Jake Sturm: Developing XML Solutions Microsoft Press Deutschland, Edisonstraße 1, 85716 Unterschleißheim Copyright © 2000 by Jake Sturm
Das in diesem Buch enthaltene Programmmaterial ist mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor, Übersetzer und der Verlag übernehmen folglich keine Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieses Programmmaterials oder Teilen davon entsteht. Das Werk einschließlich aller Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen.
15 01
14 00
13
12
11
10
9
8
7
6
5
4
3
2
1
ISBN 3-86063-627-8 © Microsoft Press Deutschland (ein Unternehmensbereich der Microsoft GmbH) Edisonstraße 1, D-85716 Unterschleißheim Alle Rechte vorbehalten Übersetzung: Beate Majetschak, Düsseldorf Fachlektorat: Günter Jürgensmeier, München Korrektorat: Claudia Mantel-Rehbach, München Satz: Günter Jürgensmeier, München Umschlaggestaltung: HommerDesign, Haar (www.HommerDesign.com) Layout und Gesamtherstellung: Kösel, Kempten (www.KoeselBuch.de)
Inhaltsverzeichnis
Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführung . . . . . . . . . . . . . . . . . . . . Über dieses Buch . . . . . . . . . . . . . . Teil I: Einführung in XML . . . . . . Teil II: XML und Windows DNA . . XML-Tools . . . . . . . . . . . . . . . . . . Die CD zum Buch . . . . . . . . . . . . . . Installation der Beispielprogramme Die elektronische Version des Buchs Systemanforderungen . . . . . . . . . Teil I Einführung in XML
. . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
XIII XV
. . . . . . . . .
XV XV XVI XVII XVII XVIII XVIII XVIII
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1 XML im Unternehmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wissensarbeiter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das DNS-Geschäftsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ziele des DNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Skalierbarkeit gewährleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Erstellung von Microsoft Windows DNA-Systemen ermöglichen Die Internetnutzung erleichtern . . . . . . . . . . . . . . . . . . . . . . . . Ein »Unternehmensgedächtnis« einrichten . . . . . . . . . . . . . . . . . Papierformulare eliminieren . . . . . . . . . . . . . . . . . . . . . . . . . . . Selbstbedienungsanwendungen entwickeln . . . . . . . . . . . . . . . . . Das Feedback von Kunden aufzeichnen . . . . . . . . . . . . . . . . . . . B2B-Kommunikation bereitstellen . . . . . . . . . . . . . . . . . . . . . . . Auf Krisen reagieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
3 4 5 6 6 7 9 10 10 10 11 11 11
2 Auszeichnungssprachen SGML . . . . . . . . . . . . HTML . . . . . . . . . . . . Das frühe HTML . . . Probleme bei HTML . XML . . . . . . . . . . . . . Die Ziele von XML . . Vorteile von XML . . Zusammenfassung . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
13 14 15 15 15 18 18 20 20
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
V
3 Struktur eines XML-Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grundbestandteile eines XML-Dokuments . . . . . . . . . . . . . . . . . . . . . Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Grundlagen von HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Logische und physische HTML-Elemente . . . . . . . . . . . . . . . . . . . . CSS- und nicht CSS-fähige Browser . . . . . . . . . . . . . . . . . . . . . . . HTML-Code XMLisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HTML-Marotten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein XML-Template für Webdokumente erstellen . . . . . . . . . . . . . . . . . . XML Notepad einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der head-Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der body-Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Webhilfeseite einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Werte zu den Elementen des head- und des body-Abschnitts hinzufügen Aufräumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was haben Sie erreicht? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhalte automatisch verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhalt interpretieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Elemente wiederverwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Weitere XML-Editoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kriterien für wohlgeformte XML-Dokumente . . . . . . . . . . . . . . . . . . . . Die XML-Deklaration hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . . Das fertige XML-Dokument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
23 24 24 26 26 27 27 28 29 29 29 29 31 33 38 38 42 42 42 43 43 43 45 46 46 48
4 Eine Einführung in DTDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine DTD erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die !ELEMENT-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vordefinierte Konstantendeklarationen: PCDATA, ANY und EMPTY Eines oder mehrere Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . Die !ATTLIST-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Attributdatentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Standarddeklaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die überarbeitete DTD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die DTD mit einem XML-Dokument verknüpfen . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
49 49 52 52 53 57 57 60 60 61 65
5 Entitäten und andere Komponenten . . . . . . . . . . . . . Überblick über Entitäten . . . . . . . . . . . . . . . . . . . . . Interne Entitäten . . . . . . . . . . . . . . . . . . . . . . . . . . Interne allgemeine Entitäten . . . . . . . . . . . . . . . . . Interne Parameterentitäten . . . . . . . . . . . . . . . . . . Der XHTML-Standard und interne Parameterentitäten Das neue Dokument HilfeHTM.htm . . . . . . . . . . . Mögliche Probleme mit Parameterentitäten . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
67 67 68 69 71 72 83 83
VI
. . . . .
. . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
Inhaltsverzeichnis
Externe Entitäten . . . . . . . . . . . . . . . . . . . . . Externe analysierte allgemeine Entitäten . . . . Externe nicht analysierte allgemeine Entitäten Externe Parameterentitäten . . . . . . . . . . . . Verarbeitungsreihenfolge . . . . . . . . . . . . . . . . Konditionale Abschnitte . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
85 85 88 89 90 91 92
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
93 94 95 96 97 97 98 98 99 100 103 104 106 106 107 107
7 XML-Schemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfache Schemadatentypen . . . . . . . . . . . . . . . . . . . Die Komponenten eines Schemadatentyps . . . . . . . Einfache Datentypen erstellen . . . . . . . . . . . . . . . Komplexe Datentypen . . . . . . . . . . . . . . . . . . . . . . . Schemas in XML-Tools ansehen . . . . . . . . . . . . . . Wichtige Elemente in der Datei XHTMLschema.xsd . Eine DTD für Schemas . . . . . . . . . . . . . . . . . . . . Das schema-Element . . . . . . . . . . . . . . . . . . . . . Das annotation-Element . . . . . . . . . . . . . . . . . . . Das complexType-Element . . . . . . . . . . . . . . . . . . Das element-Element . . . . . . . . . . . . . . . . . . . . . Das attribute-Element . . . . . . . . . . . . . . . . . . . . Das attributeGroup-Element . . . . . . . . . . . . . . . . Das group-Element . . . . . . . . . . . . . . . . . . . . . . . complexType-Elemente mit Dokumentgeltungsbereich Ein Schema für ein datenorientiertes XML-Dokument Namespaces und Schemas . . . . . . . . . . . . . . . . . . . . Schemas in denselben Namespace aufnehmen . . . . . Schemas aus einem anderen Namespace integrieren . Datentypen überschreiben . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
109 109 110 112 116 116 117 119 121 121 121 123 124 125 126 130 132 134 135 136 137 138
6 XML Namespace, XPath, XPointer und XLink Namespaces . . . . . . . . . . . . . . . . . . . . . . . Namespace-Präfixe . . . . . . . . . . . . . . . . Standard-Namespaces . . . . . . . . . . . . . . Attribute und Namespaces . . . . . . . . . . . Namespaces in DTDs deklarieren . . . . . . XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . XML-Pfade . . . . . . . . . . . . . . . . . . . . . Knotenarten . . . . . . . . . . . . . . . . . . . . Achsen . . . . . . . . . . . . . . . . . . . . . . . . Grundlegende XPath-Muster . . . . . . . . . XPointer . . . . . . . . . . . . . . . . . . . . . . . . . XLink . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfache Links . . . . . . . . . . . . . . . . . . Erweiterte Links . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . .
Inhaltsverzeichnis
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . .
VII
8 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kommunikation über verteilte Systeme . . . . . . . . SOAP und das Request/Response-Modell . . . . . . HTTP-Header und SOAP . . . . . . . . . . . . . . . . . Request Header . . . . . . . . . . . . . . . . . . . . . Response Header . . . . . . . . . . . . . . . . . . . . Einfache SOAP-Nachrichten . . . . . . . . . . . . . . . Der Inhalt eines SOAP-Requests . . . . . . . . . . Nachrichten mit der Methode M-POST senden Der Inhalt einer SOAP-Response . . . . . . . . . Das Fault-Element . . . . . . . . . . . . . . . . . . . Ein Schema für den Inhalt der SOAP-Nachricht SOAP-Kodierung . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
139 139 140 141 141 142 143 143 146 147 148 150 151 151
9 BizTalk . . . . . . . . . . . . . . . . . . . . . . . . Die Nachrichtenstruktur von BizTalk . . . . BizTalk-Dokumente . . . . . . . . . . . . . . . BizTalk-Dokument-Header . . . . . . . . Lose gebundene Nachrichten . . . . . . . Das delivery-Element . . . . . . . . . . . . Das properties-Element . . . . . . . . . . . Das manifest-Element . . . . . . . . . . . Das process-Element . . . . . . . . . . . . MultiPart-MIME . . . . . . . . . . . . . . . XDRs . . . . . . . . . . . . . . . . . . . . . . . . . Das description-Element . . . . . . . . . . Das datatype-Element . . . . . . . . . . . Das AttributeType-Element . . . . . . . . Das element-Element . . . . . . . . . . . . Das group-Element . . . . . . . . . . . . . . Das Schema-Element . . . . . . . . . . . . Das ElementType-Element . . . . . . . . . Das BizTalk-Schema für Northwind Traders BizTalk-Schemas gemeinsam nutzen . . . . DTD, W3C-Schema oder BizTalk-Schema? Informationen für ein Schema identifizieren Zusammenfassung . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
153 154 155 156 159 158 160 161 162 163 164 165 165 167 167 167 168 169 170 172 173 174 175
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
177
Teil II XML und Windows DNA
10 Überblick über Windows DNA . . Das logische Dreischichtenmodell Benutzerdienstekomponenten Geschäftsdienstekomponenten Datendienstekomponenten . . Verbindung der drei Schichten
VIII
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
179 180 180 181 181 183
Inhaltsverzeichnis
Das physische Dreischichtenmodell . . . . . . . . . . . . . . . . . . Zustandswahrende und zustandslose Komponenten . . . . . . . Das Design eines verteilten Systems . . . . . . . . . . . . . . . . . . Komponenten kaufen, wiederverwenden oder neu erstellen Logische Komponenten erstellen . . . . . . . . . . . . . . . . . Erweiterung des Windows DNA-Modells . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
183 184 185 187 188 190 191
11 Das XML-Document Object Model (DOM) . . . . . . . . . . . . . . . . . . Die Implementierung des XML-DOMs in Internet Explorer . . . . . . . Das XMLDOMDocument-Objekt . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMNode-Objekt . . . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMNodeList-Objekt . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMNamedNodeMap-Objekt . . . . . . . . . . . . . . . . . Das XMLDOMDocumentType-Objekt . . . . . . . . . . . . . . . . . . Das XMLDOMDocumentFragment-Objekt . . . . . . . . . . . . . . . Das XMLDOMElement-Objekt . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMAttribute-Objekt . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMEntity-Objekt . . . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMEntityReference-Objekt . . . . . . . . . . . . . . . . . . Das XMLDOMNotation-Objekt . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMCharacterData-Objekt . . . . . . . . . . . . . . . . . . Das XMLDOMText-Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMCDATASection-Objekt . . . . . . . . . . . . . . . . . . Das XMLDOMComment-Objekt . . . . . . . . . . . . . . . . . . . . . . Das XMLDOMProcessingInstruction-Objekt . . . . . . . . . . . . . . Das XMLDOMImplementation-Objekt . . . . . . . . . . . . . . . . . . Das XMLDOMParseError-Objekt . . . . . . . . . . . . . . . . . . . . . Das XTLRuntime-Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . Das XMLHTTPRequest-Objekt . . . . . . . . . . . . . . . . . . . . . . . Eine SOAP-Anwendung mit XML-DOM erzeugen . . . . . . . . . . . . . XML-Parser Version 2.6 und Version 3.0 . . . . . . . . . . . . . . . . . . . . Die Objekte XMLDOMDocument2, XMLDOMSchemaCache und XMLDOMSelection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
193 193 194 198 202 204 205 207 207 209 209 209 210 210 211 211 211 211 212 212 215 215 216 220
. . . . . . . . . . . . . . . . . . . .
221 224
12 XML-Darstellung mit XSL und CSS . . . . . . . . . . . XHTML und Cascading Style Sheets . . . . . . . . . . CSS-Dokumente . . . . . . . . . . . . . . . . . . . . . XSL zur Darstellung von XML-Dokumenten nutzen XSL-Muster . . . . . . . . . . . . . . . . . . . . . . . . XSL-Filteroperatoren . . . . . . . . . . . . . . . . . . XML mit XSL umwandeln . . . . . . . . . . . . . . . XSL-Dokumentelemente . . . . . . . . . . . . . . . . XSLT, XPath und XSL Formatting Objects . . . . . . . XSLT-Elemente . . . . . . . . . . . . . . . . . . . . . . XSL in XSLT konvertieren . . . . . . . . . . . . . . . XPath-Funktionen . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . .
225 226 226 226 229 229 230 231 242 242 244 247
Inhaltsverzeichnis
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . .
. . . . . . . . . . . .
. . . . . . .
. . . . . . . . . . . .
. . . . . . .
. . . . . . . . . . . .
. . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
IX
XSLT-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Unterstützung von XSL und XSLT im XML-DOM . . . . . . . . . . . . . . IXTLRuntime-Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Objekte XMLDOMXSLTemplate und XMLDOMXSLProcessor Programmierung mit XSL und XSLT . . . . . . . . . . . . . . . . . . . . . . . . Das XML-DOM für XSLT und XSL nutzen . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
249 249 249 254 256 256 261
13 Dynamische Benutzerdienstekomponenten erstellen . . . . . . DHTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Objektmodell von DHTML . . . . . . . . . . . . . . . . . . . Ereignisse, die mit DHTML-Objekten verknüpft sind . . . . . Das Event-Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . DHTML-Verhaltensweisen . . . . . . . . . . . . . . . . . . . . . . . Das XML-DSO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HTML-Elemente mit dem XML-DSO an XML-Daten binden Beispiele für den Einsatz des XML-DSO . . . . . . . . . . . . . . . . Ereignisse des XML-DSO . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
263 263 264 266 266 268 270 270 271 278 283
14 Geschäftsdienstekomponenten . . . . . . . . . . . Geschäftsdienstekomponenten mit HTC erstellen Kompilierte Komponenten . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
285 286 296 297
15 Datendienstekomponenten und XML . . . . . . . . . . . . . . . . . . . . . . . . ADO 2.5 und XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten mit ADO 2.5 als XML-Code ausgeben . . . . . . . . . . . . . . . . . . XML-Daten mit ADO 2.5 einlesen . . . . . . . . . . . . . . . . . . . . . . . . . Daten ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Datenquelle aktualisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Streams arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die ISAPI-Erweiterung für SQL Server . . . . . . . . . . . . . . . . . . . . . . . . Zugriff auf SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . URLs zur Ausführung von Abfragen nutzen . . . . . . . . . . . . . . . . . . Die SQL ISAPI-Erweiterung für die Aktualisierung von Daten benutzen Die XSL ISAPI-Erweiterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
299 299 300 303 304 305 307 308 309 311 313 315 317
16 Microsoft BizTalk Server 2000 . . . . Der BizTalk Editor . . . . . . . . . . . . Datensätze und Felder . . . . . . . Die Registerkarte Declaration . . Die Registerkarte Reference . . . . Die Registerkarte Parse . . . . . . . Die Registerkarte Dictionary . . . BizTalk Mapper . . . . . . . . . . . . . . BizTalk Management Desk . . . . . . . BizTalk Management Desk nutzen
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
319 319 322 322 322 324 326 326 329 330
X
. . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
Inhaltsverzeichnis
Pipelines . . . . . . . . . . . . . . . . . . . . . . . Verteilerlisten . . . . . . . . . . . . . . . . . . . BizTalk-Dokumente versenden und empfangen BizTalk Server Administration Console . . . . . Oberfläche für die Überwachung . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
332 333 334 334 335 336
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
337
Der Autor
343
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inhaltsverzeichnis
XI
Danksagung
Als Erstes möchte ich den beiden Lektoren Denise Bankaitis und Julie Xiao meine Anerkennung zollen. Ein Buch entsteht immer im Team aus Autor und Lektoren. Und dieses Buch ist ein gelungenes Gemeinschaftswerk. Denise hat das Buch auf sprachliche Korrektheit hin überprüft und seine Lesbarkeit stark verbessert. Julie, die fachliche Lektorin, überprüfte den technischen Inhalt des Buches. Ihre Aufgabe war wegen der ständigen Änderungen in den W3CSpezifikationen, den neuen Produktreleases und dem Fehlen einer Dokumentation der aktuellsten XML-Technologien besonders schwierig. Julie hat den Text auf Fehler durchgesehen, Inkonsistenzen ausfindig gemacht und wesentliche Beiträge zu diesem Buch geleistet. Ich möchte auch Marc Young danken, der die technische Bearbeitung der ersten Kapitel des Manuskripts übernahm, und Jennifer Harris, die das Projekt ganz am Anfang betreute. Weiterhin möchte ich folgenden Personen für ihren Beitrag zum Buch danken: Gina Cassill, Patricia Masserman, Joel Panchot, und Richard Shrout. Mein Dank gilt auch Dan Rogers und Kevin McCall, die bei Microsoft für die BizTalk ServerGruppe verantwortlich sind und mir unzählige Fragen beantwortet haben. Beim Schreiben dieses Buches habe ich mehrere XML-Programme verwendet. Ich möchte mich bei den Mitarbeitern von Extensibility, Inc., bedanken, die meine Fragen beantwortet und mir das Programm XML Authority zur Verfügung gestellt haben. Außerdem würde ich gerne den folgenden Firmen für die Bereitstellung von Software Dank sagen: Vervet für XML Pro, Microstar für Near and Far und Icon Information-Systems für XML Spy. Es handelt sich um großartige XML-Programme, die mir bei der Erstellung der Beispiele zum Buch sehr hilfreich waren. Neben diesen Programmen sorgt auch Microsoft mit einer Bandbreite an Produkten, die von Internet Explorer 5 bis BizTalk Server reichen, dafür, dass XML heute Bestandteil von Unternehmenslösungen sein kann. Ohne diese Programme und Produkte wäre dieses Buch nie fertig geworden. Ich möchte mich auch bei meiner Familie, Gwen, Maya, William, Lynzie und Jillian, bedanken, die wieder einmal auf mich verzichten mussten, damit ich dieses Buch fertig stellen konnte. Zum Schluss möchte ich mich bei Ihnen dafür bedanken, dass Sie dieses Buch erworben haben. Ich hoffe, das Buch hilft Ihnen dabei, XML zu verstehen, und es findet Verwendung bei Ihrer zukünftigen Arbeit.
XIII
Einführung
Dieses Buch richtet sich an alle, die einen Überblick über die Entwicklung der nächsten Generation von Geschäftssoftware erhalten möchten. Wenn Sie sich in XML (Extensible Markup Language) einarbeiten und erfahren möchten, wie Sie XML für die B2B-Kommunikation (B2B – Business-to-Business) einsetzen können, erfahren möchten, was SOAP (Simple Object Access Protocol) und BizTalk-Erweiterungen sind, und wissen möchten, wie Sie Microsoft Internet Explorer 5 zusammen mit XML einsetzen können, bietet Ihnen dieses Buch alle benötigten Informationen. Sie sollten über Grundkenntnisse von Microsoft Visual Basic und der Visual Basic Integrated Development Environment (IDE) verfügen. Entwickler finden Codebeispiele, eine Beschreibung von Internet Explorer 5-DOM (DOM – Document Object Model) und viele andere Themen. Webentwickler erfahren, wie sie XML zur Erstellung von Webseiten einsetzen können. Erfahrene Programmierer und Manager finden eine Beschreibung, wie sich XML in das Unternehmen integrieren lässt. In diesem Buch werden auch einige W3C-Spezifikationen (W3C – World Wide Web Consortium) besprochen, die jedoch noch nicht endgültig sind. Sie sollten deshalb die Website von W3C unter http://www.w3.org häufiger besuchen, um nach Aktualisierungen der Spezifikationen Ausschau zu halten.
Über dieses Buch Dieses Buch bietet eine ausführliche Beschreibung von XML als Auszeichnungssprache und dafür, wie XML eingesetzt werden kann, um ein digitales Nervensystem (DNS – Digital Nervous System) mit dem Microsoft Windows DNA-Framework mit SOAP 1.1, BizTalk Framework 2.0 und Internet Explorer 5 zu erstellen. Dieses Buch setzt sich aus zwei Teilen zusammen. Teil I behandelt die grundlegenden Elemente von XML und die Entwicklung von Unternehmenslösungen mit SOAP und BizTalk. Teil II befasst sich mit XML und Windows DNA. Es wird dargestellt, wie mit Internet Explorer 5 und dem Windows DNA-Framework Geschäftssysteme eingerichtet werden. Im Buch finden Sie auch Codebeispiele, anhand derer die Konzepte veranschaulicht werden.
Teil I: Einführung in XML Kapitel 1 beschreibt, wie XML sich in das Unternehmen einfügt. Es bietet einen Überblick über DNS, XML und Wissensarbeiter und enthält eine Beschreibung dafür, wie XML-Lösungen sich in den DNS einfügen. Kapitel 2 bietet einen allgemeinen Überblick über Auszeichnungssprachen (Markup Languages). Das Kapitel beginnt mit einem kurzen Überblick über die Geschichte der Auszeichnungssprachen. Es folgt eine Beschreibung der drei wichtigsten Sprachen Standard Generalized
XV
Markup Language (SGML), Hypertext Markup Language (HTML) und Extensible Markup Language (XML). Kapitel 3 befasst sich mit der Grundstruktur von XML-Dokumenten. Es werden Themen wie XML-Elemente, -Attribute und -Kommentare, Verarbeitungsanweisungen und wohlgeformte Dokumente besprochen. Es werden außerdem einige beliebte XML-Programme demonstriert. Kapitel 4 bietet eine Einführung in die Document Type Definition (DTD). Die DTD ist ein optionales Dokument, das zur Definition der Struktur von XML-Dokumenten verwendet werden kann. Dieses Kapitel bietet einen Überblick über DTDs, erklärt die Erstellung gültiger Dokumente und beschreibt die DTD-Syntax sowie die Erstellung von XML-Dokumentstrukturen mit DTDs. Kapitel 5 untersucht DTD-Entitäten. Dieses Kapitel zeigt, wie externe, interne, allgemeine und Parameterentitäten deklariert werden und wie diese Entitäten in dem XML-Dokument und der DTD erweitert werden. Kapitel 6 behandelt vier der Spezifikationen, die XML unterstützen: XML Namespaces, XML Path Language (XPath), XML Pointer Language (XPointer) und XML Linking Language (XLink). Dieses Kapitel bietet einen Überblick über Namespaces, ihre Bedeutung und Deklaration. Außerdem wird beschrieben, wie mit XPath, XLink und XPointers bestimmte Teile eines XML-Dokuments gefunden werden und Links in einem XML-Dokument erzeugt werden können. Kapitel 7 befasst sich mit XML-Schemas. Das Kapitel veranschaulicht einige Nachteile von DTDs, was ein Schema ist und die Elemente eines Schemas. In Kapitel 8 geht es um SOAP 1.1. Das Kapitel behandelt die Probleme, die mit Firewalls verbunden sind, Prozeduraufrufe und den Einsatz von SOAP, um Interoperabilität zu gewährleisten. Außerdem wird anhand von Beispielen der Einsatz von SOAP in Geschäftslösungen beschrieben. Kapitel 9 untersucht das BizTalk Framework 2.0 und bietet eine ausführliche Beschreibung von BizTalk-Tags und -Schemas. Die nächste Generation von Produkten, die BizTalk unterstützen werden, wird ebenfalls beschrieben. Der Rest des Kapitels ist auf den Einsatz von BizTalk in Geschäftslösungen ausgerichtet.
Teil II: XML und Windows DNA Kapitel 10 bietet einen Überblick über das Windows DNA-Framework und dessen grundlegende Modelle, das logische und das physische Modell. Das Kapitel behandelt in erster Linie das logische Dreischichtenmodell, das von den Diensten definiert wird, die von den Systemkomponenten ausgeführt werden. Diese Dienste fallen in drei grundlegende Kategorien: Benutzerdienstekomponenten, Geschäftsdienstekomponenten und Datendienstekomponenten. Das Kapitel endet mit einer Beschreibung des Windows DNA-Systemdesigns. Kapitel 11 beschreibt einen Großteil der Objekte des XML-Document Object Models (DOM). Darin wird beschrieben, wie das DOM eingesetzt wird, und es bietet zahlreiche Codebeispiele, die die Arbeit mit den DOM-Objekten veranschaulichen. Die restlichen DOM-Objekte werden in Kapitel 12 besprochen. Kapitel 12 behandelt die Präsentation von XML-Daten mit der Extensible Stylesheet Language (XSL) in einem Webbrowser, die Umwandlung von XML-Dokumenten mit XSL Transformations (XSLT) und die Erstellung statischer Komponenten von Benutzerdiensten mit XML. Wei-
XVI
Einführung
terhin werden die Unterstützung von XSL und XSLT im XML-DOM und die Programmierung mit XSL und XSLT beschrieben. Kapitel 13 veranschaulicht die Erstellung dynamischer webbasierter Benutzerdienstkomponenten mit DHMTL (Dynamic HTML) und das XML Data Source Object (DSO), das in Internet Explorer 5 enthalten ist. Sie erfahren, wie mit DHTML Benutzerdienstkomponenten erstellt werden können, die direkt auf die Eingaben von Benutzern reagieren, und wie das XML DSO verwendet wird, um direkt mit XML-Daten arbeiten zu können, die in HTML-Code eingebettet sind. Kapitel 14 zeigt, wie XML zur Erstellung von Benutzerdienstkomponenten eingesetzt werden kann und wie Benutzerdienstkomponenten mit HTML Components (HTC) erzeugt werden. Kapitel 15 erkundet den Einsatz von XML in Datendienstkomponenten. Das Kapitel beschreibt die Verwendung von ActiveX Data Objects (ADO) mit XML, die Microsoft XML SQL Server Internet Server Application Programming Interface-Erweiterung (ISAPI) und die XSL-ISAPIErweiterung. Die SQL-ISAPI-Erweiterung gestattet die automatische Konvertierung von XSLDokumenten in XML, wenn Daten nicht mit dem Browser Internet Explorer 5 angefordert werden. Kapitel 16 bietet eine Einführung in Microsoft BizTalk Server 2000. Mit BizTalk Server 2000 können Unternehmen Informationen innerhalb und mit Partnern des Unternehmens mit XML austauschen.
XML-Tools Es gibt zahlreiche XML-Tools, die Sie bei der Entwicklung von XML-Anwendungen unterstützen. Einige dieser Tools werden in den Beispielen im Buch verwendet, wie z. B. XML Authority von Extensibility, Inc., XML Spy von Icon Informations-System und XML Pro von Vervet Logic. XML Authority bietet eine umfassende Entwicklungsumgebung, die die Erstellung, Konvertierung und Verwaltung von XML-Schemas beschleunigt. XML Spy ist ein Tool zur Anzeige und Bearbeitung von XML-Dokumenten. XML Pro ist ein Tool zur Bearbeitung von XML-Dokumenten anhand von Menüs und Dialogfeldern. Die Tools können Sie von den folgenden Websites herunterladen: XML Authority unter www.extensibility.com, XML Spy unter http://xmlspy.com und XML Pro unter www.vervet.com. Bitte beachten Sie, dass es sich hierbei nicht um Produkte von Microsoft handelt und Microsoft weder für deren Inhalt verantwortlich ist noch sich durch einen Verweis in diesem Buch Ansprüche hinsichtlich eines Produkts oder einer Website ableiten lassen. Microsoft übernimmt keine Garantie oder Aufwandsentschädigung für die Produkte von Drittanbietern.
Die CD zum Buch Die CD zum Buch beinhaltet alle Codebeispiele, die im Buch besprochen werden, Microsoft Internet Explorer 5, Software von Drittanbietern und eine elektronische Version des englischen Originalbuchs. Die Codebeispiele finden Sie im Ordner \Example Code. Um die Beispiele zu installieren, legen Sie die CD-ROM in Ihr CD-ROM-Laufwerk ein. Falls AutoRun nicht aktiviert ist, führen Sie die Datei StartCD.exe im Stammverzeichnis der CD aus. Wählen Sie dazu Start/Ausführen, klicken Sie im Dialogfeld Ausführen auf die Schaltfläche Durchsuchen und wählen Sie die Datei StartCD.exe im Stammverzeichnis der CD.
Einführung
XVII
Installation der Beispielprogramme Die Beispielprogramme können Sie entweder auf der CD zum Buch betrachten oder auf Ihrer Festplatte installieren, um damit eigene Anwendungen zu erstellen. Die Installation der Beispielprogramme beansprucht ungefähr 162 KB Festplattenspeicher. Um die Beispielprogramme zu installieren, legen Sie die CD in das CD-ROM-Laufwerk ein und führen die Datei Setup.exe im Ordner \Setup der CD aus. Einige Beispielprogramme benötigen die Vollversion von Internet Explorer 5. Wenn Sie diese noch nicht auf Ihrem Computer installiert haben, führen Sie die Datei Ie5setup.exe im Ordner \MSIE5 aus, um die Installation des deutschen Internet Explorer 5 nachzuholen. Falls Probleme mit den Beispieldateien auftreten, sollten Sie die Datei Readme.txt im Stammverzeichnis der CD oder den Text im Buch lesen, der das Beispielprogramm beschreibt. Sie können die Beispielprogramme auch deinstallieren. Klicken Sie dazu in der Systemsteuerung doppelt auf Software, klicken Sie auf die Schaltfläche Programme ändern oder entfernen. Wählen Sie nun den Eintrag XML-Lösungen programmieren – Beispielcode und klicken Sie auf die Schaltfläche Ändern/Entfernen.
Die elektronische Version des Buchs Der vollständige Text der englischen Originalausgabe Developing XML Solutions steht auf der CD als elektronisches Buch mit Volltextsuche zur Verfügung. Um es anzuzeigen, benötigen Sie Microsoft Windows 95, Microsoft Windows 98, Microsoft Windows NT (mit Service Pack 3 oder neuer) oder Microsoft Windows 2000. Der Microsoft Internet Exlorer 4.01 oder neuer und die neuesten HTML Help-Komponenten müssen auf Ihrem System installiert sein. Ist dies nicht der Fall, bietet Ihnen der Installationsassistent eine englische Grundversion von Internet Explorer 5 an; sie befindet sich im Ordner \EBooks. Die Installation wurde so angepasst, dass nur die unbedingt notwendigen Dateien installiert und keine aktuellen Einstellungen oder Dateizuordnungen verändert werden.
Systemanforderungen Die XML-Beispiele in diesem Buch können auf einem Computer ausgeführt werden, der die folgenden Systemanforderungen erfüllt: b 486er-Prozessor oder höher b Windows 95, Windows 98, Windows NT 4.0 oder Windows 2000 b Visual Basic 6 (wenn Sie die Visual Basic-Beispiele des Buchs ausführen möchten, muss die Software auf Ihrem Computer installiert sein.)
XVIII
Einführung
Teil I Einführung in XML
1 4 5 6
XML im Unternehmen
Wissensarbeiter Das DNS-Geschäftsmodell Ziele des DNS
Die letzten vier Jahrzehnte des zwanzigsten Jahrhunderts sind Zeugen der Geburt des Computerzeitalters. Computer sind zu einem wesentlichen Werkzeug für fast jeden Mitarbeiter eines Unternehmens geworden. Mehr als 50 Prozent aller US-Haushalte sind inzwischen mit PCs ausgestattet und mit dieser schnellen Vermehrung ging auch die Explosion des Internets einher. Das Internet hat nicht nur die Art und Weise verändert, in der Konsumenten Informationen sammeln und einkaufen, sondern auch, wie Unternehmen Geschäfte machen. Heutzutage müssen Unternehmen in der Lage sein, schnell auf die Anforderungen des Marktes zu reagieren, und sie müssen große Datenmengen analysieren können, um die richtigen Entscheidungen treffen zu können. Um für das Unternehmen nützlich zu sein, müssen die Daten genau, relevant und sofort verfügbar sein. Wie Sie in diesem Kapitel sehen werden, bietet ein Digitales Nervensystem (DNS – Digital Nervous System) die nötige Computer- und Softwareinfrastruktur, anhand derer sich genaue und relevante Daten rechtzeitig bereitstellen lassen. Eines der wichtigsten Elemente des DNS ist die Bewegung von Daten. Häufig lassen sich die Daten am besten im XML-Format (XML – Extensible Markup Language) versenden. XML kann zur Erstellung von Textdokumenten eingesetzt werden, die Daten in strukturierter Form enthalten. Neben den Daten können auch ausführliche Regeln integriert werden, die die Datenstruktur definieren. Der Autor des XML-Dokuments definiert diese Regeln. Ein Beispiel wäre ein Satz von Regeln zur Überprüfung der Gültigkeit von Microsoft Exchange-E-MailDokumenten, von Microsoft SQL Server-Datenbanken, von Microsoft Word-Dokumenten oder anderen Arten von Daten, die im Unternehmen verwendet werden. Eine Initiative der Industrie namens BizTalk, die von Microsoft gestartet wurde und von vielen Unternehmen unterstützt wird, wie z. B. CommerceOne und Boeing, stellt einen Standardsatz an Regeln zur Verfügung, auf die sich verschiedene Konzerne und Einzelunternehmen geeinigt haben. Diese Regeln werden an einem zentralen Ort gespeichert und lassen sich zur Erstellung standardisierter XML-Nachrichten einsetzen, die zwischen Anwendungen innerhalb des Unternehmens sowie an Anwendungen der Partner eines Unternehmens versendet werden können. Von diesen XML-Nachrichten können große und kleine Unternehmen profitieren, weil sie dadurch mit einer größeren Gruppe von Partnern Geschäfte machen können.
3
XML leistet erheblich mehr, als nur Daten zu verschieben. So lassen sich Daten beispielsweise in ein XML-Dokument integrieren. Anschließend kann eine XSL-Seite (XSL – Extensible Stylesheet Language) mit dem XML-Dokument verknüpft werden, um die Daten in Microsoft Internet Explorer 5 präsentieren zu können (und hoffentlich in naher Zukunft auch in anderen Webbrowsern). Durch die Unterscheidung zwischen XML-Dokument und XSL-Seite können Webentwickler Daten und deren Darstellung trennen. Kapitel 2 untersucht, warum diese Technik für die Webentwicklung in Unternehmen wesentlich ist. Dank einer weiteren Initiative namens SOAP (SOAP – Simple Object Access Protocol) lässt sich XML einsetzen, um Methoden auf einem Remotecomputer im Internet aufzurufen, und zwar selbst durch eine Firewall hindurch. SOAP wurde von Developmentor, Microsoft und anderen ins Leben gerufen. Weitere Informationen finden Sie unter http://www.develop.com/ soap/. BizTalk, Internet Explorer 5 und SOAP adressieren drei der wichtigsten Themen, mit denen sich Unternehmen heutzutage auseinander setzen müssen: b Die Erstellung standardisierter Nachrichten, die in das Unternehmen hinein- und aus diesem hinausgelangen können (BizTalk) b Die Trennung von Daten und ihrer Darstellung bei der Erstellung von Webseiten (Internet Explorer 5) b Der Aufruf von Methoden durch Firewalls hindurch und zwischen unterschiedlichen Plattformen (SOAP) Das Hauptaugenmerk dieses Buches liegt auf den Features von XML und darauf, wie XML im Zusammenhang mit den drei genannten Themen genutzt werden kann.
Wissensarbeiter Ein DNS wird eingerichtet, um den Mitarbeitern die Informationen bereitzustellen, die sie benötigen, um ihre Arbeit zu erledigen. Diese Wissensarbeiter konzentrieren sich auf den Einsatz von Informationen, anhand derer Unternehmensentscheidungen getroffen werden. Im Idealfall sollten die meisten Mitarbeiter eines Unternehmens im nächsten Jahrzehnt zu Wissensarbeitern werden, während einförmige, sich wiederholende Tätigkeiten von Computern übernommen werden. Wissensarbeiter können aus folgenden Bereichen stammen: b Manager, die Daten betrachten, um Unternehmensentscheidungen zu fällen b Analysten, die detaillierte Berichte über den Zustand des Unternehmens anfertigen b Mitarbeiter, die Bestellungen entgegennehmen und Kunden bei der Auswahl von Produkten behilflich sind b Mitarbeiter, die Dokumente erstellen, deren Inhalte wertvoll für das Unternehmen sind, wie z. B. Projektentwürfe, Projektzeitpläne und E-Mails Um ihre Arbeit erledigen zu können, benötigen diese Wissensarbeiter Zugriff auf die Menge an Informationen, die auf den Computern innerhalb und außerhalb des Unternehmens gespeichert sind. In der Regel erfolgt der Zugriff auf diese Informationen über das Intranet oder Internet, wobei ein Web-Arbeitsstil entsteht. In den ersten zehn Jahren des einundzwanzigsten Jahrhunderts werden wir eine Revolution miterleben: Unternehmen werden DNSs einrichten, um Informationen, die für Wissensarbeiter wichtig sind, verwalten, freigeben und benutzen zu können.
4
Kapitel 1
Das DNS-Geschäftsmodell Das DNS unterstützt und verbindet die vier Grundfunktionen eines Unternehmens: b Grundlegende Geschäftsabläufe Zu den grundlegenden Geschäftsabläufen gehören das Rechnungswesen, die Auftragsannahme, der Einkauf, die Lagerhaltung, das Personalwesen usw. Der Großteil der Anwendungen in Unternehmen dient dazu, diese grundlegenden Geschäftsabläufe abzuwickeln. b Strategisches Denken Beim strategischen Denken geht es um langfristige Gewinne, Wachstumsvorhersagen, Marketingstrategien, Vertriebsanalysen, die Ausrichtung des Unternehmens, die Vision und den Geltungsbereich von Projekten, mit denen das DNS eingerichtet wird, usw. b Interaktion mit Kunden Die Interaktion mit Kunden beinhaltet alles, was mit Kundenkontakt zu tun hat, wie z. B. das Feedback von Kunden, die Analyse der Kundenzufriedenheit etc. b Reaktionsfähigkeit des Unternehmens Die Reaktionsfähigkeit des Unternehmens gibt an, wie schnell ein Unternehmen auf schlechte Nachrichten reagieren und die Situation in den Griff bekommen kann. Defizite in der Produktion oder Bestandshaltung sowie Überproduktion, Probleme bei der Erreichung von Zielvorgaben usw. müssen die entsprechenden Wissensarbeiter schnell erreichen. Das DNS steht im Zentrum der Unternehmensfunktionen. Alle Informationen können durch das DNS fließen. Der schwierigste Teil beim Einrichten eines solchen Systems besteht darin, etwas bereitzustellen, mit dem Nachrichten das DNS durchlaufen können. Wie bereits erwähnt, eignet sich XML für diese Aufgabe. Hinter DNS verbirgt sich die Vision, dass die digitale Speicherung, der Abruf und die Bereitstellung von Informationen die Effizienz und Reaktionsfähigkeit von Unternehmen gewaltig verbessern werden, die dieses Werkzeug korrekt einsetzen. Die Rolle, die das DNS bei der Verbindung dieser Unternehmensfunktionen übernimmt, wird in Abbildung 1.1 veranschaulicht. Visual Studio-Anwendungen, Internet Explorer 5, Microsoft Office
Reaktionsfähigkeit des Unternehmens
XML
XML
Windows NT Windows 2000 Server
SQL Server 7-Datenbank SQL Server 7Data Warehouse
DNS
BackOffice
XML
Visual Studio-Anwendungen Internet Explorer 5 Microsoft Office
Grundleg. Geschäftsabläufe
XML
Microsoft Office
Strateg. Denken
IIS, Site Server
Interaktion mit Kunden Internet Explorer 5 Visual Studio-Anwendungen
XML im Unternehmen
PivotTableDienste
Abbildung 1.1: Microsoft-Produkte, die die vier Unternehmensfunktionen und das DNS unterstützen
5
Wie die Abbildung zeigt, werden alle Unternehmensfunktionen und das DNS durch MicrosoftProdukte unterstützt. Das Herz der DNS bilden die Microsoft-Serverprodukte Microsoft BackOffice, SQL Server 7, Internet-Informationsdienste (IIS), Site Server, Microsoft Windows NT etc. Alle Unternehmensfunktionen lassen sich über das DNS mit diesen Serverprodukten verbinden. Site Server wird irgendwann durch Business Server ersetzt werden. Falls Mainframesysteme unterstützt werden müssen, lässt sich auch Microsoft SNA Server in das DNS integrieren. Eine neuere Version von SNA Server, die in Kürze verfügbar sein wird, sowie Business Server basieren beide auf XML. Neuere Versionen von IIS und SQL Server 7.5 werden ebenfalls mit XMLFunktionen ausgestattet sein. Somit wird XML zu einem wesentlichen Element in jedem Teil des DNS.
Ziele des DNS Das DNS soll nun etwas genauer betrachtet werden. Das Hauptzielt des DNS besteht darin, kritische Informationen rechtzeitig am richtigen Ort bereitzustellen. Dazu muss das DNS folgende Aufgaben erfüllen: b Skalierbarkeit gewährleisten b Die Erstellung von Microsoft Windows DNA-Systemen (DNA – Distributed interNet Application Architecture) ermöglichen b Die Benutzung des Internets erleichtern b Ein »Unternehmensgedächtnis« bilden b Papierformulare überflüssig machen b Selbstbedienungsanwendungen ermöglichen, die es Benutzern gestatten, Aufgaben unabhängig auszuführen b Das Feedback von Kunden aufzeichnen b Die Kommunikation mit Geschäftspartnern ermöglichen b Auf Krisen reagieren Die genannten Themen werden in den folgenden Abschnitten ausführlich beschrieben.
Skalierbarkeit gewährleisten Zu den grundsätzlichen Gegebenheiten gehört heutzutage die Tatsache, dass sich alles sehr schnell ändert. Ein System, das heutzutage nur 10 000 Benutzer unterstützt, muss morgen möglicherweise 100 000 Benutzer unterstützen. Jedes DNS muss skalierbar sein und die Skalierbarkeit ist einer der wichtigsten Faktoren bei der Erstellung eines effektiven DNS. Skalierbarkeit lässt sich sowohl über Hardware- als auch über Softwarelösungen erreichen. Es werden zwar auch Hardwarelösungen kurz beschrieben, dieses Kapitel und auch das gesamte Buch konzentriert sich jedoch auf die Softwarelösungen. Hardwarelösungen Intel und Microsoft entwickeln Produkte, die eine wesentlich höhere Kapazität durch schnellere Prozessoren, mehr Arbeitsspeicher, mehr geclusterte Computer und mehrere Prozessoren unterstützen. Microsofts Vision besteht darin, Skalierbarkeit über Cluster aus kleineren Computern
6
Kapitel 1
zu unterstützen, die über Software kooperieren. Diese Cluster bieten Redundanz und Skalierbarkeit und bieten eine Alternative zu monolithischen Mainframesystemen. Mit Windows 2000 lassen sich PCs mit 32 Prozessoren in einem Cluster aus bis zu vier PCs einsetzen. Softwarelösungen Windows DNA bietet ein Gerüst für das Design, die Erstellung und Wiederverwendung von Softwarekomponenten, mit dem sich ein DNS einrichten lässt, das aus einem großen, verteilten System besteht. Windows DNA-Systeme sind verteilt, weil sie Komponenten enthalten können, die sich an einer beliebigen Stelle im Unternehmen befinden – d. h. auf einem Clientcomputer, in einem Web, einer Datenbank, einem Server der mittleren Schicht, einem Mainframe-Computer oder jedem anderen Computer im Unternehmen. Die XML-Erweiterungen, die in BizTalk vorgeschlagen werden, sollen dazu dienen, die Grenzen zu überwinden, die momentan zu den Extranets bestehen. Extranets sind Netzwerke, die aus Computersystemen von zwei verschiedenen Unternehmen gebildet werden. Normalerweise sind diese Unternehmen Geschäftspartner. Dank BizTalk können Informationen in einem standardisierten Format durch das Extranet fließen. Die XML-Erweiterungen, die in SOAP vorgeschlagen werden, werden entwickelt, um Kommunikationsprobleme zwischen den Plattformen zu lösen (UNIX, Windows etc.). SOAP adressiert auch die Schwierigkeit, Methoden durch eine Firewall über XML und HTTP (HTTP – Hypertext Transfer Protocol) aufzurufen, um Nachrichten an die Methoden hinter der Firewall zu übergeben. Die Kombination aus XML und Internet gestattet es, dass die physischen Standorte der verschiedenen Elemente eines Windows DNA-Systems den gesamten Globus umspannen. Die Windows DNA-Systeme, die das Internet und XML nutzen, können Nachrichten über nationale Grenzen innerhalb und außerhalb von Unternehmen versenden. Diese Windows DNA-Systeme lassen sich mit COM-Komponenten (COM – Component Object Model) erstellen wie denjenigen, die in Microsoft Visual Studio in C++, Microsoft Visual Basic oder Java, ASP-Seiten und Webbrowsern wie Internet Explorer 5 enthalten sind. Sie werden von der gesamten Bandbreite der Microsoft-Software wie BackOffice, Office, Exchange Server, Site Server, SQL Server 7 etc. unterstützt. Microsoft bietet im Wesentlichen alle Produkte, mit denen sich Lösungen erstellen lassen, die an die Bedürfnisse der einzelnen Unternehmen angepasst sind.
Die Erstellung von Microsoft Windows DNA-Systemen ermöglichen Ein Windows DNA-System lässt sich nicht ohne Weitblick und Planung einrichten. Damit das System korrekt funktioniert, müssen Sie sicherstellen, dass alle Komponenten zusammenarbeiten können. Viele Systemkomponenten werden von anderen Komponenten abhängen, die Dienste für sie ausführen. Jede Komponente kann mit Methoden und Eigenschaften verknüpft sein. Die Methoden sind Dienste, die die Komponente ausführt, und die Eigenschaften sind die Attribute der Komponente. Angenommen, es gibt eine Komponente namens DataServices, die direkt mit der Datenbank kommuniziert und alle Erstellen-, Lesen-, Aktualisieren- und Löschen-Dienste der Datenbank ausführt. Die Komponenten DataServices ist dann mit den Methoden Erstellen, Lesen, Aktualisieren und Löschen ausgestattet. Eine weitere Komponente namens UserServices interagiert
XML im Unternehmen
7
mit dem Benutzer. Die Komponente gestattet es dem Benutzer, Datensätze in der Datenbank zu betrachten, zu aktualisieren, zur Datenbank hinzuzufügen und aus dieser über die Komponente DataServices zu löschen. Eng verbundene Systeme Momentan wird ein System, dessen Komponenten voneinander abhängen, in der Regel so eingerichtet, dass alle Komponenten zusammenhängen und die Methoden und Eigenschaften der anderen Komponenten direkt aufrufen. Im Beispiel fordert der Benutzer einen Dienst von der Komponente UserServices an, die wiederum direkt eine Anforderung an die Komponente DataServices sendet, die den Dienst dann ausführt. Abbildung 1.2 veranschaulicht den Prozess einer Anforderung, einen Datensatz zu aktualisieren.
Aktualisierung anfordern
Benutzerdienstekomponente
Methode Aktualisieren aufrufen
Benutzer
Datendienstekomponente
Daten aktualisieren
Datenbank
Abbildung 1.2: Die Anforderung der Aktualisierung eines Datensatzes in einem eng verbundenen System
Wie Sie sehen, wird die Komponente UserServices so programmiert, dass sie die Methode Aktualisieren der Komponente DataServices aufruft. Um die Methode Aktualisieren zu verändern, muss auch der Code in der Komponente UserServices angepasst werden. Dies wird als eng verbundenes System bezeichnet, da die einzelnen Komponenten des Systems direkt voneinander abhängen. Bei dieser Art von System müssen alle Komponenten gleichzeitig entworfen werden. Die Komponente UserServices kann zwar zuerst erstellt werden, es muss jedoch bekannt sein, welche Methoden die Komponente DataServices enthalten wird. Dies bedeutet, dass die Komponenten DataServices gleichzeitig mit der Komponente UserServices erstellt werden muss. Wenn ein Windows DNA-System eingerichtet wird, das ein gesamtes Unternehmen mit mehreren Hundert Komponenten umfasst, ist es fast unmöglich, alle Komponenten gleichzeitig zu erstellen. Kommt noch die Möglichkeit hinzu, mit Komponenten außerhalb des Systems über Extranets zu kommunizieren, sind eng verbundene Komponenten nicht mehr möglich. Normalerweise verfügen Unternehmen über mehrere eng verbundene Systeme. Diese müssen nicht immer ersetzt werden. Manchmal reicht es aus, neuere Komponenten einzuführen, die mit den älteren Komponenten kommunizieren können. Eng verbundene Komponenten sind beispielsweise für Systeme geeignet, die nur aus wenigen Komponenten bestehen. Mit XML und SOAP lassen sich eng verbundene Systeme einrichten und erweitern. Dank SOAP kann eine Komponente die Methoden einer anderen Komponente über XML und HTTP aufrufen oder die Eigenschaften festlegen. Flexibel verbundene Systeme Um die Probleme zu lösen, die bei eng verbundenen Systemen auftreten, ist ein Umdenken erforderlich. Die Komponenten müssen in der Lage sein, Dienste anzufordern, ohne vorher zu wissen, welche Komponente den Dienst tatsächlich ausführen wird. Das heißt, es muss ein flexibel verbundenes System entstehen. Die Anforderung eines Dienstes kann als Nachricht betrachtet werden. Wenn eine Komponenten einen Dienst anfordert, sendet sie eine Nachricht an eine andere Komponente, in der sie
8
Kapitel 1
angibt, was die andere Komponente tun soll. Die Anforderung eines Dienstes kann auch zusätzliche Informationen enthalten, die benötigt werden, um den Dienst auszuführen (wie z. B. die ID des Datensatzes, der aktualisiert werden soll, oder die aktualisierten Werte für den Datensatz). Um einen Dienst in einem flexibel verbundenen System anzufordern, muss eine Komponente die Anforderung in eine Nachricht packen, die an eine Nachrichtenkomponente übergeben wird. Die Nachrichtenkomponente ist dann dafür verantwortlich, den Nachrichtentyp herauszufinden und festzustellen, welche Komponente die Dienste anbietet, die mit der Nachricht verknüpft sind. Die Aktualisierungsanforderung sieht ähnlich wie in Abbildung 1.3 aus.
Aktualisierung anfordern
Benutzerdienstekomponente
Aktualisierungsnachricht erstellen und an MessagingKomponente senden
MessagingKomponente
Aktualisierungsnachricht weiterleiten
Benutzer
Datendienstekomponente
Daten für Aktualisierung
Datenbank
Abbildung 1.3: Anforderung für die Aktualisierung eines Datensatzes in einem flexibel verbundenen System
In einem flexibel verbundenen System benötigt die Komponente UserServices keine Informationen über die Komponente DataServices; sie muss nur das Format der Aktualisierungsnachricht kennen. Die DataServices-Komponente und seine Schnittstelle können vollständig und wiederholt umprogrammiert werden, ohne dass dafür die UserServices-Komponente verändert werden müsste, solange die DataServices-Komponente dasselbe Nachrichtenformat verwendet. Ausgehend von diesem Beispiel nehmen Sie nun einmal an, es gäbe zwei Unternehmen, das Unternehmen A und sein Partner, das Unternehmen B. Wie Sie in Abbildung 1.3 sehen, ist es möglich, dass die UserServices-Komponente in Unternehmen A ausgeführt wird und die DataServices-Komponente in Unternehmen B. Die Unternehmen müssen sich nicht darum kümmern, welche Plattformen im anderen Unternehmen verwendet werden oder wie die Komponenten im anderen Unternehmen im Einzelnen aussehen. So lange die beiden Unternehmen sich auf ein Standardformat für Nachrichten einigen können, sind sie in der Lage, Dienste von anderen Systemen anzufordern. Bei BizTalk geht es in erster Linie um die Erstellung dieser Standardformate für Nachrichten, die bei der B2B-Kommunikation (B2B – Business-to-Business) eingesetzt werden. Somit gestattet BizTalk es, umfangreiche Windows DNA-Systeme einzurichten, die sowohl das interne DNS für die Wissensarbeiter des Unternehmens als auch das Extranet der Geschäftspartner unterstützt.
Die Internetnutzung erleichtern Das Internet hat alles verändert. Inzwischen machen fast alle Unternehmen über das Internet Geschäfte. Die Anzahl Surfer im Internet hat gigantische Proportionen erreicht. Der Einsatz des Internets für Wissenschaft, Handel, den Download von Software etc. hat einen neuen Web-Lifestyle erzeugt. Unternehmen müssen jedoch zukünftig mehr leisten als einfach nur eine Website zusammenzustellen. Die Konsumenten und Geschäftspartner erwarten ausgereifte, leicht zu bedienende
XML im Unternehmen
9
Sites, die ihre Bedürfnisse erfüllen. Das Internet erzeugt völlig neue Märkte und erlaubt es auch kleinen Unternehmen, bei den ganz Großen mitzuspielen. Dieser Wettbewerb kann sehr hart sein, wie man an Unternehmen wie Amazon.com und Buch.de sieht. Die technologischen Änderungen werden die Art und Weise beeinflussen, in der Websites erzeugt und präsentiert werden. Unternehmen werden Sites entwickeln müssen, die aktuelle Trends und Technologien widerspiegeln, wenn sie nicht Gefahr laufen wollen, alles an ihre Konkurrenten zu verlieren. Der Backbone eines erfolgreichen DNS wird ein Intranet, das Internet oder beides sein. XML kann eingesetzt werden, um Daten mit dem Protokoll HTTP über das Internet zu verschicken. Mit SOAP lassen sich über HTTP sogar Methoden aufrufen.
Ein »Unternehmensgedächtnis« einrichten Der Begriff Unternehmensgedächtnis bezieht sich darauf, wie das Unternehmen als Ganzes von bisherigen Problemen und Lösungen lernt. Um ein Unternehmensgedächtnis zu erzeugen, müssen Dokumentationen, Speicherplatz, eine Organisation und der Abruf dieser Lösungen eingerichtet werden, sodass alle Mitarbeiter des Unternehmens auf das gleiche Wissen zugreifen und nicht »das Rad neu erfinden« müssen. Im Idealfall sollten Manager die korrekte Information innerhalb einer Minute finden und auf diese zugreifen können. Solche Manager werden als Ein-Minuten-Manager bezeichnet. Möglicherweise kann dieses Ziel momentan nicht erreicht werden. Es sollte aber das Ziel der Windows DNA-Systeme bleiben, die heutzutage entwickelt werden. XML kann zur Übersetzung von Daten in ein Standardformat und zur Übertragung der Daten über das DNS verwendet werden. Ein Standardformat erlaubt die Behandlung einer Bandbreite an Informationsformaten, die von E-Mail-Dokumenten bis zu Datenbankfeldern reichen, als eine Einheit.
Papierformulare eliminieren Der Einsatz von Papierformularen ist im Vergleich zu elektronischen Medien bei der Speicherung und Analyse von Unternehmensinformationen ineffizient. Werden die Informationen elektronisch gespeichert, lassen sie sich effizient durchsuchen und im Unternehmen gemeinsam nutzen. Außerdem lassen sich elektronische Daten in das XML-Format packen und zwischen Unternehmen transportieren. Im Idealfall sollten sich alle Formulare innerhalb von drei Minuten ausfüllen lassen. Dies wird als »weichgekochtes Ei«-Regel bezeichnet.
Selbstbedienungsanwendungen entwickeln In vielen Unternehmen wird ein Großteil der Personalressourcen für die Bearbeitung von Routineanforderungen wie die Angabe des Bestellstatus, die Beantwortung von einfachen Fragen, die Mitarbeiterinformation etc. eingesetzt. Ein wesentlicher Bestandteil des DNS stellt Internetund Intranet-Sites bereit, über die Benutzer die Dienste ohne die Hilfe von Mitarbeitern des Unternehmens nutzen können. Über gut gestaltete Sites können die Benutzer schnell und leicht auf die gewünschten Informationen zugreifen. Die Mitarbeiter des Unternehmens können dann für wichtigere Aufgaben eingesetzt werden. Die Informationen, die vom und an den Benutzer gesendet werden, lassen sich mit XML packen und zustellen.
10
Kapitel 1
Das Feedback von Kunden aufzeichnen Die Marketingabteilungen der Unternehmen benötigen ausführliche Informationen über die Kunden. Normalerweise werden Umfragen, Verkaufsanalysen und Marketingergebnisse von Drittanbietern eingesetzt, um Informationen über aktuelle und zukünftige Kunden zu sammeln. Die heutigen Technologien erlauben eine ausführliche Analyse der Benutzung von Websites, die detaillierte Informationen über das Kaufverhalten und die Bedürfnisse von Kunden, den Erfolg von Verkaufsunterstützungsaktionen und Ähnlichem. Außerdem können die Benutzer dem Unternehmen direktes Feedback durch die Anpassung der Navigation der Website oder über Umfrageformulare bieten. Die Informationen, die aus solchen Formularen stammen, lassen sich mit XML in ein Standard-BizTalk-Format umwandeln, das von der Marketingabteilung des Unternehmens leicht analysiert werden kann. Websites werden in einem iterativen Prozess erstellt. Jede neue Iteration basiert auf der sorgfältigen Analyse vorheriger Schritte. Auf diese Weise werden Websites und die Definition der Kundenbedürfnisse konstant verfeinert und aktualisiert, wenn sich die Bedürfnisse der Kunden verändern und neue Technologien verfügbar werden.
B2B-Kommunikation bereitstellen Extranets eignen sich hervorragend, um Informationen zwischen Geschäftspartnern auszutauschen. Kritische Informationen, die von beiden Geschäftspartnern genutzt werden müssen, lassen sich leicht durch ein DNS übertragen, das sich über die Unternehmensgrenzen hinweg erstreckt. XML und BizTalk bieten eine funktionsfähige Lösung für diese Nachrichtenübertragung. Die Einrichtung von fortschrittlichen Echtzeittransaktionen zwischen Unternehmen, die mittels XML über Extranets übertragen werden, ermöglicht die Just-in-Time-Zustellung (JIT) von Waren.
Auf Krisen reagieren Der rasche Fluss kritischer Geschäftsinformationen, der es den Wissensarbeitern gestattet, kritische Entscheidungen zu treffen, wird für den Erfolg jedes Unternehmens wesentlich sein. Alle ereignisgesteuerten DNS bieten eine Leitung, durch die Geschäftsereignisse im DNS veröffentlicht werden können. Diejenigen, die an bestimmten Arten von Ereignissen interessiert sind, können diese abonnieren und werden automatisch benachrichtigt, sobald die Ereignisse auftreten. Auch hier kann XML eingesetzt werden, um die Nachrichten zu packen, die veröffentlicht werden.
XML im Unternehmen
11
2 14 15 18 20
Auszeichnungssprachen
SGML HTML XML Zusammenfassung
Wie Sie in Kapitel 1 gesehen haben, wird XML zu einem wesentlichen Teil des DNS (Digital Nervous System) eines Unternehmens. Microsofts Hauptaugenmerk liegt auf drei Zielen, die mit XML erreicht werden sollen: die Erstellung von Nachrichten in einem Standardformat (mit BizTalk), die Trennung von Daten und ihrer Darstellung bei der Erstellung von Webseiten (mit Microsoft Internet Explorer 5) und der Aufruf von Methoden durch Firewalls hindurch und über verschiedene Plattformen hinweg (mit dem Simple Object Access Protocol, SOAP). In diesem Kapitel wird untersucht, warum sich XML dafür besser als andere Auszeichnungssprachen wie z. B. HTML oder SGML eignet. Eine Auszeichnungssprache verwendet eine spezielle Notation, um die verschiedenen Bestandteile eines Dokuments zu kennzeichnen. In einem HTML-Dokument dienen beispielsweise spitze Klammern () dazu, die unterschiedlichen Textteile zu kennzeichnen. In anderen Arten von Dokumenten gibt es beispielsweise durch Kommas getrennten Text, wobei die Kommas als Sonderzeichen benutzt werden. Text lässt sich sogar mit Binärcode auszeichnen. Diese Methode kommt in Microsoft Office-Dokumenten zum Einsatz. Softwareentwickler können für jede Auszeichnungssprache eine Anwendung entwickeln, die Dokumente lesen kann, die in der Auszeichnungssprache geschrieben wurden. Webbrowser lesen beispielsweise HTML-Dokumente und Microsoft Office-Anwendungen lesen Office-Dokumente. XML-Dokumente können von Spezialanwendungen gelesen werden, die verschiedene Parsingobjekte nutzen, oder sie lassen sich in Kombination mit XSL (XSL – Extensible Stylesheet Language) in einem Webbrowser anzeigen. Dokumente, die mit einer Auszeichnungssprache erstellt werden, bestehen aus Auszeichnungen und Text. Die Auszeichnungen definieren die Art und Weise, in der der Text von einer Anwendung, die das Dokument liest, interpretiert werden sollte. In HTML enthält der Text Einführung beispielsweise die Auszeichnungen und und den Text Einführung. Wenn der Text von einer HTML-Anwendung wie einem Webbrowser gelesen wird, teilen die Auszeichnungen der Anwendung mit, dass der Text Einführung im Stil h1 (Überschrift 1) dargestellt werden sollen.
13
Wenn Sie eine Auszeichnungssprache benutzen, sollten Sie die folgenden drei Elemente berücksichtigen: b Die Auszeichnungssprache, die die Auszeichnungen definiert b Das Dokument, das die Auszeichnungssprache verwendet und aus Auszeichnungen und Text besteht b Das interpretierte Dokument, das von einer Anwendung gelesen und interpretiert wurde In XML ist die Auszeichnungssprache das einzige vordefinierte Element. Die Entwickler von XML-Dokumenten definieren die Struktur des Dokuments und die Auszeichnungen selbst. Dank dieses Merkmals ist XML flexibel und gestattet es, dass die Daten in einem interpretierten Dokument für die unterschiedlichsten Zwecke eingesetzt werden. Die formatierten Daten in einem XML-Dokument können beispielsweise geparst und dann angezeigt, in einer Datenbank abgelegt oder von einer anderen Anwendung benutzt werden. Dieses Kapitel beschreibt die drei Auszeichnungssprachen XML, HTML und SGML, wobei zunächst SGML als übergeordnete Sprache von HTML und XML beschrieben wird.
SGML Wie bereits erwähnt, lässt sich ein Microsoft Office-Dokument auch als Dokument betrachten, das mit einer Art Auszeichnungssprache erstellt wurde. Microsoft Office-Dokumente können jedoch nur von Microsoft Office-Anwendungen oder Anwendungen gelesen werden, die Microsoft Office-Dokumente konvertieren können. Somit sind Microsoft Office-Dokumente von einer bestimmten Anwendung abhängig und lassen sich nur von den Personen gemeinsam nutzen, die über Microsoft Office oder einen passenden Konverter verfügen. Weil Unternehmen Daten für eine große Anzahl an Partnern, Kunden und Abteilungen innerhalb des Unternehmens freigeben müssen, benötigen sie anwendungsunabhängige Dokumente. SGML wurde für diesen Bedarf entwickelt und ist eine Auszeichnungssprache, die vollkommen unabhängig von jeder Anwendung ist. SGML verwendet eine Dokumenttypdefinition (DTD) zur Definition der Dokumentstruktur. Die DTD legt die Elemente und Attribute fest, die im Dokument verwendet werden dürfen, und gibt an, welche Zeichen zur Auszeichnung des Textes benutzt werden. In SGML können spitze Klammern (), Gedankenstriche (–) oder auch andere Zeichen eingesetzt werden, um ein Dokument auszuzeichnen. Es muss lediglich gewährleistet sein, dass das Sonderzeichen in der DTD korrekt definiert ist. SGML gibt es bereits seit mehr als einem Jahrzehnt und die Sprache ist älter als das Web. SGML ist eine Metasprache, die entwickelt wurde, um Datenspeicher mit strukturierter Dokumentation in elektronischem Format unterhalten zu können. Als Metasprache beschreibt SGML die Dokumentstrukturen für andere Auszeichnunssprachen wie auch für XML oder HTML. HTML und XML können folglich als Anwendungen von SGML bezeichnet werden. SGML ist eine extrem vielseitige und leistungsfähige Sprache. Leider haben diese Merkmale auch ihren Preis: Die Anwendung von SGML ist schwierig. Die Schulung von Mitarbeitern für den Einsatz von SGML-Dokumenten und die Erstellung von Anwendungen, die SGML-Dokumente erzeugen, beansprucht sehr viel Zeit und Energie. Deshalb eignet sich SGML nicht für die Webentwicklung. Die Spezifikation von SGML ist über 500 Seiten lang und enthält zusätzliche mehr als 100 Seiten mit Anhängen. Die Spezifikation ist sehr komplex und auf große, komplexe Systeme ausgerichtet. Um die drei Ziele standardisierte Nachrichten, Trennung und
14
Kapitel 2
von Daten und ihrer Darstellung sowie den Aufruf von Methoden zu erreichen, wäre der Einsatz von SGML eine Übertreibung.
HTML Inzwischen ist fast jeder Computerbenutzer mit HTML vertraut. HTML ist eine ziemlich einfache Sprache, dank derer sich das Internet so weit verbreiten konnte. Seit seiner Einführung als Möglichkeit für Wissenschaftler, Dokumente gemeinsam zu nutzen, hat HTML einen weiten Weg zurückgelegt. Dieser wird nun aufgezeigt.
Das frühe HTML Ursprünglich sollte HTML Elemente beinhalten, anhand derer sich der Inhalt entsprechend seiner Bedeutung auszeichnen ließ. Tags wie , , etc. dienten zur Repräsentation des Inhalts eines HTML-Dokuments. Die eigentliche Interpretation und Anzeige sollte von den Einstellungen des Webbrowsers abhängen. Rein theoretisch sollten alle Webbrowser mit denselben Einstellungen HTML-Dokumente auf dieselbe Weise anzeigen. Diese Flexibilität sollte Benutzern mit einem speziellen Bedarf oder spezifischen Vorlieben die Möglichkeit bieten, ihre Webbrowser so anzupassen, dass die HTML-Seiten im bevorzugten Format angezeigt werden – ein Merkmal, das besonders für Personen mit einer Sehbehinderung und Benutzer älterer Webbrowser von Vorteil ist. In diesem Szenario benutzten die HTML-Entwickler Tags auf der Basis eines HTML-Standards, die dann entsprechend der Einstellungen des Benutzers angezeigt wurden. Damit dies funktioniert, musste es einen Standard für HTML geben. Den aktuellen Webstandard finden Sie unter http://www.w3.org.
Probleme bei HTML HTML war während der anfänglichen Entwicklung des Internets eine großartige Sprache. Inzwischen ist jedoch der Bedarf für eine Sprache entstanden, die sich für komplexere und umfassendere Zwecke einsetzen lässt, wie z. B. Unternehmensfunktionen, und HTML kann dies nicht leisten. Es werden nun einige Probleme beschrieben, die im Zusammenhang mit HTML auftreten. Widerstreitende Standards 1994 entwarf Netscape einige HTML-Erweiterungen, die nur von Netscapes Webbrowsern interpretiert werden konnten. Dies war der Anfang des Browserkriegs und sein erstes Opfer war der HTML-Standard. Dank der Erweiterungen konnten Entwickler nun die Schriftgröße, die Schrift- und Hintergrundfarbe und andere Merkmale festlegen. Selbstverständlich wurden die Erweiterungen jedoch nur in Netscape-Browsern korrekt angezeigt. Die HTML-Erweiterungen waren so populär, dass Netscape 1996 der führende Browser war. Netscape hatte zwar einen großen Sieg errungen, für Webentwickler und -benutzer bedeutete dies jedoch einen Verlust. Neben dem Problem der Behandlung der nichtstandardisierten Erweiterungen gab es auch noch die Schwierigkeit, dass die verschiedenen Browser Standard-Tags auf unterschiedliche Weise behandelten. Dies bedeutete, dass die Webentwickler unterschied-
Auszeichnungssprachen
15
liche Versionen eines HTML-Dokuments für die verschiedenen Browser entwickeln mussten. Die Erweiterungen zwangen die Benutzer dazu, Seiten zu akzeptieren, die nach den Wünschen des Autors formatiert waren. HINWEIS In den meisten Browsern lassen sich Standardeinstellungen festlegen, die die Einstellungen der HTML-Seiten überschreiben. Leider wissen die meisten Benutzer nicht, wie sie diese Einstellungen nutzen, und wenn eigene Standards eingerichtet werden, werden die meisten Seiten nicht korrekt angezeigt. Es ist schwierig und machmal auch unmöglich, HTML-Dokumente zu erzeugen, die in allen Browsern ungefähr gleich aussehen. Weitere Informationen zu diesem Thema finden Sie unter http://www.webstandards.org. HINWEIS Details zur HTML-Standardisierung liegen außerhalb des Rahmens dieses Buches. In der Site http://www.webstandards.org finden Sie jedoch die benötigten Informationen und Ressourcen. Keine internationale Unterstützung Durch das Internet ist eine globale Gemeinschaft entstanden und die Welt ist erheblich kleiner geworden. Unternehmen erweitern ihren Geschäftsbereich in diesem globalen Markt, finden neue Partner und erweitern ihre Unternehmen auf dem gesamten Globus, wobei alles über das Internet verknüpft ist. Es gab einige Vorschläge zu einem HTML-Standard, es konnte sich jedoch kein Standard ausbilden. Es gibt beispielsweise keine HTML-Tags, die festlegen, in welcher Sprache ein HTML-Dokument geschrieben wurde. Unzulängliche Verknüpfungssysteme Wenn Sie HTML-Dokumente erzeugen, werden die Links hart in das Dokument kodiert. Ändert sich ein Link, muss der Webentwickler alle HTML-Dokumente durchsuchen, um alle Verweise auf den Link zu finden und sie zu aktualisieren. Da Websites aber dynamisch sind und sich ständig entwickeln und wachsen, kann dieser Mangel des Verknüpfungssystems ein wesentliches Problem darstellen. Es besteht ein Bedarf für ein fortgeschrittenes Verknüpfungssystem, mit dem sich nicht nur Links mit jedem beliebigen Element verbinden lassen, sondern auch Links zu mehreren Orten einrichten lassen. Diese Möglichkeit bietet beispielsweise das Verknüpfungssystem in XML. In Kapitel 6 erfahren Sie mehr über diese XML-Funktion. Fehlerhafte Struktur und fehlerhafter Datenspeicher HTML beinhaltet zwar eine Struktur, diese ist jedoch ziemlich starr. So ist es beispielsweise möglich, Überschrift 3-Tags () vor Überschrift 1-Tags () zu setzen. Innerhalb des -Tags lässt sich jedes zulässige Tag nutzen. HTML-Dokumente lassen sich zwar überprüfen, es wird dabei jedoch nur bestätigt, dass die Tags korrekt eingesetzt wurden. Und, was noch schlimmer ist, der Browser versucht bei fehlendem Ende-Tag herauszufinden, wo die Tags stehen müssen, und fügt sie ein. Auf diese Weise kann fehlerhafter HTML-Code entstehen, der jedoch vom Browser trotzdem korrekt interpretiert wird. Ein weiteres Problem tritt auf, wenn versucht wird, Daten in einem HTML-Dokument unterzubringen. Dies ist ziemlich schwierig. Angenommen, es sollen Informationen aus einer Datenbank in einem HTML-Dokument untergebracht werden. Es gibt eine Datenbanktabelle namens Kunden mit den Feldern KundenID, Kundenname und Kundenadresse. Wird ein HTMLDokument mit diesen Daten erzeugt, benötigt jeder Kunde die Werte KundenID und Kunden-
16
Kapitel 2
name. Der Wert Kundenadresse ist optional. Die Daten könnten in HTML in einer Tabelle wie der folgenden dargestellt werden:
| Name | Adresse | ID |
|---|---|---|
| Peter Müller | Birkenstrasse 125, 12345 Musterhausen | 001 |
| Maria Meier | Bachstrasse 2, 12345 Musterhausen | 002 |
| Mark Schmitz | Bachstrasse 4, 12345 Musterhausen |
In einem Browser sieht die Tabelle wie in Abbildung 2.1 aus.
Abbildung 2.1: Eine Datenbanktabelle in HTML
Dieses Dokument enthält gültigen HTML-Code. Die Tabelle enthält keine Fehler, sie ist syntaktisch korrekt. Die Information in der Tabelle ist jedoch ungültig. So fehlt beim dritten Eintrag die ID. Es wäre zwar möglich, Anwendungen zu erstellen, die die Gültigkeit von Daten in HTML-Dokumenten überprüfen, solche Anwendungen sind aber komplex und ineffizient. HTML wurde nicht auf die Datenauswertung ausgelegt. HTML ist auch nicht auf die Speicherung von Daten ausgelegt. Daten werden in der Regel in HTML-Tabellen präsentiert und gespeichert. Mit -Tags lassen sich komplexere Strukturen
Auszeichnungssprachen
17
zur Speicherung von Daten einrichten. Auch hier stellt sich jedoch das Problem der Gültigkeitsüberprüfung der Daten. Es wird eine Möglichkeit benötigt, die Daten in einem strukturierten Format abzulegen, das automatisch auf syntaktische Korrektheit und Struktur des Inhalts überprüft werden kann. Im Idealfall definiert der Autor des Dokuments sowohl das Format des Dokuments als auch die korrekte Datenstruktur. Wie Sie in den Kapiteln 4 und 5 sehen werden, dienen dazu XML und DTDs.
XML 1996 begann das World Wide Web Consortium (W3C), eine neue Standardauszeichnungssprache zu entwickeln, die einfacher sein sollte als SGML, jedoch eine strengere Struktur als HTML aufweisen sollte. Das W3C richtete die XML-Arbeitsgruppe (XWG – XML Working Group) ein, die XML entwickeln sollte.
Die Ziele von XML Die Ziele von XML, die in der Version 1.0 der Spezifikation (http://www.w3.org/TR/WD-xmllang#sec1.1) aufgestellt wurden, werden nachfolgend zusammen mit einer Beschreibung dessen aufgeführt, wie gut die Ziele im aktuellen XML-Standard implementiert werden: b XML soll sich leicht über das Internet nutzen lassen Momentan unterstützen die meisten Webbroser, wie Internet Explorer 4 und Netscape Navigator 4, XML nur minimal. Internet Explorer 5 bietet eine erweiterte Unterstützung von XML, die den Einsatz von XSL-Seiten zur Darstellung von XML-Inhalt erlaubt. b XML soll ein großes Spektrum an Anwendungen unterstützen Mit der Einführung von BizTalk und SOAP wird ein größeres Spektrum von Anwendungen XML nutzen. Andere Anwendungen wie Lotus Domino verwenden XML ebenfalls. Es stehen nun zahlreiche Anwendungen zur Verfügung, um XML-Inhalte und DTDs zu betrachten und zu bearbeiten. b XML soll zu SGML kompatibel sein Momentan existieren bereits viele SGML-Anwendungen und SGML-Standardnachrichtenformate. Dadurch, dass XML zu SGML kompatibel ist, können diese SGML-Anwendungen wiederverwendet werden. Der Konvertierungsprozess kann zwar komplex sein, XML ist jedoch zu SGML kompatibel. b Es soll leicht sein, Programme zu schreiben, die XML-Dokumente verarbeiten Damit XML eine große Akzeptanz findet, müssen sich Anwendungen, die XML-Dokumente verarbeiten, leicht erstellen lassen. Wenn diese Anwendungen einfach sind, ist die Nutzung von XML kostengünstig. Die aktuelle Spezifikation erfüllt dieses Ziel, und zwar insbesondere dann, wenn Parser benutzt werden wie diejenigen, die von Microsoft und IBM angeboten werden. b Die Zahl der optionalen Features in XML muss minimal gehalten werden und im Idealfall gegen Null gehen Je mehr optionale Features es gibt, desto schwieriger ist die Benutzung von XML. Je komplexer eine Sprache ist, desto kostpieliger ist die Anwendungsentwicklung und desto unwahrscheinlicher ist es, dass sie benutzt wird. Der XML-Standard erfüllt dieses Ziel. b XML-Dokumente sollten für Menschen leicht zu lesen und zu interpretieren sein Im Idealfall sollte sich ein XML-Dokument in einem beliebigen Texteditor öffnen lassen, und es
18
Kapitel 2
sollte möglich sein, festzustellen, was das Dokument enthält. Grundkenntnisse von XML sollten ausreichen, um ein XML-Dokument lesen zu können. b Das XML-Design sollte sich schnell vorbereiten lassen Es ist wesentlich, dass der Standard sehr schnell fertig gestellt wird, sodass XML zur Lösung aktueller Probleme eingesetzt werden kann. b Das Design von XML sollte formal, kurz und prägnant sein Es ist sehr wichtig, dass Computeranwendungen XML lesen und parsen können. Wenn die Sprache formal, kurz und prägnant ist, lässt sie sich von Computeranwendungen leicht interpretieren. XML lässt sich in der Erweiterten Backus-Naur-Form (EBNF) ausdrücken, einer Notationsform für die Beschreibung der Syntax von Sprachen. EBNF lässt sich sehr leicht von einem Computerprogramm parsen. SGML lässt sich nicht in EBNF formulieren. Weitere Informationen zur EBNF finden Sie unter http://nwalsh.com/docs/articles/xml/index.html#EBNF. b XML-Dokumente sollten sich leicht erstellen lassen Es sind einige XML-Editoren erhältlich, mit denen sich XML-Dokumente leicht erstellen lassen. Diese Editoren werden in Kapitel 3 beschrieben. Sie können auch Ihren eigenen, benutzerdefinierten XML-Editor erzeugen. b Eine knappe Formulierung ist in XML nicht so wichtig Es ist nicht so wichtig, dass die XML-Auszeichnungen ganz knapp formuliert sind, als vielmehr der XML-Standard selbst. Wenn der Standard einen Satz akzeptabler Abkürzungen enthielte (wie dies bei SGML der Fall ist), in der Sprache selbst aber darauf verzichtet würde, wäre XML erheblich komplexer. XML erfüllt diese Anforderung erfolgreich. Diese Ziele sind darauf ausgerichtet, XML zum idealen Medium für die Erstellung von Webanwendungen zu machen. Zusätzlich eignet sich XML auch dafür, Standardnachrichten zu erzeugen und Nachrichten weiterzureichen, um Methoden aufzurufen. Vier Spezifikationen definieren XML und geben an, wie diese Ziele erreicht werden: b Die XML-Spezifikation definiert die XML-Syntax und steht unter der Adresse http://www. w3.org/TR/WD-xml-lang zur Verfügung. b Die XLL-Spezifikation definiert die Sprache XLL (Extensible Linking Language). Die Spezifikation ist unter der Adresse http://www.w3.org/TR/xlink erhältlich. b Die XSL-Spezifikation definiert XSL (Extensible Style Sheets). Sie steht unter der Adresse http://www.w3.org/TR/NOTE-XSL.html bereit. b Die XUA-Spezifikation definiert den XML User Agent. Diese Spezifikation wird einen XMLStandard im Stil von SOAP definieren, sie existiert jedoch noch nicht. Die aktuelle XML-Spezifikation ist nur 26 Seiten lang – im Gegensatz zur mehr als einhundert Seiten langen SGML-Spezifikation. XML ist ziemlich einfach und lässt sich dank BizTalk auch einsetzen, um Nachrichten in einem standardisierten Format zu erstellen. XML gestattet die Trennung von Inhalt und Darstellung in Form von XML-Dokumenten und XSL-Seiten. Mit SOAP lässt sich die Anforderung einer Methode auf einem Remoteserver in ein XML-Dokument packen, mit dem der Remoteserver die Methode dann aufrufen kann. Somit kann XML die drei Grundziele vollständig erfüllen.
Auszeichnungssprachen
19
Vorteile von XML Dank der folgenden Features eignet sich XML sehr gut, um ein Unternehmens-DNS einzurichten: b XML ist international XML basiert auf Unicode. Da Unicode mehr Speicherplatz für Zeichen bietet, lassen sich damit die Zeichen sämtlicher momentan bekannten Sprachen kodieren. SGML und HTML basieren auf ASCII, das nur Speicherplatz für sehr wenig Zeichen bietet und somit Alphabete wie Japanisch und Chinesisch ausschließt. b XML lässt sich strukturieren Mit DTDs lässt sich XML so strukturieren, dass sich sowohl der Inhalt als auch die Syntax leicht überprüfen lassen. Diese erweiterte Struktur erlaubt es, standardisierte gültige XML-Dokumente zu erstellen. b XML-Dokumente lassen sich zusammensetzen Dank der leistungsfähigen Verknüpfungsmethoden von XML lassen sich Dokumente aus anderen Dokumenten zusammensetzen. Dank dieses verbesserten Verknüpfungssystems können Dokumente nach Bedarf durch die Auswahl von Teilen aus anderen Dokumenten zusammengestellt werden. b XML kann als Datencontainer dienen XML eignet sich ideal als Container für Daten. Mit DTDs lassen sich fast alle Daten so darstellen, dass sie von Menschen, Computerparsern und Anwendungen gelesen werden können. b XML bietet Flexibilität Auf ein DTD kann entweder ganz verzichtet werden (es wird ein Standard-DTD benutzt) oder aber die Struktur eines Dokuments wird mittels eines DTD bis ins kleinste Detail definiert. Mit einem DTD lässt sich die genaue Struktur des Dokuments festlegen, sodass sich sowohl die Datenstruktur als auch der Inhalt leicht überprüfen lassen. b XML ist ganz einfach XML ist kaum komplizierter als HTML. Sobald mehr Browser XML unterstützen und weitere Tools für die Arbeit mit XML erhältlich sind, werden sehr wahrscheinlich auch mehr Entwickler XML nutzen. b XML bietet Standardformate Standardformate für XML-Dokumente lassen sich ganz einfach erstellen. Dank dieser Vorteile lassen sich mit XML komplexere Bedürfnisse von Unternehmen erfüllen.
Zusammenfassung Dank HTML konnte das World Wide Web entstehen. Seit dieses nun aber zu einem Zentrum für Handel und Informationen geworden ist und im Zentrum des Interesses von Geschäftsoperationen steht, erfüllt HTML die Anforderungen nicht mehr. Da Webbrowser keinen einheitlichen HTML-Standard benutzen, sich die Gültigkeit von HTML-Dokumenten nur schwer überprüfen lässt und die Unterstützung verschiedener internationaler Sprachen nur dürftig ist, stellt HTML für die Zukunft des Webs keine gute Wahl dar. SGML ist ein exzellentes, leistungsfähiges System für die Dokumentierung komplexer Systeme, ist jedoch für die Anforderungen des Webs leider viel zu komplex. XML eignet sich ideal als Sprache für die nächste Generation von Webanwendungen, für E-Commerce und für Unternehmens-DNSe. XML ist eine einfache, kleine Auszeichnungssprache, die sich leicht und flexibel einsetzen lässt. Außerdem lassen sich damit Dokumente in Sprachen erstellen, die nicht das arabische Alphabet nutzen, wie z. B. Japanisch oder Chinesisch. XML eignet sich ideal, um Daten zu speichern und Nachrichten zu versenden, und die Gültigkeit von XML-Dokumenten lässt sich überprüfen.
20
Kapitel 2
Zu dem Zeitpunkt, zu dem dieses Buch geschrieben wurde, war bereits ein großer Teil des XML-Standards fertig gestellt und er wird so für einige Zeit Bestand haben. Die Spezifikation XML 1.0, die die Syntax von XML und XML-DTDs definiert, erfährt eine hohe Akzeptanz und wird sich in naher Zukunft wohl kaum ändern. Andere Elemente von XML sind noch in Entwicklung, wie z. B. Schemas, die DTDs ähneln, und die XML Path Language (XPath), die ein Ersatz für einige XML-Verknüpfungsmechanismen ist, die momentan verwendet werden. In den nächsten Jahren wird XML weiter verfeinert und zu einem unglaublich leistungsfähigen Tool werden, dank dessen es die nächste Evolution des Internets geben wird. Dieses Buch stellt den aktuellen XML-Standard vor und bietet einen Ausblick auf die Zukunft von XML und darauf basierende Anwendungen.
Auszeichnungssprachen
21
3 24 27 29 38 42 43 45 46 46 48
Struktur eines XMLDokuments
Grundbestandteile eines XML-Dokuments Die Grundlagen von HTML Ein XML-Template für Webdokumente erstellen Eine Webhilfeseite einrichten Was haben Sie erreicht? Weitere XML-Editoren Kriterien für wohlgeformte XML-Dokumente Die XML-Deklaration hinzufügen Das fertige XML-Dokument Zusammenfassung
Die Struktur eines XML-Dokuments lässt sich mit zwei Standards definieren. Der erste ist die XML-Spezifikation, die die Regeln für die Erstellung aller XML-Dokumente festlegt. Die Spezifikation finden Sie in der Website http://www.w3.org/TR/1998/REC-xml-19980210. Alle XML-Dokumente, die die XML-Spezifikation erfüllen, werden als wohlgeformte XML-Dokumente bezeichnet. Ob ein XML-Dokument wohlgeformt ist, d. h. ob die Syntax korrekt ist, lässt sich überprüfen. Eine Regel besagt beispielsweise, dass jedes Element mit einem Tag beginnen und enden muss. Fehlt eines dieser Tags, ist das Dokument nicht wohlgeformt. Die Überprüfung kann von einer XML-kompatiblen Computeranwendung wie Microsoft Internet Explorer 5 durchgeführt werden. Der zweite Standard, der optional ist, wird vom Autor des Dokuments formuliert und in einer Dokumenttypdefinition (DTD) definiert. Wenn ein XML-Dokument die Regeln erfüllt, die in der DTD festgelegt werden, wird es als ein gültiges XML-Dokument bezeichnet. Die Gültigkeit von XML-Dokumenten lässt sich ebenfalls überprüfen. Wird z. B. ein XML-DTD erstellt, das die Anzahl der body-Elemente auf ein Vorkommen beschränkt, sind alle Dokumente, die es zweimal enthalten, ungültig. Somit können Anwendungen mit der DTD und den Regeln, die in der XML-Spezifikation enthalten sind, überprüfen, ob ein XML-Dokument wohlgeformt und gültig ist. Schemas sind DTDs sehr ähnlich, verwenden jedoch ein anderes Format. DTDs und Schemas sind nützlich, wenn mehrere Dokumente anhand eines Regelsatzes erstellt werden. Es können Programme geschrieben werden, die Dokumente erzeugen, die gemäß der DTD gültig und nach dem aktuellen XML-Standard wohlgeformt sind.
23
Viele Branchen produzieren momentan DTDs und Schemas. Diese Standards werden eingesetzt, um XML-Dokumente zu erzeugen, mit denen die Mitglieder der Branchen Informationen gemeinsam nutzen können. Ein Komittee einer medizinischen Vereinigung könnte beispielsweise die wesentlichen Informationen für einen Patienten festlegen und anhand dieser dann eine Patientendatensatz-DTD aufbauen. Um die Patienteninformationen zwischen medizinischen Einrichtungen auszutauschen, müssten Anwendungen existieren, die XML-Dokumente anhand der Patientendatensatz-DTD als Nachrichten erzeugen. Beim Empfang könnte eine solche XML-Patientennachricht dann anhand der Patientendatensatz-DTD verifiziert werden, d. h. es könnte überprüft werden, ob der Patientendatensatz alle benötigten Informationen enthält. Würde sich die XML-Patientennachricht als ungültig herausstellen, würde die Nachricht an den Absender zur Korrektur zurückgeschickt werden. Die Patientendatensatz-DTD und das Schema könnten an einem Ort gespeichert werden, der über das Internet zugänglich ist. Damit hätten alle medizinischen Einrichtungen die Möglichkeit, die Gültigkeit eingehender XMLDokumente zu überprüfen. Eines der Ziele von BizTalk ist es, eine Standardsammlung für Schemata zu schaffen. In diesem Kapitel wird beschrieben, wie ein XML-Dokument erstellt wird, mit dem sich Internetanwendungen aufbauen lassen. Im Idealfall sollte das XML-Dokument von einem XMLkompatiblen Browser als solches interpretiert werden, von einem nicht XML-kompatiblen, aber CSS-fähigen Browser als HTML-Dokument, das Stylesheets verwendet, und von einem Browser, der weder CSS noch XML erkennt, als reines HTML-Dokument. In erster Linie geht es hier um die Erstellung eines wohlgeformten Dokuments. Es wird ein Überblick über die Regeln gegeben, die ein wohlgeformtes Dokument erfüllen muss, und es wird ein wohlgeformtes Dokument erzeugt, mit dem XML über das Web in jedem HTML 4-kompatiblen Webbrowser angezeigt werden kann. In Kapitel 4 erfahren Sie dann, wie Sie eine DTD für dieses wohlgeformte Dokument einrichten, und in Kapitel 5 wird die DTD dann angepasst.
Grundbestandteile eines XML-Dokuments Ein XML-Dokument besteht aus Elementen, Attributen und Kommentaren. Um leichter zu verstehen, wie diese Bestandteile in einem XML-Dokument funktionieren, sollten Sie sie nun in Microsoft XML Notepad betrachten. XML Notepad ist im Microsoft Windows DNA XML Resource Kit enthalten, das Sie in Microsofts Website unter msdn.microsoft.com/vstudio/xml/default.asp und auf der CD-ROM zum Buch finden.
Elemente Die Abschnitte in einem XML-Dokument werden mit Elementen gekennzeichnet. Ein XMLDokument hat folgende Syntax: Inhalt
Der Inhalt steht zwischen den XML-Tags. XML-Tags umschließen zwar in der Regel Inhalt, dies ist aber nicht unbedingt erforderlich. Ohne Inhalt werden die XML-Tags als leere Elemente, d. h. Elemente ohne Inhalt, bezeichnet. In XML können leere Elemente wie folgt dargestellt werden:
24
Kapitel 3
HINWEIS Die XML-Notation wird als Singleton bezeichnet. In HTML wird das leere Tag wie folgt dargestellt . In einem XML-Dokument, das Patientendatensätze enthält, können beispielsweise PatientName, PatientAlter, PatientKrankheit und PatientGewicht Elemente des XML-Dokuments sein: Peter Müller 108 155
Das Element PatientName kennzeichnet den Inhalt Peter Müller als Name des Patienten, das Element PatientAlter markiert 108 als Alter des Patienten und PatientGewicht den Inhalt 155 als Gewicht des Patienten. Elemente stellen Informationen über den Inhalt des Dokuments bereit. Computeranwendungen können damit die einzelnen Inhaltsabschnitte identifizieren. Die Anwendung kann die Inhaltsabschnitte dann nach ihren Erfordernissen bearbeiten oder anderweitig nutzen. Im Fall des Dokuments mit den Patientendatensätzen könnten die Inhaltsabschnitte in die Felder eines neuen Datensatzes einer Patientendatenbank übernommen werden oder einem Benutzer über Textfelder in einem Webbrowser angezeigt werden. Die Elemente legen fest, in welche Felder oder Textfelder jeder Inhaltsabschnitt gehört. Der Inhalt, der mit dem Element PatientName gekennzeichnet ist, wird in das gleichnamige Feld in der Datenbank oder das Textfeld txtPName im Webbrowser übernommen. Mit Elementen lässt sich die Darstellung, die Speicherung und die Übertragung von Daten automatisieren. Verschachtelung von Elementen Elemente lassen sich auch verschachteln. So können beispielsweise alle Patienteninformationen unter einem Element Patient zusammengefasst werden. Das Patientendatenbeispiel ließe sich dann wie folgt formulieren:
Peter Müller 108 155
Bei der Verschachtelung von Elementen dürfen sich die Tags nicht überlappen. Das folgende Gebilde wäre nicht wohlgeformt, weil das Ende-Tag zwischen den Tags eines untergeordneten Elements steht:
Peter Müller 108 155
XML-Elemente können also andere Elemente enthalten. Die Elemente müssen jedoch korrekt verschachtelt sein, d. h. für jedes Start-Tag muss ein Ende-Tag existieren. Benennungskonventionen Elementnamen müssen den folgenden Regeln entsprechen: b Namen bestehen aus mindestens einem Zeichen. Leerzeichen sind dabei nicht zulässig. Wenn ein Name nur aus einem Zeichen besteht, muss es sich um einen Groß- (A–Z) oder einen Kleinbuchstaben (a–z) handeln.
Struktur eines XML-Dokuments
25
b Namen müssen immer mit einem Buchstaben oder einem Unterstrich (_) beginnen. b Nach dem ersten Zeichen kann ein beliebiges Zeichen verwendet werden, also auch ein Unicode-Zeichen (mehr zum Unicode-Standard finden Sie unter dem URL http://www.unicode.org/). b Bei Elementnamen wird die Groß-/Kleinschreibung berücksichtigt. PatientName, PATIENTNAME und patientname werden somit als unterschiedliche Elemente betrachtet. Die folgenden Elementnamen sind beispielsweise wohlgeformt: Fred _Fred Fredd123 FredGruß
Die folgenden Namen jedoch nicht: Fred 123 -Fred 123
Das erste nicht wohlgeformte Element enthält ein Leerzeichen, das zweite beginnt mit einem Gedankenstrich (–) und das dritte beginnt mit einer Zahl statt mit einem Buchstaben oder einem Unterstrich.
Attribute Ein Attribut ist ein Mechanismus, mit dem sich beschreibende Informationen zu einem Element hinzufügen lassen. Im XML-Dokument mit den Patientendatensätzen ist beispielsweise bisher nicht bekannt, ob das Gewicht in Pfund oder Kilo angegeben wird. Um deutlich zu machen, dass es sich um eine Angabe in Kilo handelt, wird ein Einheit-Attribut mit dem Wert kg ergänzt: 155
Attribute lassen sich nur in das Start-Tag integrieren und wie bei Elementen wird die Groß-/ Kleinschreibung unterschieden. Attributwerte müssen in doppelte Anführungszeichen (") gesetzt werden. Attribute können auch im Zusammenhang mit leeren Elementen eingesetzt werden, wie im folgenden wohlgeformten Beispiel:
Diese Angabe könnte besagen, dass das Patientengewicht bisher noch unbekannt ist oder noch nicht in das System eingegeben wurde. Ein Attribut darf in einem Element nur ein Mal deklariert werden. Das folgende Element ist also nicht wohlgeformt: 155
Dies ist sinnvoll, weil das Gewicht nicht gleichzeitig in Kilo und in Pfund angegeben werden kann.
Kommentare Kommentare sind Beschreibungen, die in ein XML-Dokument integriert werden, um zusätzliche Informationen über das Dokument bereitzustellen. Kommentare haben in XML dieselbe Syntax
26
Kapitel 3
wie in HTML und sind so formatiert, dass sie von der Anwendung, die das Dokument verarbeitet, ignoriert werden, wie im folgenden Beispiel:
Der Kommentar löst das Problem mit dem leeren Element ganz elegant. Die Probleme werden dadurch verursacht, dass ein HTML-Browser die Singleton-Notation nicht versteht. Bei der Umwandlung vorhandener HTML-Dokumentstrukturen in XML-Code stoßen Sie immer auf diese Schwierigkeiten.
Der body-Abschnitt Nachdem der head-Abschnitt nun fertig ist, können Sie den body-Abschnitt bearbeiten. Dieser Abschnitt wird die Informationen enthalten, die im Browser angezeigt werden. Gehen Sie wie folgt vor, um das body-Element zu erstellen. 1. Fügen Sie die folgenden Attribute zum body-Element hinzu: text, bgcolor, link, alink und vlink. Ergänzen Sie anschließend die untergeordneten Elemente basefont, a und table. 2. Klicken Sie auf vlink und fügen Sie den folgenden Kommentar unterhalb des Attributs ein: Standardfarben für Seite
Abbildung 3.6 zeigt das veränderte body-Element.
Struktur eines XML-Dokuments
33
Abbildung 3.6: Das body-Element, nachdem die benötigten Attribute und Elemente hinzugefügt wurden
Das basefont-Element einrichten Um das basefont-Element fertig zu stellen, müssen Sie ein Größenattribut und den folgenden Kommentar hinzufügen: Size ist Standardgröße für Hauptteil; Werte sollten zwischen 1 und 7 liegen (3 ist normalerweise der Standardwert).
Auch hier lässt sich das Problem mit dem leeren Element mit einem Kommentar lösen. HINWEIS Die zulässigen Werte des Attributs size wurden zwar beschränkt, es lässt sich jedoch nur mit einer DTD überprüfen, ob die korrekten Werte verwendet werden. Mehr hierzu erfahren Sie in Kapitel 4. Das a- Element einrichten Das a-Element dient als Anker für den Seitenanfang. Fügen Sie die Attribute name, href und target zum a-Element hinzu und fügen Sie dann den folgenden Kommentar in das Attribut name ein: Anchor für Seitenanfang
Das table- Element einrichten Gehen Sie wie folgt vor, um das table-Element fertig zu stellen: 1. Fügen Sie die folgenden Attribute zum table-Element hinzu: border, frame, rules, width, align, cellspacing und cellpadding. Fügen Sie den folgenden Kommentar unterhalb vom cellpadding-Element ein. Rules/frame wird bei Rand verwendet
34
Kapitel 3
2. Als Nächstes müssen Sie ein untergeordnetes tr-Element zum table-Element hinzufügen, um die Zeilen für die Tabelle einzurichten. Das Ergebnis ist in Abbildung 3.7 zu sehen.
Abbildung 3.7: Hier wurde ein tr-Element zum table-Element hinzugefügt
3. Fügen Sie folgende Attribute zum tr-Element hinzu: align, valign und bgcolor. 4. Fügen Sie ein untergeordnetes td-Element zum tr-Element hinzu. Das td-Element repräsentiert eine Tabellenzelle. Die einzelnen Zellen enthalten die Informationen, die auf der Webseite angezeigt werden. 5. Fügen Sie folgende Attribute zum td-Element hinzu: rowspan, colspan, align, valign und bgcolor. Ergänzen Sie dann die folgenden Kommentare: Es darf nur das Attribut rowspan oder das Attribut colspan verwendet werden. Mögliche Werte für Valign: top, bottom, middle
Als Nächstes werden Sie ein untergeordnetes Element namens CellContent zum td-Element hinzufügen. Das Element CellContent ist kein HTML-Element. Das Tag wird deshalb von reinen HTML-Webbrowsern ignoriert. Das Element CellContent dient zur Identifikation der Art von Informationen, die in der Zelle gespeichert werden. Anwendungen können so später den Inhalt der Website leichter ermitteln. Das CellContent-Element enthält mehrere Tags, die als Template für den Inhalt benutzt werden können, der in der Zelle enthalten sein wird. Um eine gewohnte Organisation beizubehalten, könnten die Überschriften h1, h2, h3 und h4 verwendet werden. Um das Beispiel einfach zu halten, kommt hier nur ein h1-Element zum Einsatz. Unter jeder Überschrift befindet sich ein Absatz. Jeder Absatz enthält mehrere Elemente, die nach dem jeweiligen Bedarf angeordnet werden können.
Struktur eines XML-Dokuments
35
Das CellContent-Element einrichten Gehen Sie wie folgt vor, um das CellContent-Element einzurichten: 1. Fügen Sie zum CellContent-Element ein Attribut namens cellname hinzu. 2. Richten Sie ein untergeordnetes Element namens h1 für das CellContent-Element ein und ergänzen Sie ein align-Attribut. 3. Fügen Sie ein untergeordnetes Element namens p zum CellContent-Element hinzu und ergänzen Sie ein align-Attribut. Geben Sie dann die folgenden Kommentare für das p-Element ein: Alle nachfolgenden Elementen können innerhalb des p-Elements in beliebiger Reihenfolge verwendet werden. Die li-Elemente müssen aus ul und ol entfernt werden, falls sie nicht benutzt werden.
4. Fügen Sie die folgenden untergeordneten Elemente zum p-Element hinzu: font, font, img, br, a, ul und ol. Es werden zwei font-Elemente benötigt, weil markierte Textabschnitte nicht in der Standardschriftart, sondern einer anderen Schriftart angezeigt werden sollen. Das zweite font-Element wird zusammen mit dem b-Element eingesetzt, um den Inhalt zwischen den b-Tags in Fettschrift zu formatieren. 5. Klicken Sie auf p und wählen Sie im Menü Insert den Befehl Text, um ein Objekt zu erzeugen, mit dem Sie Inhalte in das p-Element einfügen können. 6. Fügen Sie zum ersten font-Element die Attribute face, color und size und zum zweiten fontElement neben diesen Attributen noch ein untergeordnetes b-Element hinzu. 7. Fügen Sie die folgenden Attribute zum img-Element hinzu: src, border, alt, width, height, lowsrc, align, hspace und vspace. Ergänzen Sie die folgenden Kommentare nach vspace:
Abbildung 3.8: Die Struktur der Elemente img und br
36
Kapitel 3
Das Attribut Border gibt die Dicke des Rands in Pixel an. Werte für Align = right, left Die Attribute hspace und vspace stellen den Abstand zwischen Bild und Text in Pixeln dar.
8. Das br-Element verhindert, dass der Text die Bilder umfließt. Fügen Sie ein Attribut namens clear zum br-Element hinzu. Fügen Sie den folgenden Kommentar nach dem clear-Attribut ein: Clear = left, right, all; verhindert, dass Text Bild umfließt
Abbildung 3.8 zeigt, welche Struktur das XML-Dokument nun haben sollte. 9. Fügen Sie ein type-Attribut zum ul-Element hinzu und ergänzen Sie den folgenden Kommentar: Mögliche Werte für type-Attribut: circle, square, disk
10. Damit der fett gedruckte Text am Anfang der Liste als Überschrift angezeigt wird, klicken Sie auf das font-Element, das das b-Element enthält, und wählen im Menü Edit den Befehl Copy. Klicken Sie auf das ul-Element und wählen dann im Menü Edit den Befehl Paste. Fügen Sie als Nächstes ein untergeordnetes li-Element zum ul-Element hinzu. Das li-Element repräsentiert ein Element in der Liste. Kopieren Sie das font-Element, das kein b-Element enthält, in das li-Element. Kopieren Sie das a-Element in das li-Element. Fügen Sie ein Textobjekt zum li-Element hinzu. Dieses li-Element müssen Sie später löschen. 11. Fügen Sie zum Schluss die Attribute type und start zum ol-Element hinzu und ergänzen Sie folgenden Kommentar: Werte für das Attribut Type: A für Großbuchstaben, a für Kleinbuchstaben, I für große römische Ziffern, i für kleine römische Ziffern, 1 für nummerisch
12. Kopieren Sie das font-Element, das das b-Element enthält, vom p-Element in das ol-Element. Kopieren Sie das li-Element vom ul-Element in das ol-Element. Abbildung 3.9 zeigt das fertige CellContent-Element.
Abbildung 3.9: Das CellContent-Element in XML Notepad
Struktur eines XML-Dokuments
37
HINWEIS Einige Elemente in Abbildung 3.9, wie z. B. die Elemente img und br, werden in reduzierter Form angezeigt. Nun müssen Sie ein grundlegendes XML-Template einrichten, mit dem sich Webseiten erstellen lassen. Im nächsten Abschnitt wird eine Webhilfeseite anhand dieses XML-Dokuments eingerichtet.
Eine Webhilfeseite einrichten In XML Notepad können Sie nun wie bei den Kommentaren auf der rechten Seite Werte für Elemente, Text und Attribute eingeben. Speichern Sie das Dokument, das Sie soeben eingerichtet haben, unter dem Namen Standard.xml. Wählen Sie als Nächstes im Menü File den Befehl Save As und speichern Sie die Datei noch einmal unter dem Namen Hilfe.htm. Nun können Sie damit beginnen, Werte zum Template hinzuzufügen. Sie können auch Kopien vorhandener Elemente hinzufügen, falls Sie die Gesamtstruktur des Dokuments nicht verändern. In der Regel wird die Struktur beibehalten, wenn neue Elemente auf derselben Ebene hinzugefügt werden, wie das kopierte Element. Somit könnten Sie mehrere Kopien des li-Elements hinzufügen, wenn diese alle dem ul-Element oder dem ol-Element untergeordnet wären. Es wäre jedoch nicht möglich, ein li-Element einem anderen Element unterzuordnen, ohne die Struktur des Dokuments zu verändern.
Werte zu den Elementen des head- und des body-Abschnitts hinzufügen Nachdem das Template nun fertig ist, können Sie damit ein Webdokument erzeugen und den Inhalt der Elemente und die Attributwerte eingeben. Um Werte zu den Attributen der head- und body-Elemente hinzuzufügen, gehen Sie wie folgt vor: 1. Erweitern Sie das body-Element und weisen Sie dem title-Element des head-Elements den folgenden Wert zu: Helpdesk von Nordwind. 2. Weisen Sie als Nächstes den Attributen des body-Elements die folgenden Werte zu: Attribut
Wert
Text
#000000
Bgcolor
#FFFFFF
Link
#003399
Alink
#FF9933
Vlink
#996633
3. Erweitern Sie das a-Element und weisen Sie dem name-Attribut den Wert Top zu. 4. Geben Sie für die Attribute des table-Elements folgende Werte ein:
38
Attribut
Wert
Border
0
Width
100%
Cellspacing
0
Cellpadding
0
Kapitel 3
Die erste Zeile fertig stellen Wie in Abbildung 3.3 gezeigt, enthält die erste Zeile der Beispieltabelle den auf der Seite zentrierten Titel. Um dieses Ergebnis zu erhalten, gehen Sie wie folgt vor: 1. Erweitern Sie das tr-Element und setzen Sie das Attribut valign auf den Wert Center. Erweitern Sie anschließend das td-Element und setzen Sie das align-Attribut auf den Wert Center. 2. Geben Sie für das colspan-Attribut des td-Elements den Wert 2 ein (damit wird erreicht, dass sich der Titel über die beiden Spalten erstreckt). 3. Erweitern Sie das CellContent-Element und geben Sie für das cellname-Attribut den Wert Tabellenkopf ein. Weisen Sie dem h1-Element den Wert Helpdesk zu und dem align-Attribut den Wert Center. Abbildung 3.10 zeigt, wie das Dokument nun aussehen sollte. Sie können nun den tr-Abschnitt reduzieren, weil die Zeile nun fertig ist.
Abbildung 3.10: Die fertige erste Zeile in XML Notepad
Die zweite Zeile fertig stellen Gehen Sie wie folgt vor, um die zweite Tabellenzeile fertig zu stellen: 1. Klicken Sie auf das Element tr und wählen Sie dann im Menü Insert den Befehl Duplicate Subtree. Damit wird ein weiteres tr-Element eingefügt, das bereits alle untergeordneten Elemente enthält. Erweitern Sie das neue tr-Element und setzen Sie das valign-Attribut auf Top.
Struktur eines XML-Dokuments
39
2. Die zweite Zeile soll aus zwei Zellen bestehen, die jeweils Listen mit Hyperlinks enthalten. Um dies so einzurichten, klicken Sie auf das td-Element und wählen im Menü Insert den Befehl Duplicate Subtree. Nun haben Sie ein zweites td-Element mit allen untergeordneten Elementen. 3. Bearbeiten Sie nun zunächst das erste td-Element. Weisen Sie dem align-Attribut des ersten td-Elements den Wert Left zu. Erweitern Sie das CellContent-Element und geben Sie für das cellname-Attribut den Wert Hilfethemen ein. Erweitern Sie das p-Element, dann das ulElement und schließlich das font-Element. Geben Sie für das size-Attribut den Wert 3 ein und für das b-Element den Wert Fuer erstmalige Besucher. 4. Weil Hyperlinks zu Hilfeseiten eingerichtet werden sollen, kommt das a-Element zum Einsatz. Erweitern Sie das li-Element und anschließend das a-Element und geben Sie den Wert Informationen fuer erstmalige Besucher ein. Weisen Sie dem href-Attribut des a-Elements den Wert ErstBesucherInfo.htm zu. 5. Klicken Sie auf li und wählen Sie im Menü Insert den Befehl Duplicate Subtree, um ein li-Element inklusive aller untergeordneten Elemente hinzuzufügen. Erweitern Sie das neue li-Element und anschließend das a-Element, und geben Sie den Wert Sicher einkaufen bei Nordwind ein. Weisen Sie dem href-Attribut dieses a-Elements den Wert SicheresShopping.htm zu.
Abbildung 3.11: Die fertige erste Liste in XML Notepad
40
Kapitel 3
6. Klicken Sie auf das li-Element und wählen Sie im Menü Insert den Befehl Duplicate Subtree, um ein drittes li-Element hinzuzufügen. Erweitern Sie das li-Element und anschließend das a-Element und geben Sie den Wert Frequently Asked Questions (FAQ) ein. Weisen Sie dem href-Attribut den Wert FAQ.htm zu. 7. Klicken Sie auf das li-Element und wählen Sie im Menü Insert den Befehl Duplicate Subtree, um ein viertes li-Element hinzuzufügen. Erweitern Sie dieses li-Element, erweitern Sie das a-Element und geben Sie den Wert Navigation im Web ein. Weisen Sie dem href-Attribut den Wert NavWeb.htm zu. Abbildung 3.11 zeigt, wie das Dokument nun aussehen müsste. 8. Erweitern Sie das zweite td-Element und setzen Sie das align-Attribut auf den Wert Left. Erweitern Sie das CellContent-Element und geben Sie für das Attribut cellname den Wert Links für Versand ein. Erweitern Sie die Elemente p, ul und font und geben Sie für das b-Element den Wert Versand ein. 9. Erweitern Sie das li-Element, erweitern Sie das a-Element und geben Sie den Wert Preise ein. Geben Sie für das Attribut href den Wert Preise.htm ein. 10. Klicken Sie auf li und wählen Sie im Menü Insert den Befehl Duplicate Subtree, um ein zweites li-Element einzufügen. Erweitern Sie das neue li-Element, erweitern Sie das a-Element und geben Sie den Wert Status der Bestellung ein. Weisen Sie dem Attribut href den Wert BestellStat.htm zu. 11. Klicken Sie auf das li-Element und wählen Sie im Menü Insert den Befehl Duplicate Subtree, um ein drittes li-Element einzufügen. Erweitern Sie das neue li-Element und das a-Element, und geben Sie den Wert Retouren ein. Weisen Sie dem Attribut href den Wert Retouren.htm zu. Abbildung 3.12 zeigt die fertige zweite Liste.
Abbildung 3.12: Die fertige zweite Liste in XML Notepad
Struktur eines XML-Dokuments
41
Aufräumen Im Beispiel kamen viele der Elemente des Templates nicht zum Einsatz, wie z. B. die ol-Elemente, einige h1-Elemente und das base-Element. Es gibt keinen Grund, diese Elemente zu behalten. Einige von ihnen beeinflussen sogar die Anzeige des Dokuments in einem nur HTML-fähigen Browser. Löschen Sie deshalb im Template alle Elemente, die nicht verwendet wurden. Speichern Sie das Dokument anschließend. Wenn Sie das Dokument nun in einem Webbrowser betrachten, sollte es wie in Abbildung 3.2 aussehen. Die bereinigte Datei heißt auf der CD-ROM Hilfe1.htm.
Was haben Sie erreicht? Sie haben ein Standard-Template eingerichtet und damit eine einfache Webseite erstellt. Es stellt sich nun die Frage, ob Sie damit etwas gewonnen haben. In diesem Abschnitt werden die Vorteile von Standard-Templates vorgestellt.
Inhalte automatisch verändern Das höchste Ziel besteht darin, Computeranwendungen zu erstellen, die Inhalte im Dokument katalogisieren, anzeigen und speichern. Im Idealfall sollten diese Anwendungen dabei automatisch vorgehen, ohne dass Menschen eingreifen müssen. Sie sollten immer in der Lage sein, eine Computeranwendung zu erzeugen, die ein wohlgeformtes XML-Dokument automatisch verarbeitet. Normale HTML-Dokumente lassen sich nicht automatisch verarbeiten, weil sie nicht wohlgeformt sind. Es ist extrem schwierig, HTML-Code nach einem einheitlichen Standard zu erzeugen. Wenn Sie ein Design für eine Webseite skizzieren und dieses zehn verschiedenen Webentwicklern geben, erhalten Sie zehn Dokumente mit völlig unterschiedlichem HTML-Code. Selbst mit einem Standard würde sich der Code sehr wahrscheinlich unterscheiden. Eine automatisierte Computeranwendung kann nur mit einem Standardformat arbeiten. Wenn jedes HTML-Dokument nur einen bestimmten Satz von Tags beinhalten kann und diese Tags nur eine vorgegebene Reihenfolge haben dürfen, lässt sich eine Anwendung schreiben, die den Inhalt des Dokuments verarbeitet. Sie könnten auch einen Regelsatz definieren, mit dem die Entwickler arbeiten sollen. Im Beispiel für das XML-Template wurden diese Regeln mit XML und XML Notepad definiert. Die Regeln hätten auch einfach in ein Dokument geschrieben werden können. Dann hätte es jedoch keine Möglichkeit gegeben, sicherzustellen, dass die zehn Entwickler ihre HTML-Seiten alle den Regeln entsprechend aufbauen. Werden die Regeln jedoch in XML definiert, lässt sich sehr schnell überprüfen, ob das Dokument wohlgeformt ist (was zutreffen muss, falls das Dokument mit einem XML-Editor erstellt wurde). Sie benötigen auch eine DTD, um alle Regeln zu überprüfen. (Mehr dazu, wie Sie diese DTD einrichten, erfahren Sie in Kapitel 4). Wird das Dokument mit XML Notepad erstellt, lassen sich Fehler vermeiden, wenn die Anwendung das Dokument liest. Die Elemente der Beispielwebseite ließen sich auch in einer Datenbank speichern. Die Tabellen und Felder könnten dann anhand der Informationen eingerichtet werden, die in der Datenbank enthalten sind. Weil eine XML-fähige Computeranwendung den Inhalt jedes Elements identifi-
42
Kapitel 3
zieren kann, kann die Anwendung automatisch die Elemente in die korrekte Tabelle und das korrekte Feld setzen.
Inhalt interpretieren Der Inhalt lässt sich in passender Weise definieren. Im Beispieldokument wurde ein CellContent-Element hinzugefügt. Sie hätten jedoch auch zahlreiche Elemente zum Dokument hinzufügen können, um den Inhalt jedes Abschnitts anzugeben. Und Sie hätten die vorhandenen Elemente auch mit Attributen versehen können. Das ul-Element hätten Sie beispielsweise wie folgt definieren können:
Diese zusätzlichen Attribute und Elemente können dann von der Anwendung eingesetzt werden, um den Inhalt des Dokuments zu katalogisieren. Stellen Sie sich vor, dass der Index für die Suche in der Website anhand dieser Tags erstellt würde. Diese zusätzlichen Tags und Attribute sorgen auch dafür, dass das Dokument für Menschen leichter lesbar ist. Wenn Sie eine Website entwerfen, können Sie auch den Inhalt verschiedener Elemente definieren, anstatt nur aufzuzeichnen, wie die Seite aussehen soll. Einige Komponenten, wie z. B. die Navigationsleisten am oberen Seitenrand, an den Seiten und am unteren Rand werden sehr wahrscheinlich von zahlreichen Seiten benutzt. Solche Komponenten sollten identifiziert und zum Standard-Template hinzugefügt werden. Der Entwickler braucht dann nur die Elemente auf der Seite zu ändern, die auf den einzelnen Seiten unterschiedlich sind.
Elemente wiederverwenden In der Beispielvorlage haben Sie Elemente erzeugt, die sich bei der Erstellung eines Webdokuments wiederverwenden lassen. Als Sie eine neue Zeile hinzugefügt haben, haben Sie die Zeilenstruktur kopiert und als neue Zeile in das Dokument eingefügt. Diese neue Zeile enthielt bereits eine komplette Struktur. Mit derselben Technik haben Sie mehrere andere Elemente dupliziert, wie z. B. das li-, das font-, das p- und das a-Element. Die Wiederverwendung von Elementen, die Attribute und untergeordnete Elemente enthalten, garantiert, dass das gesamte Dokument einheitlich ist. Wenn Sie Dokumente erstellen, hilft diese Einheitlichkeit dabei, sicherzustellen, dass die Regeln für das Dokument eingehalten werden. Anhand wiederverwendbarer Elemente lässt sich das gesamte Dokument leichter erstellen, weil es sich aus vordefinierten Teilen zusammensetzen lässt. Es wäre beispielsweise ganz einfach, zusätzliche h-Elemente durch Wiederverwendung des p-Elements aufzunehmen. Sie müssten nur die Elemente h2, h3 und h4 einfügen und dann drei p-Elemente kopieren und einfügen. Im Beispiel in Abbildung 3.13 wird das p-Element wiederverwendet.
Weitere XML-Editoren Um XML-Dokumente zu betrachten, stehen neben XML Notepad weitere Programme zur Verfügung. Einige davon arbeiten mit DTDs zusammen und werden in Kapitel 4 beschrieben. Abbildung 3.14 zeigt das fertige Helpdesk-Dokument Hilfe.htm im XML-Editor XML Spy (http:// xmlspy.com).
Struktur eines XML-Dokuments
43
Abbildung 3.13: XML Notepad zeigt die Elemente h2, h3 und h4
Abbildung 3.14: Die Datei Hilfe.htm in XML Spy
XML-Dokumente lassen sich außerdem mit XML Pro öffnen und bearbeiten (http://www.vervet.com). In XML Pro werden die Elemente, die eingefügt werden können, in einem separaten Fenster aufgelistet. Abbildung 3.15 zeigt das fertige Helpdesk-Dokument Hilfe.htm in XML Pro. Von den angegebenen Websites können Sie Testversionen der Programme herunterladen. Verwenden Sie das Programm, mit dem Sie am besten zurechtkommen.
44
Kapitel 3
Abbildung 3.15: Die Datei Hilfe.htm in XML Pro
Kriterien für wohlgeformte XML-Dokumente Um wohlgeformt zu sein, muss ein XML-Dokument folgende Anforderungen erfüllen: 1. Das Dokument darf nur ein Stammelement enthalten. 2. Jedes Element muss korrekt verschachtelt sein. 3. Jedes Attribut darf nur einen Wert haben. 4. Alle Attributwerte müssen in doppelte oder einfache Anführungszeichen gesetzt sein. 5. Für jedes Element muss ein Start- und ein Ende-Tag existieren, falls es sich nicht um ein leeres Element handelt. 6. Leere Elemente werden mit einem einzelnen Tag dargestellt, das mit einem Schrägstrich (/) endet. 7. Isolierte Auszeichnungen sind im Inhalt nicht erlaubt. Die Sonderzeichen haben in Inhaltsabschnitten die Syntax >, & und <. 8. Doppelte Anführungszeichen haben in Inhaltsabschnitten die Syntax " und einfache Anführungszeichen haben die Syntax &apos. 9. Die Zeichenfolgen dürfen nicht verwendet werden. 10. Wenn es für ein Dokument keine DTD gibt, müssen alle Attribute standardmäßig Werte des Typs CDATA haben.
Struktur eines XML-Dokuments
45
In diesem Kapitel wurden die Regeln 1 bis 6 beschrieben. Wenn Sie Sonderzeichen verwenden müssen, fügen Sie sie nach den Regeln 7 und 8 ein und vergewissern Sie sich, dass Sie die korrekte Syntax nutzen. Die Zeichenfolge in Regel 9 hat in XML eine spezielle Bedeutung und darf deshalb in Inhaltsabschnitten und Namen nicht verwendet werden. Sie wird in Kapitel 5 ausführlich beschrieben. Der Typ CDATA, auf den in Regel 10 verwiesen wird, besteht aus allen zulässigen Zeichen. Im Beispieldokument müssen die Attributwerte Zeichen enthalten, was auch der Fall ist.
Die XML-Deklaration hinzufügen XML Notepad fügt die XML-Deklaration nicht automatisch zu einem XML-Dokument hinzu. Die XML-Deklaration ist optional und sollte, falls sie verwendet wird, in der ersten Zeile des XML-Dokuments stehen. Die Syntax für die Deklaration sieht wie folgt aus:
Das Attribut version gibt die Version des XML-Standards an, dem das Dokument entspricht. Das Attribut encoding gibt den Unicode-Zeichensatz an, dem das Dokument entspricht. Mit dieser Kodierung können Sie Dokumente in jeder Sprache und mit jedem beliebigen Zeichensatz erstellen. Das Attribut standalone gibt an, ob das Dokument von anderen Dateien abhängig (standalone = "no") oder vollständig eigenständig ist (standalone = "yes").
Das fertige XML-Dokument Der Code des fertigen XML-Dokuments sieht wie folgt aus:
Helpdesk von Nordwind
Helpdesk
46
Kapitel 3
-
Informationen fuer erstmalige Besucher -
Sicher einkaufen bei Nordwind -
Frequently Asked Questions (FAQ)
Navigation im Web
Fuer erstmalige Besucher
Struktur eines XML-Dokuments
47
Preise-
Status der Bestellung
Retouren
Versand
Das fertige Dokument sieht im Wesentlichen wie ein HTML-Dokument aus und funktioniert auch so. Es erfüllt jedoch die Kriterien eines wohlgeformten XML-Dokuments. Beachten Sie, dass alle Tags korrekt verschachtelt sind, alle Tags von einem Ende-Tag abgeschlossen werden und das Stammelement () alle anderen Elemente beinhaltet. Sie hätten diesen XML-Code auch eintippen können. Es wäre jedoch schwieriger gewesen und der Code hätte vermutlich zahlreiche Syntaxfehler enthalten. Es gibt verschiedene XML-Editoren wie XML Authority, XML Instance und XML Spy, mit deren Hilfe Sie sich auf die Struktur Ihres Dokuments und die Elemente konzentrieren können, die im Dokument enthalten sein sollen, ohne sich um die konkrete Syntax kümmern zu müssen. Selbstverständlich sollten Sie sich das fertige Dokument nach der Bearbeitung noch einmal in einem Browser betrachten, um sicherzustellen, dass der XML-Code dem entspricht, was Sie haben wollten.
Zusammenfassung Wohlgeformte XML-Dokumente lassen sich mit Elementen, Attributen und Kommentaren erstellen. Diese Komponenten definieren den Inhalt des Dokuments. Mit diesen Definitionen lassen sich Anwendungen erzeugen, die Inhalte manipulieren. In diesem Kapitel wurden als Anforderungen für wohlgeformte Dokumente genannt: dass das Dokument genau ein Stammelement enthalten muss, dass die Elemente korrekt verschachtelt sein müssen, dass keine doppelten Attributnamen in einem Element enthalten sein dürfen und dass alle Attributwerte in einfachen oder doppelten Anführungszeichen stehen müssen. Mit einem XML-Editor können Sie sich auf die Definition der Struktur Ihres Dokuments konzentrieren, was einen ersten Schritt auf dem Weg zu einem wohlgeformten XML-Dokument darstellt. Um eine Klasse mit Dokumenten desselben Formats erstellen zu können, müssen Sie eine DTD erzeugen, mit der die Gültigkeit der gesamten Klasse von Dokumenten überprüft wird. Im nächsten Kapitel erfahren Sie, wie DTDs eingerichtet werden, und Sie werden selbst eine für das Beispieldokument aus diesem Kapitel erstellen.
48
Kapitel 3
4 49 52 57 60 61 65
Eine Einführung in DTDs
Eine DTD erstellen Die !ELEMENT-Anweisung Die !ATTLIST-Anweisung Die überarbeitete DTD Die DTD mit einem XML-Dokument verknüpfen Zusammenfassung
In Kapitel 3 haben Sie ein Dokumenttemplate für die Erstellung von XML-Dokumenten entwickelt, die in Webbrowsern als HTML-Dokumente angezeigt werden. In diesem Kapitel werden Sie eine Dokumenttypdefinition (DTD) erstellen. Diese DTD definiert einen Satz von Regeln, die mit allen XML-Dokumenten verknüpft sind, die mit dem Template erstellt werden. Mit dieser DTD lässt sich überprüfen, ob XML-Dokumente den DTD-Regeln entsprechen. Für die Erstellung und Bearbeitung von DTDs stehen zahlreiche Programme zur Verfügung, wie z. B. XML Authority, XML Spy und Near and Far. In diesem Kapitel wird die DTD mit XML Authority erstellt und bearbeitet. Sie können eine Testversion von XML Authority von der Website http://www.extensibility.com herunterladen. Mit Microsoft XML Notepad lassen sich DTDs nicht bearbeiten (es ist jedoch möglich, ein Dokument zu überprüfen, das mit einer DTD verknüpft ist).
Eine DTD erstellen In diesem Kapitel werden Sie eine DTD erstellen, die Regeln für das Template definiert, das Sie in Kapitel 3 eingerichtet haben. Anhand einer DTD lässt sich die Gültigkeit eines XML-Dokuments überprüfen, d. h. es lässt sich feststellen, ob das Dokument den Regeln entspricht, die in der DTD definiert sind. HINWEIS Wenn Sie ein umfangreiches Internetsystem einrichten, können Sie Regeln definieren, die alle Entwickler bei der Erstellung von Webseiten berücksichtigen müssen. Wenn die Webseiten mit XML erstellt werden, lässt sich anhand einer DTD überprüfen, ob alle Seiten den Regeln entsprechen. XML kann auch eingesetzt werden, um Informationen zwischen Unternehmen oder Abteilungen innerhalb eines Unternehmens auszutauschen. Anhand der DTD lässt sich sicherstellen, dass die eingehenden Informationen das korrekte Format haben.
49
Gehen Sie wie folgt vor, um das Beispieldokument in XML Authority zu öffnen: 1. Öffnen Sie XML Authority, zeigen Sie im Menü File auf den Befehl New und wählen Sie im Untermenü den Eintrag New (DTD). Wenn das Standardelement UNNAMED am oberen Rand des Dokuments eingeblendet wird, löschen Sie es. 2. Zeigen Sie im Menü File auf den Befehl Import und wählen Sie im Untermenü den Befehl XML Document. 3. Wählen Sie das Dokument Standard.xml, das Sie in Kapitel 3 erstellt haben. XML Authority importiert das Dokument als DTD. Abbildung 4.1 zeigt die Datei Standard.xml in XML Authority.
Abbildung 4.1: Das Template Standard.xml in XML Authority
4. Wählen Sie im Menü View den Befehl Source. XML Authority erstellt für das XML-Dokument automatisch eine DTD. Deshalb ist die Quelle hier eine DTD für das XML-Dokument Standard.xml. Nachfolgend sehen Sie den kompletten Quellcode, der von XML Authority erzeugt wird:
target CDATA (basefont, a, alink CDATA text CDATA bgcolor CDATA link CDATA vlink CDATA
50
base base body body
#REQUIRED> table)> #REQUIRED #REQUIRED #REQUIRED #REQUIRED #REQUIRED>
Kapitel 4
Wie Sie sehen, besteht die DTD aus den zwei Komponenten !ELEMENT und !ATTLIST. In diesem Kapitel werden diese Komponenten ausführlich behandelt.
Eine Einführung in DTDs
51
HINWEIS Die DTD, die automatisch erzeugt wurde, ist nur eine erste Annäherung. In diesem Kapitel werden Sie die DTD verfeinern, sodass sie am Ende ein passendes Regelwerk für Ihre XML-Dokumente definiert.
Die !ELEMENT-Anweisung Jedes Element in einem XML-Dokument muss in der DTD mit dem -Tag, auch Elementtypdeklaration genannt, deklariert werden, das die folgende Syntax hat:
Die Komponente Regel definiert die Regeln für den Inhalt des Elements. Diese Regeln definieren die logische Struktur des XML-Dokuments und können zur Überprüfung der Gültigkeit eines Dokuments eingesetzt werden. Die Regel kann aus einer generischen Deklaration und einem oder mehreren Elementen bestehen, die entweder gruppiert oder ungeordnet sind.
Vordefinierte Konstantendeklarationen: PCDATA, ANY und EMPTY Für XML-DTDs gibt es die drei generischen Konstantendeklarationen PCDATA, ANY und EMPTY. PCDATA Die PCDATA-Deklaration (PCDATA – Parsed Character Data) kann eingesetzt werden, wenn ein Element reinen Text enthält, d. h. wenn es keine untergeordneten Elemente gibt. Das Beispieldokument enthält einige solche Elemente, wie z. B. title, a, h1 und b. Diese Elemente lassen sich wie folgt deklarieren. (Das Nummernzeichen # kennzeichnet einen speziellen, vordefinierten Namen.)
a (#PCDATA)> h1 (#PCDATA)> b (#PCDATA)>
HINWEIS PCDATA ist auch bei leeren Elementen gültig. ANY Die ANY-Deklaration lässt gemischte Inhalte mit Text und untergeordneten Elementen zu. Das html-Element könnte die ANY-Deklaration beispielsweise wie folgt nutzen:
Die folgende ANY-Deklaration gestattet die Integration des body- und des head-Elements in das html-Element eines XML-Dokuments:
Der folgende XML-Code wäre ebenfalls gültig: Dies ist ein HTML-Dokument.
Und der folgende XML-Code wäre für die ANY-Deklaration in der Beispiel-DTD gültig: Dies ist ein HTML-Dokument.
52
Kapitel 4
Bei der ANY-Deklaration dürfen alle Inhalte mit Element-Tags ausgezeichnet werden, sofern es sich beim Inhalt um wohlgeformtes XML handelt. Diese Flexibilität sieht zwar nützlich aus, sie wirkt jedoch dem Zweck der DTD entgegen, der darin besteht, die Struktur des XML-Dokuments zu definieren, damit die Gültigkeit des Dokuments überprüft werden kann. Kurz gesagt lässt sich die Gültigkeit von Elementen, die ANY verwenden, nicht überprüfen. Es lässt sich nur sicherstellen, dass die Elemente wohlgeformt sind. EMPTY Es ist möglich, ein Element ohne Inhalt zu deklarieren – also ein Element, das keine untergeordneten Elemente und keinen Text enthält, wie etwa das img-Element. Die EMPTY-Deklaration hat die folgende Syntax:
Die Elemente base, br und basefont sind in der Beispiel-DTD ebenfalls korrekt mit EMPTY deklariert.
Eines oder mehrere Elemente Statt mit der ANY-Deklaration sollten Sie den Inhalt des html-Elements so definieren, dass seine Gültigkeit überprüft werden kann. Nachfolgend sehen Sie eine Deklaration, die den Inhalt des html-Elements festlegt und derjenigen entspricht, die von XML Authority vorgegeben wird:
Diese (head, body)-Deklaration gibt an, dass das html-Element die zwei untergeordneten Elemente head und body enthalten wird. In Klammern kann die erforderliche Anzahl untergeordneter Elemente stehen. Die einzelnen Elemente müssen dabei mit einem Komma getrennt werden. Damit das XML-Dokument gültig ist, muss die Reihenfolge der Elemente in der Deklaration der untergeordneten Elemente mit der der Elemente im XML-Dokument übereinstimmen. Das Komma, das die untergeordneten Elemente voneinander trennt, wird als Nachfolgefunktion interpretiert. Die vorherige Deklaration besagt also, dass das html-Element ein head-Element enthält, dem ein body-Element folgt. Entsprechend dieser Deklaration ist der folgende XMLCode gültig:
Die folgende Anweisung ist jedoch ungültig:
Diese Anweisung gibt an, dass das html-Element zwei untergeordnete Elemente enthalten muss, wobei das erste das body-Element ist und das zweite das head-Element, und dass es nur eine Instanz jedes Elements geben kann. Die folgenden beiden Anweisungen sind ebenfalls ungültig:
Bei der ersten Anweisung fehlt das head-Element und bei der zweiten sind die Elemente head und body zwei Mal aufgeführt.
Eine Einführung in DTDs
53
Elemente, die mehrmals vorkommen Jedes html-Element enthält ein untergeordnetes head- und ein body-Element in der angegebenen Reihenfolge. Bei anderen Elementen wie dem body- und dem table-Element können untergeordnete Elemente mehrmals oder gar nicht vorkommen. XML bietet drei Marker, um anzugeben, wie häufig ein untergeordnetes Element vorkommen darf (siehe Tabelle 4.1). Marker
Bedeutung
?
Das Element soll entweder gar nicht vorhanden sein oder nur ein Mal vorkommen (0 oder 1).
+
Das Element muss mindestens ein Mal vorkommen (1 oder mehr).
*
Das Element kann gar nicht oder mehrmals vorkommen (0 oder mehr).
Tabelle 4.1: XML-Elementmarker
Steht kein Marker hinter dem untergeordneten Element, muss dieses Element vorhanden sein und darf nur ein Mal vorkommen. Das head-Element enthält ein optionales base-Element. Um dieses Element als optionales Element zu deklarieren, muss die obige Deklaration wie folgt angepasst werden:
Das body-Element enthält ein basefont-Element und ein a-Element, die beide optional sind. Im Beispiel ist das table-Element ein erforderliches Element, mit dem die Seite formatiert wird. Deshalb sollte das table-Element zu einem erforderlichen Element gemacht werden, das im body-Element nur ein Mal vorkommt. Das body-Element kann entsprechend wie folgt deklariert werden:
Das table-Element muss mindestens eine Zeile enthalten. Die maximale Zeilenanzahl ist davon abhängig, wie viele Zeilen zur Formatierung der Seite benötigt werden. Das table-Element kann nun wie folgt deklariert werden:
Dasselbe gilt auch für das tr-Element: Das Zeilenelement muss, wie nachfolgend gezeigt, mindestens eine Spalte enthalten:
Die Elemente a, ul und ol müssen nicht unbedingt im p-Element enthalten sein. Sie können, wie nachfolgend gezeigt, aber auch unbegrenzt oft vorhanden sein:
Weil das br-Element Text formatiert, der ein Bild umgibt, sollten das img- und das br-Tag immer gemeinsam verwendet werden. Untergeordnete Elemente gruppieren Glücklicherweise bietet XML eine Möglichkeit, Elemente zu gruppieren. Das p-Element ließe sich beispielsweise auch wie folgt deklarieren:
Diese Deklaration gibt an, dass ein img-Element, dem ein br-Element folgt, gar nicht oder mehrmals im p-Element enthalten sein darf.
54
Kapitel 4
Bei dieser Deklaration bleibt ein Problem. Wie bereits erwähnt, kann das Trennzeichen Komma als gefolgt von interpretiert werden. Somit enthält jedes p-Element die untergeordneten Elemente font, img, br, a, ul und ol in der angegebenen Reihenfolge. Dies ist allerdings nicht genau das, was hier erwünscht ist. Die Elemente sollen in einer beliebigen Reihenfolge eingesetzt werden können und es soll möglich sein, einige Elemente in bestimmten Abschnitten zu verwenden und andere in anderen Abschnitten. Es sollte beispielsweise möglich sein, den folgenden Code zu schreiben:
Drei Gründe, bei Nordwind einzukaufen
Drei Gründe, bei Nordwind einzukaufen
Eine Einführung in DTDs
55
Drei Gründe, bei Nordwind einzukaufen
Angenommen, Sie möchten auch Text in das p-Element aufnehmen. Dazu müssen Sie eine PCDATA-Deklaration zur Gruppe hinzufügen. Sie müssen dann den senkrechten Strich als Trennzeichen verwenden, weil die PCDATA-Deklaration nicht zulässig ist, wenn die untergeordneten Elemente mit Kommas getrennt werden. Die Gruppe, die PCDATA enthält, kann auch eine Untergruppe wie (img, br?) enthalten. Dieses Problem können Sie dadurch lösen, dass Sie ein neues Element namens ImageLink erzeugen, das die Untergruppe enthält, und dieses dann wie folgt zum p-Element hinzufügen:
Webbrowser, die nicht XML-fähig sind, ignorieren das ImageLink-Element. Wird PCDATA in einer Gruppe von untergeordneten Elementen eingesetzt, muss der PCDATA-Deklaration ein Nummernzeichen (#) vorangestellt werden und die Deklaration an erster Stelle stehen. Mit der DTD lässt sich sicherstellen, dass bestimmte Abschnitte des Dokuments in einer gewissen Reihenfolge stehen und eine angegebene Anzahl untergeordneter Elemente enthalten (wie beim html-Element). Es lassen sich auch Abschnitte im Dokument einrichten, die eine unspezifische Anzahl untergeordneter Elemente in einer beliebigen Reihenfolge enthalten. DTDs sind extrem flexibel und gestatten es, eine Regelmenge einzurichten, die Ihren Anforderungen entspricht.
Die !ATTLIST-Anweisung Jedes Element kann mit einem Satz von Attributen verknüpft werden. Die Attribute eines Elements werden in einer !ATTLIST-Anweisung, auch Attributlistendeklaration genannt, deklariert. Die !ATTLIST-Anweisung hat die folgende Syntax:
Der ElementName ist der Name des Elements, zu dem die Attribute gehören. Die Attributdefinition besteht aus den folgenden Komponenten: AttributName AttributTyp Standarddeklaration Die Komponente AttributName ist der Name des Attributs, die Komponente AttributTyp beschreibt den Datentyp des Attributs. Die Komponente Standarddeklaration enthält den Abschnitt mit der Standarddeklaration der Attributdefinition.
Attributdatentypen XML-DTD-Attribute können folgende Datentypen haben: CDATA, Aufzählung, ENTITY, ENTITIES, ID, IDREF, IDREFS, NMTOKEN und NMTOKENS. CDATA Der Datentyp CDATA gibt an, dass das Attribut auf jeden zulässigen Zeichenwert gesetzt werden kann. Für die Beispiel-DTD zur Erstellung von Webseiten haben die meisten Elemente Attribute des Datentyps CDATA (Character Data, deutsch Zeichenfolge). Die folgenden Attribute des body-Elements sind alle CDATA-Attribute:
Eine Einführung in DTDs
57
Beachten Sie, dass für ein Element mehrere Attribute aufgelistet werden können. Mit der Angabe #Required werden notwenige Attribute gekennzeichnet. Aufzählung Der Datentyp Aufzählung listet Werte auf, die für das Attribut zulässig sind. Mit diesem Datentyp lässt sich das font-Element so umformulieren, dass das color-Attribut auf die Werte Cyan, Lime, Black, White oder Maroon beschränkt ist; das Attribut size lässt sich auf den Wert 2, 3, 4, 5 oder 6 beschränken und das Attribut face auf die Schriftart Times New Roman oder Arial. Die neue font-Deklaration würde dann wie folgt aussehen:
HINWEIS Denken Sie daran, dass bei dieser Deklaration die Groß-/Kleinschreibung unterschieden wird. Wird cyan als Wert für das Attribut color eingegeben, wird ein Fehler hervorgerufen. Beachten Sie außerdem die Angabe &apos als Platzhalter für ein einfaches Anführungszeichen und die Verwendung der Klammern, um die Auswahlmöglichkeiten zu gruppieren. Im Abschnitt »Die Standarddeklaration« später in diesem Kapitel erfahren Sie, wie ein Standardwert für die Attribute color und size deklariert wird. ENTITY und ENTITIES Die Datentypen ENTITY und ENTITIES dienen zur Definition wiederverwendbarer Zeichenfolgen, die von einem bestimmten Namen repräsentiert werden. Diese Datentypen werden in Kapitel 5 ausführlich besprochen. ID, IDREF und IDREFS Möglicherweise sollen innerhalb eines Dokuments bestimmte Elemente mit einem Attribut des Datentyps ID identifiziert werden. Der Name eines solchen Attributs muss innerhalb eines Dokuments eindeutig sein. Andere Elemente können sich dann über den Datentyp IDREF oder IDREFS auf das Attribut beziehen. IDREFS kann verwendet werden, um mehrere Attribute als IDREF zu deklarieren. Innerhalb von HTML können mit Anchor-Elementen (a) einzelne Abschnitte des Dokuments mit Lesezeichen versehen lassen. Diese Lesezeichen können eingesetzt werden, um Links zu einzelnen Abschnitten des Dokuments einzurichten. Anders als der Datentyp ID muss das a-Element nicht eindeutig sein. In XML werden IDs eingesetzt, um Links zu verschiedenen Stellen im Dokument einzurichten. Wenn dieses Thema in Kapitel 6 genauer untersucht wird, werden Sie sehen, dass der Datentyp ID noch andere Vorteile bietet. Das Beispieldokument enthält am Anfang ein a-Element als Anker, über das der Seitenanfang angesprungen werden kann. Die Definition des a-Element in der DTD lässt sich wie folgt verändern:
58
Kapitel 4
Wenn Sie nun ein XML-Dokument erstellen, können Sie ein a-Element am Seitenanfang definieren und über das Attribut linkid mit einer eindeutigen ID versehen. Um auf diese ID von anderen Elementen aus zu verweisen, muss, wie nachfolgend gezeigt, ein Attribut des Typs IDREF zu diesen Elementen hinzugefügt werden:
Im XML-Dokument lässt sich das Attribut linkid des a-Elements mit dem Attribut headlink des ul-Elements verknüpfen, indem beiden derselbe Wert zugewiesen wird (im Beispiel HeadAnchor). Wenn Sie ein zweites Attribut des Datentyps ID namens footlink zu einem Element am unteren Rand des XML-Dokuments hinzufügen würden, könnten Sie Verweise auf beide Elemente einrichten. In diesem Fall würden IDREFS-Attribute wie folgt eingesetzt werden:
Das eigentliche XML-Dokument enthielte dann den folgenden Code:
Dieser Code funktioniert sowohl in nicht XML-fähigen Browsern als auch in Browsern, die XML unterstützen. NMTOKEN und NMTOKENS Die Datentypen NMTOKEN und NMTOKENS ähneln dem Datentyp CDATA insofern, als sie Zeichenwerte repräsentieren. Name Tokens sind Zeichenfolgen, die aus Buchstaben, Zahlen, Unterstrichen, Doppelpunkten, Gedankenstrichen und Punkten bestehen. Sie dürfen keine Leerzeichen enthalten. Eine Deklaration, die diese Datentypen verwendet, sollte wie folgt aussehen:
Eine Einführung in DTDs
59
Die Standarddeklaration Die Standarddeklaration kann aus beliebigen Attributwerten oder aus einem der drei vordefinierten Schlüsselwörter #REQUIRED, #IMPLIED und #FIXED bestehen. Das Schlüsselwort #REQUIRED (required – erforderlich) gibt an, dass das Attribut vorhanden sein und einen Wert haben muss. Wenn das Schlüsselwort #REQUIRED verwendet wird, gibt es keine Standardwerte. Das Schlüsselwort #IMPLIED gibt an, dass das Attribut nicht vorhanden sein muss und dass es keinen Standardwert gibt. Das Schlüsselwort #FIXED setzt das Attribut auf einen Standardwert, der nicht verändert werden darf. Der Standardwert wird nach dem Schlüsselwort #FIXED angegeben. Wird keines dieser drei Schlüsselwörter benutzt, kann ein Standardwert zugewiesen werden, falls im XML-Dokument noch kein Attributwert zugewiesen wurde.
Die überarbeitete DTD Basierend auf diesen Informationen über die Komponenten der !ELEMENT- und !ATTLISTAnweisungen lässt sich die ursprüngliche DTD wie folgt umformulieren:
target CDATA #REQUIRED> (basefont?, a?, table)> alink CDATA #IMPLIED text CDATA #IMPLIED bgcolor CDATA #IMPLIED link CDATA #IMPLIED vlink CDATA #IMPLIED> basefont EMPTY> basefont size CDATA #REQUIRED> a (#PCDATA)> a linkid ID #IMPLIED href CDATA #IMPLIED name CDATA #IMPLIED target CDATA #IMPLIED> table (tr+)> table width CDATA #IMPLIED rules CDATA #IMPLIED frame CDATA #IMPLIED align CDATA ’Center’ cellpadding CDATA ’0’ border CDATA ’0’ cellspacing CDATA ’0’> tr (td+)> tr bgcolor (Cyan | Lime | Black | White | Maroon) ’White’ valign (Top | Middle | Bottom) ’Middle’ align (Left | Right | Center) ’Center’> td (CellContent)> td bgcolor (Cyan | Lime | Black | White | Maroon) ’White’ valign (Top | Middle | Bottom) ’Middle’ align (Left | Right | Center) ’Center’ rowspan CDATA #IMPLIED colspan CDATA #IMPLIED>
Kapitel 4
CellContent cellname CDATA #REQUIRED> h1 (#PCDATA)> h1 align CDATA #IMPLIED> ImageLink (img, br?)>
p align CDATA #IMPLIED> font (#PCDATA | b)*> font color (Cyan | Lime | Black | White | Maroon) ’Black’ face ('Times New Roman '| Arial) #REQUIRED size (2 | 3 | 4 | 5 | 6) ’3’>
Das body-Element enthält zwei optionale untergeordnete Elemente namens basefont und a und ein erforderliches Element namens table. Für dieses Beispiel ist das table-Element erforderlich, weil die Informationen auf der Seite anhand einer Tabelle formatiert werden. Das a-Element dient dazu, einen Anchor für den Seitenanfang einzurichten, und das basefont-Element legt die Standardschriftgröße für den Text im Dokument fest. Weil alle Attribute des body-Elements optional sind, ist hier das Schlüsselwort #IMPLIED zu finden. Im base-Element wird das target-Attribut benötigt. Das base-Element ohne das Attribut target wäre unsinnig, weil die Spezifikation dieses Attributs der Grund für den Einsatz des base-Elements ist. Deshalb wird beim target-Attribut das Schlüsselwort #REQUIRED verwendet. Beim font-Element haben die Attribute color und size den Datentyp Aufzählung und ihnen sind Standardwerte (Black und 3) zugewiesen. Das Attribut face bleibt unverändert.
Die DTD mit einem XML-Dokument verknüpfen Nachdem die DTD nun erstellt ist, kann sie eingesetzt werden, um das Dokument Hilfe.htm auszuwerten, das in Kapitel 3 erstellt wurde. Es gibt zwei Möglichkeiten, um eine DTD mit einem XML-Dokument zu verknüpfen: Die DTD kann in das XML-Dokument integriert und ein separates DTD-Dokument erstellt werden, auf das vom XML-Dokument verwiesen wird. Wird ein separates DTD-Dokument erstellt, kann darauf von verschiedenen XML-Dokumenten
Eine Einführung in DTDs
61
verwiesen werden. Nachfolgend sehen Sie, wie eine DTD in das XML-Dokument integriert wird. Die DTD wird mit der !DOCTYPE-Anweisung deklariert. Bei einer internen DTD, auch interne Teilmenge genannt, können Sie die folgende Syntax verwenden:
Das neue XML-Dokument, das die Datei Hilfe.htm mit der DTD kombiniert, sieht wie folgt aus:
target CDATA #REQUIRED> (basefont?, a?, table)> alink CDATA #IMPLIED text CDATA #IMPLIED bgcolor CDATA #IMPLIED link CDATA #IMPLIED vlink CDATA #IMPLIED> basefont EMPTY> basefont size CDATA #REQUIRED> a (#PCDATA)> a linkid ID #IMPLIED href CDATA #IMPLIED name CDATA #IMPLIED target CDATA #IMPLIED> table (tr+)> table width CDATA #IMPLIED rules CDATA #IMPLIED frame CDATA #IMPLIED align CDATA ’Center’ cellpadding CDATA ’0’ border CDATA ’0’ cellspacing CDATA ’0’> tr (td+)> tr bgcolor (Cyan | Lime | Black | White | Maroon) ’White’ valign (Top | Middle | Bottom) ’Middle’ align (Left | Right | Center) ’Center’> td (CellContent)> td bgcolor (Cyan | Lime | Black | White | Maroon) ’White’ valign (Top | Middle | Bottom) ’Middle’ align (Left | Right | Center) ’Center’ rowspan CDATA #IMPLIED colspan CDATA #IMPLIED> CellContent (h1? | p?)+> CellContent cellname CDATA #REQUIRED> h1 (#PCDATA)> h1 align CDATA #IMPLIED> ImageLink (img, br?)>
62
Kapitel 4
]>
Helpdesk von Nordwind
Helpdesk
Eine Einführung in DTDs
63
Informationen fuer erstmalige Besucher
Sicher einkaufen bei Nordwind
Frequently Asked Questions (FAQ)
Navigation im Web
Fuer erstmalige Besucher
Preise
Status der Bestellung
Retouren
Versand
64
Kapitel 4
Der XML-Text ist bis auf eine Ausnahme unverändert geblieben. Die Elemente des Datentyps Aufzählung dürfen kein Attribut enthalten, das auf eine leere Zeichenfolge ("") gesetzt ist. Wenn beispielsweise ein tr-Element kein align-Attribut verwendet, muss dieses Attribut entfernt werden. Weil in der DTD dem align-Attribut des tr-Elements ein Standardwert (Center) zugewiesen wurde, kommt dieser nur zum Einsatz, wenn das Attribut fehlt. Wenn Sie dieses Dokument im Browser öffnen, werden Sie feststellen, dass es fast funktioniert. Die schließenden Klammern (]>), die zur !DOCTYPE-Anweisung gehören, werden jedoch im Browser angezeigt, und das ist nicht akzeptabel. Um dieses Problem zu lösen, speichern Sie die Original-DTD in einer Datei namens StandardHTM.dtd, löschen die leeren Attribute des Aufzählungstyps und verweisen in der neuen Datei namens HilfeHTM.htm auf die externe Datei StandardHTM.dtd. Der Verweis auf eine externe DTD hat folgendes Format:
Stammelementname ist der Name des Stammelements (im Beispiel html). Das Schlüsselwort SYSTEM wird benötigt, wenn eine nicht veröffentlichte DTD verwendet wird. Um eine DTD zu veröffentlichen und zu benennen, kann das Schlüsselwort PUBLIC eingesetzt werden. Wenn der Parser den Namen nicht identifizieren kann, wird der DTD-URI benutzt. Im DTD-URI muss die DTD über die Angabe des Typs und der Adresse gekennzeichnet werden. Ein URI (URI – Uniform Resource Identifier) ist eine allgemeine Art von Systembezeichner. Der URL (URL – Uniform Resource Locator), den Sie bereits aus dem Internet kennen, ist eine Art von URI. Im Beispiel müsste der folgende externe Verweis auf die DTD an den Anfang des Dokuments HilfeHTM.htm gesetzt werden:
Ein nicht XML-fähiger Browser ignoriert diese Anweisung. Die externe DTD bietet nicht nur die Möglichkeit, die Gültigkeit eines XML-Dokuments zu überprüfen, sondern das XML-Dokument lässt sich auch in einem beliebigen Browser anzeigen.
Zusammenfassung Sie wissen nun, wie eine DTD eingerichtet wird, mit der ein Satz von Regeln definiert wird, anhand derer sich die Gültigkeit von XML-Dokumenten überprüfen lässt. Mit DTDs lässt sich eine Standardregelmenge entwickeln, mittels derer sich Standard-XML-Dokumente erstellen lassen. Diese Dokumente lassen sich zwischen Unternehmen oder intern zwischen Abteilungen eines Unternehmens austauschen und anhand der DTD überprüfen. Mit der DTD lassen sich auch Standarddokumente innerhalb einer Gruppe erzeugen, wie z. B. die Gruppe, die eine E-Commerce-Site einrichtet. In Kapitel 5 werden Entitäten genauer betrachtet. Anhand von Entitäten lassen sich in einer DTD wiederverwertbare Zeichenfolgen erzeugen.
Eine Einführung in DTDs
65
5 67 68 85 90 91 92
Entitäten und andere Komponenten
Überblick über Entitäten Interne Entitäten Externe Entitäten Verarbeitungsreihenfolge Konditionale Abschnitte Zusammenfassung
In Kapitel 4 wurden zwei Komponenten der Dokumenttypdefinition (DTD) beschrieben: Elemente und Attribute. In diesem Kapitel werden einige weitere Komponenten betrachtet, die zu der DTD hinzugefügt werden können. Das Hauptaugenmerk liegt auf den Entitäten, mit denen Text repräsentiert wird, der Bestandteil der DTD oder des XML-Dokuments sein kann. Mit einer Entität lässt sich beispielsweise eine lange Deklaration repräsentieren. Anschließend kann diese Entität in der DTD verwendet werden. Mit Entitäten lässt sich auch eine allgemeine Datei erstellen, die einen Satz von Standarddeklarationen enthält, die von vielen DTDs gemeinsam genutzt werden können.
Überblick über Entitäten Entitäten ähneln Makros der Programmiersprache C, da sich damit eine Zeichenfolge mit einem Namen verknüpfen lässt. Dieser Name kann dann in jeder DTD oder dem XML-Dokument eingesetzt werden. Der XML-Parser ersetzt den Namen durch die Zeichenfolge. Alle Entitäten bestehen aus drei Teilen: dem Wort ENTITY, dem Namen der Entität (der so genannte wörtliche Entitätswert) und dem Ersetzungstext – d. h. der Zeichenfolge, durch die der Entitätsname ersetzt wird. Entitäten werden entweder in einer internen oder einer externen DTD deklariert. Es gibt verschiedene Arten von Entitäten, die davon abhängen, woher der Text stammt, durch den der Name ersetzt wird, und wo die Entitäten platziert werden. Interne Entitäten erhalten den Ersetzungstext aus der DTD innerhalb der Deklaration. Externe Entitäten beziehen den Ersetzungstext aus einer externen Datei. Interne und externe Entitäten lassen sich außerdem in allgemeine Entitäten und Parameterentitäten unterteilen. Allgemeine Entitäten kommen in XML-Dokumenten zum Einsatz und Parameterentitäten in DTDs.
67
Interne allgemeine Entitäten, interne Parameterentitäten und externe Parameterentitäten enthalten immer Text, der geparst werden sollte. Weil externe Entitäten im Hauptteil (body) eines Dokuments stehen und weil Sie möglicherweise auch Nichttextdateien wie Bilder in den Hauptteil des Dokuments integrieren möchten, können externe allgemeine Entitäten analysiert (parsed) oder nicht analysiert (unparsed) sein. Externe analysierte allgemeine Entitäten dienen dazu, XML-Anweisungen aus externen Dateien in das XML-Dokument zu integrieren. Externe nicht analysierte allgemeine Entitäten werden verwendet, um Informationen in das XML-Dokument aufzunehmen, die nicht textbasiert sind und auch nicht geparst werden sollten. Es gibt somit fünf Kategorien von Entitäten: interne allgemeine Entitäten, interne Parameterentitäten, externe analysierte allgemeine Entitäten, externe nicht analysierte allgemeine Entitäten und externe Parameterentitäten. Abbildung 5.1 veranschaulicht, woher der Ersetzungstext für jede Entitätenkategorie stammt (die Punkte) und wohin er gelangt (die Pfeile).
DTD Externe Parameterentität
ExternalDTD.xml XML-DTDFragment
Deklaration interne Parameterentität Interne Parameterentität Deklaration interne allgemeine Entität XML Document Body Interne allgemeine Entität Externe analysierte allgemeine Entität
ExternalBody.xml XML-BodyFragment
Image.gif Externe nicht analysierte allgemeine Entität
Binärdaten
Abbildung 5.1: Quelle und Ziel des Ersetzungstextes für die fünf Entitätenkategorien
Interne Entitäten Beginnen wir nun mit den internen Entitäten. Eine Entität, die nur in einer DTD verwendet wird, kann eine interne Entität sein. Wenn Sie beabsichtigen, die Entität in mehreren DTDs zu verwenden, sollten Sie jedoch besser eine externe Entität verwenden. In diesem Abschnitt wird veranschaulicht, wie interne Entitäten deklariert werden, wo sie eingefügt werden und wie auf sie verwiesen wird.
68
Kapitel 5
Interne allgemeine Entitäten Interne allgemeine Entitäten sind die einfachsten Entitäten. Sie werden im DTD-Abschnitt des XML-Dokuments wie im folgenden Abschnitt beschrieben definiert. Deklaration interner allgemeiner Entitäten Interne allgemeine Entitäten werden mit der folgenden Syntax deklariert:
HINWEIS Wie Sie der Syntaxzeile entnehmen können, werden spitze Klammern (< >) und Anführungszeichen (" ") speziell für die Auszeichnung des XML-Dokuments eingesetzt. Als Inhalt lassen sie sich nicht direkt verwenden. Um eine spitze Klammer oder ein Anführungszeichen als Inhalt zu nutzen, müssen Sie eine von XMLs fünf vordefinierten Entitäten verwenden. Die eigentlichen Entitätswerte für diese vordefinierten Entitäten sind die folgenden: &, , " und '. Der Ersetzungstext für diese wörtlichen Entitätswerte ist &, , " und ’. Sie können auch eigene allgemeine Entitäten erstellen. Allgemeine Entitäten sind nützlich, um Namen mit ausländischen Zeichen wie é oder Escapezeichen wie und & zu verbinden. So lassen sich beispielsweise Unicode-Zeichen in XML-Dokumenten als Ersatz für jedes Zeichen nutzen, das im Unicode-Standard definiert ist. Diese werden als Zeichenverweise definiert. Um ein Unicode-Zeichen in einem XML-Dokument zu nutzen, müssen Sie dem Zeichen die Angabe &# voranstellen. Sie können entweder den Hexadezimalcode oder den Dezimalcode verwenden. In Unicode wird der Buchstabe ü beispielsweise durch xFC repräsentiert und ß durch xDF. Die Dezimalwerte der Zeichen sind 252 und 223. Somit werden allgemeine Entitäten in DTDs für die beiden Zeichen ü und ß wie folgt erzeugt.
Die beiden Entitäten ließen sich auch wie folgt deklarieren:
Interne allgemeine Entitäten einsetzen Um im XML-Dokument auf eine allgemeine Entität zu verweisen, muss der Entität ein kaufmännisches Und-Zeichen (&) vorangestellt und ein Semikolon (;) angehängt werden. Die folgende XML-Anweisung verweist auf zwei allgemeine Entitäten, die im letzten Abschnitt deklariert wurden: Gr&u_um;&s_sh;e
Nachdem der Ersetzungstext vom Parser eingefügt wurde, sieht die Zeile wie folgt aus: Grüße
Interne allgemeine Entitäten lassen sich an drei Stellen einsetzen: im XML-Dokument als Inhalt für ein Element, in der DTD als Standardwert für ein Attribut oder als Attributwert des Typs #FIXED und in anderen allgemeinen Entitäten in der DTD. Im letzten Beispiel wurde die erste Möglichkeit genutzt (Gr&u_um;&s_sh;e). Die zweite Stelle, an der Sie eine interne allgemeine Entität einsetzen können, ist innerhalb einer DTD als Standardwert für ein Attribut oder als Attributwert des Typs #FIXED. Sie können
Entitäten und andere Komponenten
69
z. B. die folgenden allgemeinen Entitäten in Ihrer DTD-Deklaration nutzen, um Entitäten für verschiedene Farben zu erzeugen:
"Lime"> "Black"> "White"> "Maroon">
Wenn der Wert des Attributs bgcolor für das tr-Element in allen XML-Dokumenten, die die DTD benutzen, auf White gesetzt sein soll, können Sie die folgende Zeile in die vorhergehende DTD-Deklaration aufnehmen:
Die internen allgemeinen Entitäten müssen definiert werden, bevor sie als Standardwerte eines Attributs eingesetzt werden können, weil die DTD ein Mal vom Anfang bis zum Ende durchgelesen wird. In diesem Fall wurden interne allgemeine Entitäten für verschiedene Farben eingerichtet. Das Attribut bgcolor wurde mit dem Schlüsselwort #FIXED deklariert, was bedeutet, dass dieser Wert nicht vom Benutzer verändert werden kann. Der Wert ist immer weiß (White). Die allgemeine interne Entität für die Farbe könnte auch als Inhalt für die Elemente im bodyAbschnitt des XML-Dokuments genutzt werden. Eine interne allgemeine Entität kann auch als Standardwert eingesetzt werden, wie z. B. bei bgcolor CDATA "&Wh;". In diesem Fall wird, falls kein Wert angegeben wird, &Wh für bgcolor eingesetzt, wenn das XML-Attribut im Hauptteil des Dokuments benötigt wird. Diese Referenz wird dann in White konvertiert. HINWEIS Eine interne allgemeine Entität kann in einer DTD auch für ein Attribut des Typs #FIXED eingesetzt werden. Der Attributwert wird im Hauptteil des XML-Dokuments jedoch nur dann zugewiesen, wenn auf das Attribut verwiesen wird. Eine interne allgemeine Entität kann nicht bei Attributen des Aufzählungstyps verwendet werden, weil die allgemeine Entität in der DTD interpretiert werden müsste, und dies ist nicht möglich. Interne allgemeine Entitäten können außerdem innerhalb anderer allgemeiner Entitäten in der DTD verwendet werden. Die bereits bekannte Entität für Sonderzeichen könnte beispielsweise wie folgt eingesetzt werden:
#IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED #IMPLIED"
Dieser Code deklariert eine Parameterentität namens events (Ereignisse), die als Attribut für alle Objekte verwendet werden kann, die diese Attribute beinhalten. HINWEIS Sie hätten auch eine Parameterentität namens Script deklarieren und diese dann in der Parameterentitätsdeklaration events wie folgt nutzen können:
name = "align" minOccurs = "0" default = "Center" "string"/>
Das attributeGroup-Element Wie Sie in der vereinfachten Schema-DTD im Abschnitt »Eine DTD für Schemas« sehen können, gibt es bei Schemas nichts Vergleichbares zur DTD-Parameterentität, die für Attribute verwendet wird. Bei Schemas lässt sich mit dem attributGroup-Element jedoch etwas Ähnliches erzeugen. Attributgruppen, die mit dem attributeGroup-Element deklariert werden, können entweder lokal oder auf Dokumentebene gültig sein. (Das Element kann in die Deklaration des schema-Elements oder in die des complexType-Elements aufgenommen werden.) In der ursprünglichen Version des Schemas wurden alle Attribute ohne das attributeGroup-Element definiert. Die Beispiel-DTD, die Sie in Kapitel 5 erzeugt haben, enthielt eine Parameterentität namens attrs. In einem Schema lässt sich die Attributgruppe namens attrs wie folgt definieren:
XML-Schemas
125
.. .
Und attrs kann wie folgt eingesetzt werden:
.. .
Somit wird das attributeGroup-Element als untergeordnetes Element des schema-Elements deklariert, um eine Gruppe von Attributen zu erzeugen, die im gesamten Dokument gültig sind. Auf das attributeGroup-Element kann dann in einem type-Element verwiesen werden, indem das ref-Attribut auf den Namen der Gruppe gesetzt wird. Wie Sie sehen, vereinfacht dies das Schema erheblich. HINWEIS Attributgruppen können nur einfache Datentypen enthalten.
Das group-Element Mit dem group-Element lassen sich Elemente auf dieselbe Weise gruppieren wie bei der Verwendung von Klammern zur Gruppierung von Elementen in einer DTD. Mit dem group-Element lässt sich auch etwas Ähnliches wie eine DTD-Parameterentität erzeugen. Die Reihenfolge der Elemente im group-Element kann entsprechend der Definition des order-Attributs variieren. Die Deklaration eines group-Elements sieht wie folgt aus:
Ein group-Element kann optional ein annotation-Element (für Kommentare) enthalten und muss ein all-, ein choice- oder ein sequence-Element enthalten. Diese Elemente definieren die Reihenfolge und die Verwendung der Elemente in der Gruppe und werden im nächsten Abschnitt ausführlich beschrieben. Beachten Sie, dass group-Elemente keine Attribute enthalten, da sie nur zur Gruppierung von Elementen eingesetzt werden. Die Attribute minOccurs und maxOccurs geben an, wie häufig das group-Element vorkommen darf. Sie ersetzen die Marker (*, ? und +) in der DTD.
126
Kapitel 7
Die Elemente choice, sequence und all Das choice-Element gibt eine Auswahl von Elementen im group-Element an – es funktioniert genauso wie der senkrechte Strich (|) in der DTD. Die DTD-Deklaration entspricht somit der folgenden Schemadeklaration:
Das sequence-Element gibt an, dass die Elemente in der aufgeführten Reihenfolge auftreten müssen und dass jedes Element 0 Mal oder häufiger vorkommen darf. Beim sequence-Element können Sie minOccurs und maxOccurs als Attribute verwenden, um anzugeben, wie oft ein element-Element in der Gruppe enthalten sein darf. Das sequence-Element hat dieselbe Funktion wie das Kommatrennzeichen in der DTD im Zusammenhang mit Untergruppen, die in Klammern gesetzt sind. In seiner einfachsten Form kann ein sequence-Element aus nur einem Element bestehen. Die DTD-Deklaration würde als Schemadeklaration folgendermaßen aussehen:
Die DTD-Deklaration entspräche folgender Schemadeklaration:
Das Element all gibt an, dass alle element- und group-Elemente, die im Schema aufgelistet sind, in beliebiger Reihenfolge benutzt werden müssen. Bei allen element-Elementen in einem all group-Element müssen die Attribute minOccurs und maxOccurs auf 1 gesetzt sein. Die Attribute minOccurs und maxOccurs dürfen beim group-Element im Zusammenhang mit dem allElement nicht benutzt werden. Sie können nur für die element-Elemente in der Gruppe eingesetzt werden. Ein group-Element, bei dem order auf all gesetzt wurde, darf keine Untergruppe eines anderen group-Elements sein. Weil jedes HTML-Dokument beispielsweise nur ein headund ein body-Element enthalten darf, könnten Sie diese Elemente in Ihrem Schema beispielsweise wie folgt deklarieren:
XML-Schemas
127
Lokale eingebettete Gruppen Wenn die Deklaration des group-Elements in ein complexType-Element integriert wird, wird die Deklaration in das complexType-Element eingebettet. Wird das group-Element im complexType-Element definiert, ist es von anderen Stellen im Schemadokument aus nicht sichtbar – es hat nur lokalen Geltungsbereich. Soll das group-Element nur ein Element enthalten, ist es sinnvoll, eine lokale Gruppe zu verwenden. Platzhalter, Partikel und Kompositoren Gemäß der Schemaspezifikation bezieht sich der Begriff Partikel (particle) auf den Inhalt eines element-Elements, das nur andere Elemente, Gruppen und Platzhalter enthält, also keinen Text. Zu den Platzhaltern gehören verschiedene Möglichkeiten, das Schlüsselwort any zu benutzen. HINWEIS Das Schlüsselwort any entspricht dem Schlüsselwort ANY in DTDs. In einem Schema bezieht sich any jedoch nur auf element- und group-Elemente. In einer DTD bezieht sich ANY dagegen auf Text und Elemente. Text ist in der Schemaspezifikation kein Bestandteil des Schlüsselworts any. Das Schlüsselwort any bietet die Möglichkeit, auf alle element- oder group-Elemente im angegebenen Namespace und Schema als complexType-Element zu verweisen. Wenn dieses Schlüsselwort innerhalb eines complexType-Elements eingesetzt wird, kennzeichnet dies, dass alle Elemente oder Gruppen im Schema, die im selben Namespace enthalten sind wie das complexType-Element, in dieses complexType-Element aufgenommen werden können. Wenn der Namespace den Wert ##targetNamespace hat, werden alle Elemente im aktuellen Dokument benutzt. Eine weitere Möglichkeit besteht darin, auf alle element- und group-Elemente in einem Namespace zu verweisen, in dem das complexType-Element nicht enthalten ist. Hierfür dient die folgende Deklaration:
In einem Schema definieren das order-Element und die Attribute minOccurs und maxOccurs zusammen den Kompositor (compositor). Ein Kompositor für ein vorgegebenes group-Element gibt an, ob Elemente in der Gruppe die folgenden Bedingungen erfüllen: b Eine Folge von Elementen, die von den angegebenen Partikeln benötigt oder zugelassen werden b Die Auswahl zwischen Elementen, die von den angegebenen Partikeln benötigt oder zugelassen werden b Eine wiederholte Auswahl zwischen den Elementen, die von den angegebenen Partikeln zugelassen oder benötigt werden b Elemente, die von den angegebenen Partikeln zugelassen oder benötigt werden Nun lässt sich die Definition präziser formulieren: Eine Gruppe besteht aus mindestens zwei Partikeln und einem Kompositor. Gruppen mit Dokumentgeltungsbereich So wie complexType-Elemente mit Dokumentgeltungsbereich erzeugt werden können, lassen sich auch group-Elemente mit Dokumentgeltungsbereich einrichten. Dieselben Grundregeln lassen sich anwenden, d. h. es muss ein name-Attribut integriert werden und die Elemente müssen als untergeordnete Elemente des schema-Elements deklariert werden. Auf diese Weise lassen sich beispielsweise die folgenden globalen group-Elemente erzeugen:
128
Kapitel 7
.. .
Diese Deklaration gibt an, dass alle Elemente, die diese Gruppe benutzen, mindestens eines dieser Elemente beinhalten müssen. Der Inhalt des Elements kann auch aus einer beliebigen Anzahl dieser Elemente in einer beliebigen Reihenfolge bestehen. Diese Deklaration ist identisch mit der nachfolgenden DTD-Deklaration:
Somit können Sie mit group-Elementen mit Dokumentgeltungsbereich etwas Ähnliches wie die Parameterentitäten in DTDs erzeugen, die Elementdeklarationen enthalten. Sie können das group-Element nun wie folgt einsetzen:
XML-Schemas
129
complexType-Elemente mit Dokumentgeltungsbereich Nachdem die group- und attributeGroup-Elemente nun ausführlich besprochen wurden, sollen die complexType-Elemente mit Dokumentgeltungsbereich genauer beschrieben werden. Wenn es eine Gruppierung von Attributen und Elementen gibt, die von mehr als einem element-Element verwendet werden, kann ein complexType-Element mit Dokumentgeltung erstellt werden. Dieses wird genauso deklariert wie das eingebettete complexType-Element. Die Deklaration enthält jedoch das name-Attribut und ist nicht in einem element-Element enthalten. Das heißt also, dass es sich außerhalb einer element-Elementdeklaration befindet. Somit wird es als untergeordnetes Element des schema-Elements deklariert. Alle h-Elemente benutzen beispielsweise gemeinsam einen Satz untergeordneter Elemente und Attribute. Ein globales complexType-Element ließe sich beispielsweise wie folgt deklarieren und einsetzen:
.. .
Das complexType-Element lässt sich auch mit dem base-Attribut erweitern. Das li-Element benutzt beispielsweise den gesamten vorherigen Inhalt und verschiedene andere Elemente. Das Beispiel für das complexType-Element lässt sich wie folgt erweitern:
130
Kapitel 7
.. .
Um ein complexType-Element zu erweitern, werden das base- und das derivedBy-Attribut des complexType-Elements benötigt. Das base-Attribut gibt die Quelle des Elements an und kann entweder #all, ein einzelnes Element oder eine Liste mit Leerzeichen als Trennzeichen als Wert enthalten. Das derivedBy-Attribut kann auf die Werte restriction, extension und reproduction gesetzt werden. Wenn Elemente oder Attribute zu einem complexType-Element hinzugefügt werden, sollte das derivedBy-Attribut auf extension gesetzt werden. Der Wert restriction für das derivedBy-Attribut gestattet es, Beschränkungen zu element-Elementen hinzuzufügen, die im complexType-Element enthalten sind. Für element-Elemente, die im ursprünglichen complexType-Element enthalten sind, kann die Anzahl der Vorkommnisse eines Elements beschränkt werden und es ist auch möglich, einen Platzhalter durch eines oder mehrere Elemente zu ersetzen. Damit ein a-Element beispielsweise mindestens ein Mal vorkommt und das br-Element in einem neuen complexType-Element auf der Basis des standardcontent-Typs, der im letzten Beispiel definiert wurde, entfernt wird, könnte der folgende Code benutzt werden:
Für Attribute lassen sich Standardwerte hinzufügen oder festlegen und es ist auch möglich, die einfache Datentypdefinition eines Attributs zu beschränken. Wenn das Attribut derivedBy auf den Wert reproduction gesetzt wird, ist das neue Element identisch mit demjenigen, von dem es abgeleitet wurde. Der Wert reproduction gibt im Wesentlichen an, dass es sich nicht um eine Beschränkung wie beim Wert restriction oder um eine Erweiterung wie beim Wert extension handelt. Wenn der Wert für das Attribut final des complexType-Elements nicht leer ist, kann das complexType-Element nicht erweitert, beschränkt oder reproduziert werden. Ein complexType-Element, das durch Erweiterung, Beschränkung oder Reproduktion abgeleitet wird, kann ebenfalls weder erweitert noch beschränkt oder reproduziert werden. Das block-Attribut gestattet die Blockierung der Erweiterung, Beschränkung oder Reproduktion. Wird das Attribut block auf den Wert restriction gesetzt, darf das complexType-Element nicht benutzt werden, um einen neuen komplexen Typ durch Beschränkung zu erzeugen.
XML-Schemas
131
Ein Schema für ein datenorientiertes XML-Dokument Das Beispiel, das bisher benutzt wurde, war ein dokumentorientiertes XML-Dokument, das nur string-Daten enthielt. Damit Sie sehen, wie andere Datentypen funktionieren, wird in diesem Abschnitt ein Beispiel mit der Datenbank Northwind erzeugt. (Diese Datenbank ist in deutscher Version in Microsoft Access, Visual Studio und Microsoft SQL Server 7 enthalten.) Für die Tabellen Customers und Categories könnten Sie das nachfolgende Schema erzeugen:
body bodyText CDATA #REQUIRED> HTML:body EMPTY> HTML:body HTML:bodyText CDATA #REQUIRED>
Ein gültiger Einsatz dieser DTD sieht wie folgt aus:
Die folgende Benutzung wäre dagegen ungültig, weil das HTML:body-Element nicht als untergeordnetes Element des doc-Elements definiert ist:
Was die DTD betrifft, sind das HTML:body-Element und das body-Element völlig verschieden. Eine DTD kann keinen Namespace auflösen und in sein Präfix (HTML) und den Namen (body) aufteilen. Somit werden das Präfix und der Name einfach zu einem Wort. Wir wollen Namespace benutzen, aber auch in der Lage sein können, das Präfix vom Namen zu trennen. Schemas ermöglichen dies.
134
Kapitel 7
Schemas in denselben Namespace aufnehmen Es ließe sich ein ähnliches Schema mit einem Namespace erzeugen, um die schema-Elemente zu identifizieren. Ein Beispiel wäre das Schema NorthwindMessage.xsd, das nachfolgend gezeigt wird:
HINWEIS Dem Schema-Namespace wurde kein Präfix zugewiesen. Deshalb handelt es sich um den Standard-Namespace. Alle Elemente ohne Präfix gehören zu den Schema-Namespaces. Wenn Elemente benutzt werden, die im Schema definiert werden, muss der Namespace des Schemas wie bei den Elementen body und HTMLbody gezeigt verwendet werden. In Schemas lassen sich die Elemente body und HTMLbody von ihren Namespace-Präfixen trennen und korrekt identifizieren. Die eingebundene Datei HTMLMessage.xsd würde dann wie folgt aussehen:
HINWEIS In diesem Fall wurde dem Schema-Namespace ein Präfix zugewiesen, und dieses Präfix wurde im gesamten Dokument benutzt. Es sind beide Methoden zulässig. Sie sollten jedoch bedenken, dass Standardeinstellungen manchmal schwieriger zu interpretieren sind. Wie Sie sehen, spielen Namespaces bei Schemas eine entscheidende Rolle. Betrachten Sie nun die verschiedenen Elemente, die in diesem Beispiel enthalten sind. Beide Dokumente enthalten ein targetNamespace-Element. Das targetNamespace-Element definiert den Namespace, zu dem dieses Schema gehört (http://www.northwindtraders.com/Message). Denken Sie daran, dass ein Namespace einen URI als eindeutigen Bezeichner verwendet und nicht, um Dokumente zu beziehen (eine Anwendung könnte den Namespace jedoch dazu verwenden, um das mit dem Dokument verknüpfte Schema zu identifizieren). Es bleibt der Anwendung überlassen, festzustellen, wie der Namespace benutzt wird. Das include-Element hat ein schemaLocationAttribut, anhand dessen eine Anwendung oder eine Person feststellen kann, wo das Schema gespeichert ist.
XML-Schemas
135
Die Datei HTMLMessage.xsd wird mit dem include-Element in die Datei NorthwindMessage.xsd eingebunden. Damit ein Schema in ein anderes Schema eingebunden werden kann, müssen beide zum selben Namespace gehören. Statt des include-Elements wird dann das referenzierte Schema integriert. Nachdem diese Einfügung vorgenommen wurde, sollte das Schema noch immer ein wohlgeformtes XML-Dokument sein. Es lässt sich ein übergeordnetes Schema erzeugen, das zahlreiche andere Schemas einbindet. Beachten Sie, dass simpleType TextBody im eingebundenen Dokument deklariert, jedoch in den Dokumenten auf oberster Ebene verwendet wird. Diese Trennung macht keinen Unterschied, da beide Dokumente von der verarbeitenden Anwendung zu einem Dokument zusammengefügt werden. Das XML-Dokument, das auf dem Schema basiert, wird als Instanzdokument bezeichnet. Dieses Instanzdokument enthält nur eine Referenz auf das Toplevel-Schema. Somit würde das Instanzdokument für das Beispielschema wie folgt aussehen:
Es wäre auch das folgende Instanzdokument möglich:
Was das Instanzdokument betrifft, stammen alle Elemente aus dem Toplevel-Schema. Dem Instanzdokument ist nicht bekannt, dass das HTMLbody-Element eigentlich aus einem anderen Schema stammt, weil das Schema alle Namespaces auflöst.
Schemas aus einem anderen Namespace integrieren Mit dem include-Element wird das gesamte referenzierte Schema in das Toplevel-Schema integriert, und bei beiden Dokumenten muss das targetNamespace-Attribut denselben Wert haben. Möglicherweise möchten Sie jedoch Schemadokumente erzeugen, die simpleType- und complexType-Deklarationen enthalten, die Sie in mehreren Schemas benutzen können. Wenn diese Schemas jedoch unterschiedliche targetNamespace-Attribute haben, kann das include-Element nicht für ein Dokument eingesetzt werden, das von allen gemeinsam genutzt wird. Hier kommt stattdessen das import-Element zum Einsatz. Mit dem import-Element lässt sich jeder Datentyp referenzieren, der im importierten Dokument erzeugt wurde, und, wie nachfolgend gezeigt, erweitern oder beschränken:
136
Kapitel 7
Die Datei HTMLTypes.xsd könnte wie folgt aussehen:
Im Toplevel-Schema wurde der Namespace namens http://www.northwindtraders.com/Types mit dem Präfix northwindType kombiniert. Mit dem import-Element lässt sich dieser Namespace nun mit einem Speicherplatz für ein Schema verknüpfen. Die Anwendung findet dann heraus, wie das schemaLocation-Attribut zu benutzen ist. Anschließend kann der Datentyp eingesetzt werden. Ein Instanzdokument für dieses Schema wird nachfolgend gezeigt:
Auch hier spielt es, was das Instanzdokument betrifft, keine Rolle, wo die Datentypen definiert sind. Es stammt alles vom Toplevel-Dokument.
Datentypen überschreiben Mit Namespaces lässt sich ein Schema aus anderen Schemas erzeugen, und es lassen sich Datentypen aus anderen Schemas einbinden. In beiden Fällen verwendet das Instanzdokument nur das Toplevel-Schema. Es ist jedoch auch möglich, ein Element mit einem bestimmten Datentyp zu deklarieren und diesen Datentyp dann im Instanzdokument zu überschreiben. Betrachten Sie das folgende Toplevel-Schema:
XML-Schemas
137
Bei diesem Schema wurde das doc-Element als Element des Datentyps Body definiert, und es enthält außerdem ein body-Element, das ein bodyText-Attribut hat. Angenommen, es soll auch möglich sein, Nachrichten mit anderen Body-Datentypen zu erzeugen, wie z. Β. mit dem Datentyp HTMLBodyCT, der im Schema definiert wird. Dazu müsste ein group-Element mit choices erstellt werden. Eine weitere Option besteht darin, das Schema wie oben zu deklarieren und dann den Datentyp Body im Instanzdokument durch den Datentyp HTMLBodyCT zu ersetzen. Dazu muss der Namespace des Schemas im Instanzdokument referenziert werden. Um den Datentyp HTMLBodyCT benutzen zu können, müsste ein Instanzdokument wie das folgende erzeugt werden:
"Hello, world"
In diesem Beispiel wurde das Attribut xsi:type benutzt, um einen Typ zu referenzieren, der im Schema definiert wurde (HTMLBodyCT). Der Teil xsi:type des Namespaces der Schemainstanz dient dazu, den Typ eines Elements mit einem anderen zu überschreiben, der im Schema definiert ist. In diesem Beispiel wurde das Element doc so umdefiniert, dass es nun den Datentyp HTMLBodyCT statt des Datentyps Body hat. Es wäre auch möglich gewesen, den Datentyp HTMLBodyCT in einem separaten Schema zu definieren und mit dem include-Element in das Toplevel-Schema zu integrieren.
Zusammenfassung Mit Schemas lassen sich Datentypen mit Attributen verknüpfen sowie eigene Datentypen erstellen, und sie machen es möglich, die Struktur eines Dokuments mit wohlgeformtem XML zu definieren. Mit Schemas können Elemente definiert werden, die mit einem Namen und einem Typ verknüpft sind. Der Typ ist entweder ein Datentyp oder er besteht aus einem oder mehreren Attributen oder Elementen. Elemente lassen sich in group-Elementen gruppieren und Attribute in attributeGroup-Elementen. Die group- und die attributeGroup-Elemente können lokal benutzt werden oder global, also im gesamten Dokument, gültig sein. Schemas bieten gegenüber DTDs viele Vorteile, wie z. B. die Verwendung von Namespaces und zahlreicher Datentypen, und sie sind in XML geschrieben. Schemas werden DTDs sehr wahrscheinlich in den nächsten Jahren immer stärker verdrängen. Schemas werden in Kapitel 8 im Zusammenhang mit BizTalk und in Kapitel 11 im Zusammenhang mit dem Document Object Model (DOM) noch einmal ausführlicher betrachtet.
138
Kapitel 7
8 139 140 141 143 151 151
SOAP
Kommunikation über verteilte Systeme SOAP und das Request/Response-Modell HTTP-Header und SOAP Einfache SOAP-Nachrichten SOAP-Kodierung Zusammenfassung
Simple Object Access Protocol (SOAP) Version 1.1 ist ein Industriestandard, der entwickelt wurde, um die plattformübergreifende Funktionsfähigkeit von Web und XML zu verbessern. Das Web entstand dadurch, dass statische Seiten mit benutzerdefiniertem Inhalt erzeugt wurden, der für die Benutzer bestimmte Zwecke erfüllt. Ein Benutzer kann ein Kunde sein, der bestimmte Webseiten abruft, um Bestellungen aufzugeben, oder ein Geschäftspartner, der ein personalisiertes Formular benutzt, um sich Aktienkurse und Verkaufszahlen anzusehen. Um diese webbasierten Dienste bereitzustellen, sind zahlreiche Komponenten erforderlich, die auf verschiedenen Computern gespeichert sind. Weil diese Systeme aus zahlreichen Computern bestehen, zu denen der Clientcomputer, Server der mittleren Schicht und normalerweise ein Datenbankserver gehören, werden sie als verteilte Systeme bezeichnet. Um zu verstehen, wie SOAP funktioniert, betrachten Sie nun zunächst, wie ein verteiltes System funktioniert.
Kommunikation über verteilte Systeme Verteilte Systeme verwenden normalerweise zwei Modelle für die Kommunikation: die Nachrichtenübergabe (die mit der Nachrichtenwarteschlange kombiniert werden kann) und das Request/Response-Nachrichtensystem. In einem Nachrichtenübergabesystem können Nachrichten jederzeit gesendet werden. Nachdem eine Nachricht versendet wurde, arbeitet die Anwendung, die die Nachricht gesendet hat, normalerweise weiter. Diese Art von System wird als asynchron bezeichnet. Ein asynchrones System arbeitet in der Regel nachrichtenbasiert, es kann jedoch auch auf anderen Modellen basieren. Beim Request/Response-Modell werden die Anforderung (request) und die Antwort (response) gepaart und können als synchrones System betrachtet werden. Die Anforderung wird von einer Anwendung gesendet und diese wartet dann, bis die Antwort eintrifft, bevor sie ihre Arbeit fortsetzt. Wenn eine Anwendung ein Objekt auf
139
einem anderen Computer über einen Remoteprozeduraufruf (RPC – Remote Procedure Call) aufruft, ist dies praktisch eine synchrone Request/Response-Nachrichtenübergabe. Das Request/Response-Modell wird normalerweise eingesetzt, um Komponenten auf verschiedenen Computern die Kommunikation über RPCs zu ermöglichen. In den letzten Jahren wurden zahlreiche Versuche unternommen, einen Standard zu entwickeln, der diese Kommunikation zwischen Komponenten auf verschiedenen Computern ermöglicht. Momentan werden die beiden Standards Distributed Component Object Model (DCOM) und das Internet Inter-Orb Protocol (IIOP) der Management Group am häufigsten eingesetzt. Beide Standards funktionieren gut. Der größte Nachteil ist, dass sie nicht kompatibel sind. Deshalb ist es nicht möglich, von einem Client aus eine Komponente auf einem Server aufzurufen, ohne zu wissen, welchen Standard der Server benutzt. Normalerweise muss der Client auch so konfiguriert werden, dass er mit dem Server kommunizieren kann. Dies gilt insbesondere dann, wenn das Thema Sicherheit berücksichtigt werden muss. DCOM funktioniert am besten, wenn alle Computer im System unter Microsoft-Betriebssystemen laufen. Ein IIOP-System funktioniert dann am besten, wenn alle Computer im System denselben CORBA Object Request Broker (ORB) benutzen.1 HINWEIS IIOP ist nur eine Spezifikation. Die Implementierung in Form eines ORB bleibt den einzelnen Herstellern überlassen. Momentan gibt es viele verschiedene ORBs. Bei einem internen System ist es eventuell möglich, eine Beschränkung auf eine Plattform einzuführen. Wird das Intranet aber auf Extranets erweitert, wie z. B. Netzwerke, die das Unternehmen und seine Partner beinhalten, oder kommt das Internet ins Spiel, ist es unmöglich, im gesamten System eine einheitliche Plattform zu benutzen. DCOM und IIOP erlauben dann keine Kommunikation zwischen den Systemkomponenten mehr und mit keinem dieser Standards können Benutzer die Grenzen von Vertrauensdomänen überschreiten. Deshalb wird für umfangreichere Systeme, die mehrere Computerplattformen beinhalten, eine Methode benötigt, die den Objekten die Kommunikation erlaubt. Diese Methode heißt SOAP.
SOAP und das Request/Response-Modell Der SOAP-Standard führt keine neuen Konzepte ein, sondern basiert vollständig auf bereits bestehender Technologie. Zur Übermittlung der Anforderungen und Antworten wird HTTP verwendet. Der Nachrichtentransport ist dadurch völlig plattformunabhängig. HTTP verbindet bekanntlich Computer in der ganzen Welt miteinander. HTTP kann Firewalls durchqueren und ist die einfachste Möglichkeit, um Nachrichten zu jedem beliebigen Computer auf der Welt zu transportieren. Es ist sehr wahrscheinlich, dass SOAP so weiterentwickelt wird, dass zukünftig auch andere Protokolle verwendet werden können. Ein SOAP-Paket enthält Informationen, anhand derer eine Methode aufgerufen werden kann. Wie die Methode tatsächlich aufgerufen wird, ist in der SOAP-Spezifikation nicht definiert.
1
CORBA steht für Common Object Request Broker Architecture, eine Spezifikation, die von der Object Management Group entwickelt wurde. Diese Spezifikation stellt eine Standardschnittstellendefinition zwischen Objekten in verschiedenen Programmen zur Verfügung, und zwar auch dann, wenn diese Programme in unterschiedlichen Programmiersprachen geschrieben sind und auf verschiedenen Plattformen laufen. In CORBA agiert ORB als »Makler« zwischen der Anforderung eines Objekts aus einem verteilten Objekt durch einen Client und dem Abschluss dieser Anforderung.
140
Kapitel 8
SOAP behandelt auch keine verteilte Garbage Collection, Message boxcarring,1 Typensicherheit oder bidirektionales HTTP. Mit SOAP lassen sich jedoch Parameter und Befehle zwischen HTTP-Clients und Servern austauschen, und zwar unabhängig von den Plattformen und Anwendungen auf dem Client und dem Server. Die Parameter und die Befehle werden mit XML kodiert. Werfen Sie nun einen Blick darauf, wie SOAP die Standard-HTTP-Header verwendet.
HTTP-Header und SOAP In HTTP stehen zwei Arten von Headern zur Verfügung: Request Header und Response Header. Wenn Sie einen Webbrowser benutzen, um im Internet zu surfen, erzeugt der Browser jedes Mal, wenn Sie zu einem neuen URL navigieren, einen Request (Anforderung) und sendet diesen an den Webserver. Der Request wird im Nur-Text-Format erzeugt und enthält Header im Standardformat. Um SOAP-Nachrichten zu erhalten, werden den Standardformaten weitere Informationen hinzugefügt. Der HTTP-Server erzeugt eine Response (Antwort), sobald ein Request von einem Client eingeht. Eine solche Nachricht enthält eine Statuszeile und die Response Header. Request und Response Header werden nun etwas ausführlicher beschrieben.
Request Header Ein typischer SOAP-Request (Anforderung), der Request Header enthält und an einen Webserver gesendet wird, sieht wie folgt aus: POST /Order HTTP/1.1 Host: www.northwindtraders.com Content-Type: text/xml Content-Length: nnnn SOAPAction: "urn:northwindtraders.com:PO#UpdatePO" Hier würden die zu sendenden Informationen stehen.
Die erste Zeile der Nachricht enthält drei Komponenten: die Request-Methode, den RequestURI und die Protokollversion. Im Beispiel wird die Methode POST verwendet. Der RequestURI hat den Wert /Order und die Versionsnummer ist HTTP/1.1. Die Request-Methoden wurden von der Internet Engineering Task Force (IETF) standardisiert. Die GET-Methode dient normalerweise dazu, Informationen aus dem Web abzurufen, mit der POST-Methode werden Informationen vom Client an den Server übergeben. Diese Informationen werden dann von Anwendungen auf dem Server benutzt. Mit der GET-Methode können nur ganz bestimmte Arten von Informationen gesendet werden. Mit der POST-Methode dagegen alle Arten von Daten. SOAP unterstützt auch den Versand von Nachrichten mit M-POST. Diese Methode wird später in diesem Kapitel ausführlicher beschrieben. Kommt bei einem SOAP-Paket die POSTMethode zum Einsatz, enthält der Request-URI normalerweise den Namen der Methode, die aufgerufen werden soll. Die zweite Zeile enthält den URL des Servers, an den der Request gesendet wird. Der RequestURL ist von der Implementierung abhängig, d. h. jeder Server definiert, wie er den Request-URL interpretieren wird. Bei einem SOAP-Paket gibt der Request-URL normalerweise den Namen des Objekts an, das die Methode enthält, die aufgerufen werden soll. 1
Eine »Boxcar Message« ist eine Art von Nachricht, die mehrere Geschäftsdokumente enthält.
SOAP
141
Die dritte Zeile enthält den Inhaltstyp (content type), text/xml, der angibt, dass es sich beim Inhalt (payload) um XML im Nur-Text-Format handelt. Der Inhalt bezieht sich auf die Daten, die zum Ziel transportiert werden. Diese Information über den Inhalt könnte von einem Server oder einer Firewall benutzt werden, um die Gültigkeit der eingehenden Nachricht zu überprüfen. Ein SOAP-Request muss immer den Inhaltstyp text/xml verwenden. Die vierte Zeile gibt die Größe des Inhalts in Byte an. Der Inhaltstyp und die Länge des Inhalts müssen immer angegeben werden. Das Header-Feld SOAPAction gibt bei einem SOAP-Request den Zweck an. Die fünfte Zeile der Nachricht, SOAPAction: "urn:northwindtraders.com:PO#UpdatePO", enthält den Namespace und den Methodennamen. Durch die Kombination von Namespace und Request-URL wird im Beispiel die Methode UpdatePO des Objekts Order aufgerufen, deren Geltungsbereich durch den Namespace-URI urn:northwindtraders.com:PO angegeben wird. Nachfolgend sehen Sie weitere gültige Feldwerte für SOAPAction-Header: SOAPAction: "UpdatePO" SOAPAction: "" SOAPAction:
Die leere Zeichenfolge bedeutet, dass der HTTP-Request-URI den Zweck der SOAP-Nachricht angibt. Ein Header-Feld ohne Angabe eines Werts kennzeichnet, dass der Zweck der SOAPNachricht nicht bekannt ist. Beachten Sie, dass eine Leerzeile zwischen der fünften Zeile und dem Inhalt des Requests steht. Bei Nachrichten-Headern wird durch die Zeichenkombination Wagenrücklauf (CR) und Zeilenvorschub (LF) das Ende des Headers gekennzeichnet. Eine zusätzliche CR/LF-Zeichenkombination besagt, dass die Header-Information nun vollständig ist und der Inhalt folgt.
Response Header Ein typischer Response (Antwort), der die Response Header enthält, sieht wie folgt aus: 200 OK Content-Type: text/plain Content-Length: nnnn Hier Inhalt einfügen.
Die erste Zeile dieser Nachricht enthält einen Statuscode und eine Nachricht, die mit diesem Statuscode verknüpft ist. Im Beispiel handelt es sich um den Statuscode 200 und die Nachricht OK. Dies bedeutet, dass der Request erfolgreich dekodiert und eine passende Response zurückgesendet wurde. Bei einem Fehler wären beispielsweise folgende Header zurückgeliefert worden: 400 Bad Request Content-Type: text/plain Content-Length: 0
In diesem Fall ist der Statuscode 400 und die Nachricht lautet Bad Request (Anforderung ungültig), was bedeutet, dass der Request wegen einer fehlerhaften Syntax vom Server nicht dekodiert werden konnte. Weitere Standardstatuscodes finden Sie im RFC 2616.
142
Kapitel 8
Einfache SOAP-Nachrichten Wie Sie sehen, benutzt SOAP HTTP als Transportprotokoll. Dadurch, dass ein SOAP-Payload (Inhalt) zu einem Request oder einer Response hinzugefügt wird, ist es möglich, einen RPC mittels HTTP an eine beliebige Komponente zu senden.
Der Inhalt eines SOAP-Requests Die SOAP-Spezifikation definiert verschiedene SOAP-Elemente, die in einem SOAP-Request eingesetzt werden können. Dies sind die Elemente envelope, head und body. Das Element envelope ist ein Container für das head- und das body-Element. Das head-Element enthält Informationen über die SOAP-Nachricht und das body-Element enthält die eigentliche Nachricht. Die SOAP-Elemente werden mit Namespaces von anderen Elementen im Inhalt des Requests unterschieden. In einem SOAP-Dokument werden beispielsweise die Namespaces SOAP-ENV:Envelope, SOAP-ENV:Head und SOAP-ENV:Body verwendet. Das SOAP-Schema für das envelope-Element sieht wie folgt aus:
SOAP
143
Ein SOAP-Request, der den im Schema definierten Inhalt hat, würde wie folgt aussehen: POST /Order HTTP/1.1 Host: www.northwindtraders.com Content-Type: text/xml Content-Length: nnnn SOAPAction: "urn:northwindtraders.com:PO#UpdatePO"
0 999 89 3000 0
HINWEIS Beachten Sie, dass die Standard-Body-Deklaration überschrieben wird, indem NorthwindBody mit Hilfe des Attributs xsi:type mit dem Body-Element verknüpft wird. Ein Schema, das NorthwindBody und die zusätzlichen Elemente definiert, wie z. Β. UpdatePO, wird im Abschnitt »Ein Schema für das body-Element der SOAP-Nachricht« später in diesem Kapitel vorgestellt.
144
Kapitel 8
Weil das Body-Element im SOAP-Schema das any-Element enthält, hätte der SOAP-Request auch wie folgt kodiert werden können:
0 999 89 3000 0
Wie Sie sehen, enthält der SOAP-Request ein XML-Dokument, das wiederum die Parameterwerte der Methode enthält. Der HTTP-Header dieses Pakets hat die Methode UpdatePO des Objekts Order als Empfänger dieses Methodenaufrufs identifiziert. Das Toplevel-Element des Methodenaufrufs muss denselben Namen wie die Methode haben, die im Header-Feld SOAPAction angegeben ist. Im Toplevel-Element sind die Parameter für die Methode enthalten. Im letzten Beispiel sind dies die Parameter orderID, customerNumber, item und quantity. In Microsoft Visual Basic würde die Methode wie folgt aussehen: Public Sub UpdatePO(byval orderID as Integer, _ byval customerNumber as Integer, _ byval item as Integer, _ byval quantity as Integer, _ byref return as Integer)
Und in Java würde die Methode wie folgt aussehen: public class UpdatePO {public int orderID; public int customerNumber; public int item; public int quantity; public int return;}
Bei der Erstellung einer Anforderung müssen Sie ein Element für jeden in- oder in/out-Parameter aufnehmen. Diese Technik, jedes Element mit einem Parameter zu verknüpfen, wird auch als Element-Normalform (ENF) bezeichnet. Der Name eines Elements entspricht dem des Parameters, mit dem das Element verknüpft ist. Der Request kann auch ein header-Element enthalten, das zusätzliche Informationen beinhaltet. Im header-Element gibt es keine vordefinierten Elemente – es kann jedes Element integriert werden, solange diesem ein Namespace vorangestellt ist oder der Header-Typ mit xsi:type überschrieben wird und ein Typ in einem Schema definiert ist. Zum Beispiel kann wie folgt ein header-Element hinzugefügt werden:
SOAP
145
10000000-0000-abcd-0000-000000000001
0 999 89 3000 0
Weil das any-Element im header-Element des SOAP-Schemas verwendet wird, könnte der SOAP-Header auch wie folgt kodiert werden:
10000000-0000-abcd-0000-000000000001
In diesem Beispiel wurde ein Element namens GUID erzeugt. Es bleibt der Empfängeranwendung überlassen, diesen Header zu interpretieren. Es ist jedoch sehr wahrscheinlich, dass er benutzt wird, um das korrekte COM-Objekt zu instantiieren. Diese zusätzlichen Elemente können als Verarbeitungsanweisungen betrachtet werden. Sie können ein vordefiniertes Attribut namens mustUnderstand als Attribut eines Header-Elements aufnehmen. Mit diesem kann dann angegeben werden, ob die Header-Information für die Verarbeitung der Information wesentlich ist. Ist dies der Fall, muss das Attribut mustUnderstand auf true gesetzt sein. Falls das Empfängerelement die Verarbeitungsanweisung nicht erkennen kann und mustUnderstand auf 1 gesetzt ist, muss die Nachricht zurückgewiesen werden. Das header-Element könnte also wie folgt aussehen:
10000000
In diesem Beispiel wird ein Element namens TransactionID erstellt. Falls dieses von der Empfängeranwendung nicht erkannt wird, wird die Nachricht zurückgewiesen.
Nachrichten mit der Methode M-POST senden Nachrichten, die eine Firewall oder einen Proxy-Server durchlaufen, lassen sich mit der Methode M-POST beschränken. M-POST ist eine neue HTTP-Methode, die mittels des HTTP Extension Framework definiert wird, das unter http://www.w3.org/Protocols/HTTP/ietf-ext-wg zu finden ist. Diese Methode wird eingesetzt, wenn obligatorische Informationen in den HTTPHeader integriert werden, und entspricht dem Einsatz des Attributs mustUnderstand im header-Element von SOAP.
146
Kapitel 8
Wie bereits erwähnt, unterstützt SOAP POST- und M-POST-Requests. Ein Client sendet zunächst einen SOAP-Request mit M-POST. Falls dieser fehlschlägt und entweder der Statuscode 501 (Statusmeldung Not Implemented) oder der Statuscode 510 (Statusmeldung Not Extended) zurückgeliefert wird, sollte der Client den Request noch einmal mit der Methode POST senden. Schlägt dies wieder fehl und wird der Statuscode 405 (Statusmeldung Method Not Allowed) zurückgeliefert, ist der Request endgültig fehlgeschlagen. Wird dagegen der Statuscode 200 zurückgeliefert, wurde die Nachricht erfolgreich empfangen. Firewalls können einen Client zwingen, die Methode M-POST zur Übermittlung eines SOAP-Request zu verwenden, indem sie normale Requests, die mit der Methode POST gesendet werden und den Inhaltstyp text/xmlSOAP haben, blockieren. Wenn Sie die Methode M-POST verwenden, müssen Sie eine obligatorische Erweiterung der Deklaration verwenden, die sich auf einen Namespace in der Deklaration des Envelope-Elements bezieht. Das Namespace-Präfix muss den obligatorischen Headern vorangestellt sein. Das folgende Beispiel veranschaulicht, wie die Methode M-POST und die obligatorischen Header benutzt werden: M-POST /Order HTTP/1.1 Host: www.northwindtraders.com Content-Type: text/xml Content-Length: nnnn Man: "http://schemas.xmlsoap.org/soap/envelope; ns=49" 49-SOAPAction: "urn:northwindtraders.com:PO#UpdatePO"
Der Header Man ordnet den URI http://schemas.xmlsoap.org/soap/envelope dem HeaderPräfix 49 zu. Jeder Header mit dem Präfix 49 wird mit diesem URI verknüpft und ist deshalb ein obligatorischer Header. Im Beispiel wird SOAPAction mit dem URI verknüpft und ist nun ein obligatorischer Header. HINWEIS Falls Sie M-POST verwenden und keine obligatorischen Header-Elemente besitzen, tritt ein Fehler auf, der zum Statuscode 501 oder 510 führt.
Der Inhalt einer SOAP-Response So wie das Beispiel für den SOAP-Request untergeordnete Elemente für alle in- und in/outParameter der Methode enthielt, enthält die SOAP-Response untergeordnete Elemente für jeden out- und in/out-Parameter. Betrachten Sie z. B. die folgende Visual Basic-Funktion: Public Function UpdatePO(byref OrderID as Integer, _ byval CustomerNumber as Integer, byval Item as Integer, _ byval Quantity as Integer) as Integer
Der Server würde hier der Variablen orderID einen Wert zuweisen und diesen an den Client zurückliefern. Weil der Parameter orderID byref ist, handelt es sich um einen in/out-Parameter. UpdatePO ist nun eine Funktion und liefert einen Wert zurück (im Beispiel einen booleschen Wert). Der Rückgabewert der Funktion kann als out only-Parameter betrachtet werden. Für diese UpdatePO-Funktion könnte der Inhalt des SOAP-Request, der alle in- und in/outParameter enthält, wie folgt aussehen:
SOAP
147
0 999 89 3000
Die Response inklusive des SOAP-Teils, der alle out- und in/out-Parameter enthält, würde dann wie folgt aussehen: HTTP/1.1 200 OK Content-Type: text/xml Content-Length: nnnn
09877 0
Beachten Sie, dass die SOAP-Response kein SOAPAction-Header-Feld enthält. Dieses Feld ist nur in SOAP-Requests erforderlich. Während der Request verarbeitet wird, wird ein SOAPPaket an eine SOAP-Anwendung auf dem Server übergeben, die die SOAP-Requests behandelt. Diese SOAP-Anwendung übergibt den Request an die geeignete Methode. Manchmal kann ein Request nicht korrekt verarbeitet werden und es wird ein Fehler hervorgerufen. Fehler lassen sich auf unterschiedliche Weise behandeln. Die Art der Fehlerbehandlung hängt davon ab, wo der Fehler auftritt. Wird der Fehler beispielsweise beim Transport des Pakets an die Methode hervorgerufen, wird normalerweise ein anderer Statuscode als 200 zurückgeliefert. Dies passiert beispielsweise, wenn Probleme beim Transport eines Pakets durch eine Firewall auftreten oder der angegebene Host nicht existiert oder heruntergefahren ist. Nachdem die Informationen an die Methode übergeben wurden, tritt möglicherweise bei der Anwendung, die den Request behandelt, ein Fehler auf. In diesem Fall kann ein benutzerdefinierter HTTP-Code, einer der vordefinierten HTTP-Codes, ein Element wie das return-Element im letzten Beispiel oder ein SOAP-Paket zurückgeliefert werden, das ein Fault-Element enthält. Betrachten Sie nun, wie Fehler mit dem Fault-Element dokumentiert werden.
Das Fault-Element Ein Fault-Element kann die vier untergeordneten Elemente faultcode, faultstring, faultactor und detail enthalten. Die Fehlercodes finden Sie im Web unter http://schemas.xmlsoap.org/ soap/envelope. In der Tabelle 8.1 sind die Codes aufgeführt, die momentan zur Verfügung stehen.
148
Kapitel 8
Name
Bedeutung
VersionMismatch
Im Aufruf wurde ein ungültiger Namespace verwendet.
MustUnderstand
Der Empfänger konnte ein XML-Element nicht interpretieren, das mit with mustUnderstand = "true" ausgezeichnet war.
Client
Diese Fehlerklassen werden durch fehlerhafte Informationen in der eigentlichen SOAP-Nachricht hervorgerufen. So könnte bei einer neuen Bestellung beispielsweise ein erforderlicher Wert wie die Artikelnummer oder die Menge fehlen. Solche Fehler zeigen ein Problem mit dem eigentlichen Inhalt der Nachricht an und deuten darauf hin, dass die Nachricht verändert werden sollte, bevor sie erneut gesendet wird. Eine Klasse von Clientfehlern lässt sich mit dem Punktoperator (.) erzeugen und könnte beispielweise wie folgt aussehen: Client.InvalidPartNumber, Client.InvalidQuantity, etc.
Server
Diese Fehler beziehen sich auf Probleme mit dem Server und bilden normalerweise keine Probleme mit der eigentlichen SOAP-Nachricht ab. Das Problem lässt sich häufig dadurch lösen, dass die Nachrichten noch einmal zu einem späteren Zeitpunkt an den Server gesendet werden. Eine Klasse von Serverfehlern lässt sich mit dem Punktoperator (.) erzeugen.
Tabelle 8.1: Momentan verfügbare Fehlercodes
Das Element faultstring ist eine Zeichenfolge und wird nicht von Anwendungen eingesetzt. Es wird nur zur Benachrichtigung von Benutzern verwendet. Dieses Element ist erforderlich. Das faultactor-Element kann Informationen darüber bieten, von welchem Element im Nachrichtenpfad der Fehler verursacht wurde. Es enthält einen URI, der die Quelle identifiziert. Falls der Fehler in einer Anwendung auftritt, die nicht das Ziel der Nachricht ist, muss das faultactorElement verwendet werden. Falls der Fehler in der Anwendung auftritt, an die die Nachricht adressiert ist, kann das faultactor-Element benutzt werden, muss aber nicht. Das detail-Element wird benötigt, wenn der Inhalt des Body-Elements der SOAP-Nachricht nicht verarbeitet werden konnte. Es bietet anwendungsspezifische Fehlerinformationen, die sich auf das BodyElement beziehen. Fehlerinformationen, die sich auf den Header beziehen, lassen sich nicht in das detail-Element aufnehmen. Alle untergeordneten Elemente des detail-Elements müssen mit einem Namespace verknüpft sein. Ein Paket, das mit einem Fault-Element zurückgesendet wird, sieht wie folgt aus: HTTP/1.1 200 OK Content-Type: text/xml Content-Length: nnnn
200 Must Understand Error
Object not installed on server.
SOAP
149
Mit dem faultstring-Element lassen sich Informationen an den Client zurücksenden, die den genauen Fehler beschreiben. Das faultstring-Element kann eine größere Bandbreite von Fehlern behandeln.
Ein Schema für den Inhalt der SOAP-Nachricht Wie Sie sehen, wurde bisher das NPO-Schema noch nicht definiert, das in der Datei http:// www.northwindtraders.com/schemas/NPOSchema.xsd enthalten ist. Es kann wie folgt definiert werden:
Dieses Schema erzeugt die zwei Elemente NorthwindBody und NorthwindHeader. Mit dem Attribut xsi:type lässt sich das Body-Element mit dem komplexen Typ NorthwindBody erweitern und das Header-Element mit dem komplexen Typ NorthwindHeader. Daraus resultiert das folgende SOAP-Dokument:
10000000-0000-abcd-0000-000000000001
0 999 89 3000
150
Kapitel 8
SOAP-Kodierung Der SOAP-Kodierungsstil bietet eine Möglichkeit, Datentypen mit Typen und Datenfeldern (Arrays) in ähnlicher Weise zu definieren wie in den meisten Programmiersprachen. Die Spezifikation für die Kodierung finden Sie unter http://schemas.xmlsoap.org/soap/encoding/. SOAP definiert wie der Schemastandard einfache und komplexe Datentypen. Elemente von einfachen Datentypen entsprechen denen, die im zweiten Schemastandard definiert werden. Elemente komplexer Datentypen beinhalten diejenigen, die im ersten SOAP-Standard definiert werden und eine spezielle Definitionsweise von Datenfeldern. Strukturen folgen den Definitionen komplexer Datentypen. Die folgende Struktur
John Jones 100 Main Street 4
würde beispielsweise wie folgt definiert werden:
Um ein Element als Datenfeld (Array) zu definieren, dient die folgende Angabe: type="SOAPENC:Array". Der Namespace SOAP-ENC ist wie unter http://schemas.xmlsoap.org/soap/encoding angegeben definiert. Ein Datenfeld könnte wie folgt aussehen:
345 354 399
Das Schema würde dann so aussehen:
In diesem Beispiel enthält das Datenfeld CustomerIDs drei Mitglieder, von denen jedes einen Wert des Typs xsd:int hat.
Zusammenfassung Dieses Kapitel war eine Einführung in die Grundlagen von SOAP. Mit diesen Grundprinzipien lassen sich Parameterwerte für Methoden mittels XML und HTTP an einen Server übergeben und von diesem zurücksenden. Wenn sich die SOAP-Spezifikation weiterentwickelt, wird SOAP sehr wahrscheinlich den Versand von eng gebundenen Nachrichten zu und von Komponenten auf fast jedem Betriebssystem erlauben. In Kapitel 9 wird das BizTalk-Framework vorgestellt. Dieses baut auf den Konzepten von SOAP auf und gestattet Unternehmen den Austausch von Geschäftsdokumenten mit XML-Schemas und Industriestandards für die gemeinsame Nutzung von Informationen.
SOAP
151
9 154 155 164 170 172 173 174 175
BizTalk
Die Nachrichtenstruktur von BizTalk BizTalk-Dokumente XDRs Das BizTalk-Schema für Northwind Traders BizTalk-Schemas gemeinsam nutzen DTD, W3C-Schema oder BizTalk-Schema? Informationen für ein Schema identifizieren Zusammenfassung
In Kapitel 8 wurde untersucht, wie mit SOAP die plattformübergreifende Interoperabilität mit dem Web und XML verbessert werden kann. In diesem Kapitel wird BizTalk Framework 2.0 genauer betrachtet, das eine Erweiterung der SOAP 1.1-Spezifikation darstellt. BizTalk Framework 2.0 bietet eine Struktur für die Erstellung von Lösungen, die Daten, die in einem SOAPDokument enthalten sind, über Plattformgrenzen hinweg bewegen. Eine Grenze ist ein Punkt, an dem Informationen von einem System auf ein anderes übergehen. Ein Unternehmen kann beispielsweise ein anderes System für die Bearbeitung von Bestellungen benutzen als die Partner des Unternehmens. Wenn eine Bestellung vom unternehmenseigenen System an das Partnersystem übergeben wird, überschreitet es eine Grenze. Sehr häufig stellen solche Grenzen Schnittstellen zwischen verschiedenen Betriebssystemen dar. Somit ist BizTalk auch ein Framework für die Bewegung von Daten über verschiedene Plattformen hinweg. BizTalk Framework 2.0 behandelt die folgenden Probleme, die mit der Bewegung von Daten mittels XML über Grenzen und Plattformen hinweg verbunden sind: b Der Bedarf nach einem leicht einsetzbaren, flexiblen Standard, um strukturierte Informationen mit HTML über Systemgrenzen hinweg zu spezifizieren, zu packen, zu publizieren und auszutauschen. b Der Bedarf nach einem leicht zu benutzenden, flexiblen Standard, um Geschäftsregeln zu spezifizieren, zu packen, zu veröffentlichen und auszutauschen, um Informationen vom Format eines Systems auf das eines anderen mit XML zu übertragen. b Der Bedarf nach Anwendungen in der mittleren Schicht, die die Kommunikation über Systemgrenzen hinweg gestatten.
153
b Der Bedarf nach einem Standard, der Fehlererkennung und Empfangsbestätigungen für Dokumente bietet, wenn Informationen über Systemgrenzen bewegt werden. BizTalk Framework 2.0 ist im Gegensatz zu XML kein W3C-Standard. Der Zweck von BizTalk besteht darin, die Implementierung des XML-Standards anhand eines standardisierten Frameworks zu erleichtern. Weil BizTalk diese Probleme mittels XML behandelt, sollten BizTalkLösungen pattform- und technologieunabhängig sein.
Die Nachrichtenstruktur von BizTalk Eine BizTalk-Nachricht kann als SOAP-Dokument betrachtet werden, das spezielle BizTalkTags im SOAP-Header-Element enthält und eines oder mehrere Geschäftsdokumente im SOAPBody-Element. Diese BizTags bestehen aus XML-Tags, die von der BizTalk Framework 2.0-Spezifikation vordefiniert sind und mit denen angegeben wird, wie das Dokument behandelt wird. BizTags bieten eine lose verbundene Methode für das Routing der SOAP-Nachrichten. Das SOAP-Body-Element enthält die Informationen, die in der Nachricht übergeben werden. Diese Struktur wird in Abbildung 9.1 veranschaulicht. BizTalk-Nachricht SOAP-Header BizTags SOAP-Body
Abbildung 9.1: Eine BizTalk-Nachricht
Das Geschäftsdokument ist ein wohlgeformtes XML-Dokument, das aus Geschäftstransaktionsdaten besteht. Ein Schema wird benutzt, um die Gültigkeit eines Geschäftsdokuments zu prüfen. BizTalk-Schemas können in der Website http://www.biztalk.org veröffentlicht und von mehreren Unternehmen gemeinsam genutzt werden. HINWEIS Zum Zeitpunkt, als dieses Buch geschrieben wurde, verwendete BizTalk ein XDRSchema (XDR – XML Data Reduced), das sich leicht von dem Schema unterscheidet, das vom W3C-Standard definiert wird. Das XDR-Schema wird sehr wahrscheinlich so lange benutzt werden, bis das W3C den endgültigen Schemastandard freigibt. Dann wird BizTalk das Standardschema implementieren. Die Unterschiede zwischen den beiden Schemas werden im Abschnitt »XDR-Schemas« später in diesem Kapitel besprochen. BizTalk-Nachrichten dienen dazu, BizTalk-Dokumente zwischen BizTalk Framework 2.0-kompatiblen Servern (BFC – BizTalk Framework Compliant) auszutauschen. Die Erstellung und das Routing einer BizTalk-Nachricht wird in Abbildung 9.2 veranschaulicht.
154
Kapitel 9
1. Anwendung muss eine Nachricht über eine Grenze hinweg senden. Anwendung Schema in einer Schemabibliothek (BizTalk.org oder sonstige)
Anwendungsadapter 2. Anwendung erstellt ein BizTalkDokument nach einem veröffentlichten Schema.
3. BizTalkDokument wird an den Server gesendet.
BizTalkDokument
BizTalkServer
Grenze 4. BizTalk-Nachricht wird an den Zielserver gesendet.
BizTalk-Nachricht SOAP-Header BizTags
BizTalk Framework 2.0kompatibler Server 5. Nachricht wird empfangen, ausgewertet und für die Empfängeranwendung vorbereitet.
SOAP-Body
Abbildung 9.2: Eine BizTalk-Nachricht wird erzeugt und geroutet
Wie Sie sehen, erzeugt eine Anwendung ein BizTalk-Dokument nach den Regeln eines veröffentlichten BizTalk-Schemas. Dieses Dokument wird an einen BizTalk-Server übergeben, um eine BizTalk-Nachricht zu erzeugen. Die BizTalk-Nachricht wird über eine Geschäftsgrenze hinweg an einen BFC-Server gesendet, der das Ziel anhand der Informationen im BizTalkDokument ermittelt.
BizTalk-Dokumente Das BizTalk-Dokument ist eine SOAP 1.1-Nachricht, die aus zwei primären Abschnitten besteht. Ein primärer Abschnitt ist der SOAP-Header, der den BizTalk-Dokument-Header mit Informationen über das Dokument enthält. Der zweite primäre Abschnitt ist der SOAP-Body, der die eigentlichen Geschäftstransaktionsinformationen enthält. Der SOAP-Header in einem BizTalk-Dokument muss die BizTalk-spezifischen Tags und enthalten. Die BizTags und können auch in den BizTalk-Dokument-Header aufgenommen werden. Die Struktur des BizTalk-Dokuments innerhalb einer BizTalk-Nachricht wird in Abbildung 9.3 veranschaulicht.
BizTalk
155
BizTalk-Nachricht Transportheader
BizTalk-Dokument SOAP Header Zustellungsinformation Eigenschafteninfos [Manifeste Information] [Prozessinformation]
SOAP-Body SOAP-Dokument
Abbildung 9.3: Die Struktur eines BizTalk-Dokuments
BizTalk-Dokument-Header Ein BizTalk-Dokument ist ein wohlgeformtes XML-Dokument. Deshalb enthält der Header des BizTalk-Dokuments die Standardinformationen eines XML-Headers, wie z. B. die XML-Version und die Sprache. Ein typisches BizTalk-Dokument ohne Inhalt würde wie folgt aussehen:
Weil delivery und properties obligatorische Header-Elemente sind und das Element process interpretiert werden muss, wenn es vorhanden ist, muss die Eigenschaft SOAP-ENV:mustunderstand für diese Elemente auf den Wert 1 gesetzt werden, damit der BFC-Empfängerserver weiß, dass die Abschnitte, die in diesen Elementen enthalten sind, verstanden werden müssen, um das Dokument zu verarbeiten. Der folgende Code ist ein Beispiel für eine DTD für ein BizTalk-Dokument.
BizTalk
157
Wie Sie den letzten beiden Codebeispielen entnehmen können, besteht ein BizTalk-Dokument aus vier Hauptabschnitten, die durch die Elemente delivery, properties, manifest und process gekennzeichnet werden. Diese Elemente werden in den folgenden Abschnitten ausführlich beschrieben.
Das delivery-Element Das delivery-Element ist ein untergeordnetes Element des SOAP Header-Elements. Dieses Element enthält Informationen über Nachrichten wie Angaben zum Quell- und Zielsystem. Das delivery-Element gibt an, woher die Nachricht stammt und was ihr Ziel ist und bietet Routinginformationen und Ähnliches. Dieses Element ist unbedingt erforderlich und darf nur ein Mal vorkommen. Das delivery-Element hat die drei untergeordneten Elemente to, from und reliability. Die Elemente to und from sind obligatorisch. Alle drei Elemente dürfen nur ein Mal vorkommen. Das to- und das from- Element Wie bereits erwähnt, sind die beiden Elemente to und from untergeordnete Elemente des delivery-Elements. Beide Elemente haben das untergeordnete Element address. Das address-Element ist obligatorisch und darf nur ein Mal vorkommen. Das address-Element kann jede Geschäftseinheit angeben, wie z. B. einen URI, den Namen einer Abteilung oder den Namen einer Organisation. Für das to-Element enthält das address-Element die Geschäftseinheit für den BizTalk-Empfängerserver. Für das from-Element enthält das address-Element die Geschäftseinheit des BizTalk-Empfängerservers. URIs können Präfixe beinhalten, wie z. B. http://, die ein Transportmittel für eine Nachricht angeben. Das Präfix muss nicht unbedingt vorhanden sein. Falls es fehlt, muss der BizTalk-Server das spezifische Adresssystem auflösen. Ohne Präfix handelt es sich beim URI um einen logischen Bezeichner. Das address-Element enthält auch ein erforderliches xsi:type-Attribut. Dieses Attribut gibt die Adresskategorie an und legt die Struktur des Adressinhalts fest. Der folgende Code zeigt ein Beispiel für ein to- und ein from-Element:
158
Kapitel 9
Lose gebundene Nachrichten Wie bereits erwähnt, enthält der BizTalk-Header nur Informationen über den BizTalk-Quellund Zielserver. Im BizTalk-Dokument-Header gibt es keine Informationen, die angeben, welche Methode oder welches Objekt diese Informationen benutzen wird. Der BizTalk-Dokument-Header enthält also eigentlich keine Informationen über die Anwendung, die das Dokument verarbeiten wird. Es bleibt dem BizTalk-Empfängerserver überlassen, die eingehende Nachricht zu identifizieren und an die korrekte Anwendung weiterzuleiten. Ein BizTalk-Server lässt sich so einrichten, dass alle Nachrichten, die vom Server http://www.northwindtraders.com stammen und deren identity-Element mit PO00123 beginnt, an das neue Bestellungsverarbeitungsobjekt übergeben werden. (Identity ist ein untergeordnetes Element des properties-Elements, das später in diesem Kapitel ausführlich beschrieben wird.) Wird dieselbe Nachricht an ein anderes Unternehmen gesendet, wird sie möglicherweise an eine ganz andere Komponente weitergeleitet. Diese Art von Nachrichten werden als lose gebunden (loosely coupled) bezeichnet, was besagt, dass die Verarbeitung nicht an eine bestimmte Anwendung gebunden ist.
http://www.northwindtraders.com/PO.asp/Billing
Orders
Dieses Dokument verwendet zwei Arten von Adressen: Die erste Adresse ist ein URI und die zweite Adresse ist eine Adresse des Typs department. Der BizTalk-Server kann diese beiden Arten von Adressen identifizieren. Das reliability- Element Das reliability-Element ist optional und enthält Informationen, mit denen die zuverlässige Übermittlung des BizTalk-Dokuments sichergestellt werden kann. Wenn das reliability-Element vorhanden ist, muss der BizTalk-Server, der die Nachricht empfängt, eine Nachricht an den sendenden BizTalk-Server mit dem URI zurücksenden. Dieser Prozess wird im Abschnitt »Empfangsbestätigungen« weiter unten in diesem Kapitel ausführlicher beschrieben. Das reliability-Element enthält zwei obligatorische Elemente, die jeweils nur ein Mal vorkommen dürfen: confirmTo und receiptRequiredBy. Das confirmTo-Element enthält den URL, der die Adresse angibt, zu der die Empfangsbestätigung gesendet wird. Das receiptRequiredBy-Element enthält eine Zeitangabe, die den spätesten Zeitpunkt angibt, zu dem die BizTalk-Nachricht empfangen worden sein muss. Der Inhalt dieses Elements sollte entsprechend dem ISOStandard 8601 formatiert sein. Weitere Informationen zu diesem Standard finden Sie unter
BizTalk
159
http://www.cl.cam.ac.uk/~mgk25/iso-time.html. Alle Zeitangaben im BizTalk-Header benutzen den ISO-Standard 8601. Der folgende Code zeigt ein Beispiel für ein reliability-Element:
www.northwindtraders.com/poConfirm
2300-05-44T03:00:00+09:00
Falls die Empfangsbestätigung nicht innerhalb der angegebenen Zeit eintrifft, kann der sendende BFC-Server versuchen, die Nachricht noch einmal zu senden. Falls der Empfängerserver die Nachricht zwei Mal oder häufiger erhält, lassen sich Duplikate eines BizTalk-Dokuments mit dem identity-Element des properties-Elements eliminieren. Der sendende BFC-Server kann nach einer bestimmten Anzahl von Wiederholungen, oder wenn nach dem ersten Versuch keine Empfangsbestätigung eingetroffen ist, auch einen Bericht über die fehlerhaften Zustellversuche erstellen. HINWEIS Es gibt immer eine gewisse Wahrscheinlichkeit, dass ein BFC-Empfängerserver die Nachricht zwar erhalten hat, die Erstellung der Empfangsbestätigung jedoch fehlgeschlagen ist oder diese verloren gegangen ist. In solchen Fällen wird vom sendenden BFC-Server möglicherweise ein Bericht über die fehlerhaften Zustellversuche erzeugt, obwohl die Nachricht eigentlich zugestellt wurde. Empfangsbestätigungen Die Empfangsbestätigung ist eine SOAP 1.1-konforme Nachricht, die zumindest die Elemente receipt und properties und ein leeres body-Element enthalten muss. Die Empfangsbestätigung ist kein BizTalk-Dokument, weil das body-Element keine Informationen enthält. Der Inhalt des receipt-Elements muss das BizTalk-Dokument identifizieren. Das receipt-Element enthält einen Zeitstempel, der den Zeitpunkt angibt, zu dem das BizTalk-Dokument empfangen wurde. Außerdem kann die Empfangsbestätigung Elemente enthalten, die direkt aus dem eingegangenen BizTalk-Dokument stammen.
Das properties-Element Das properties-Element ist ein untergeordnetes Element des SOAP Header-Elements und stellt Informationen bereit, die für die Identifikation der BizTalk-Nachricht eingesetzt werden können. Den Abschnitt, der in diesem Element enthalten ist, muss jeder BFC-Server verstehen, bevor er eine Nachricht korrekt verarbeiten kann. Das properties-Element hat folgende untergeordnete Elemente: identity, sentAt, expiresAt und topic. Diese Elemente sind alle obligatorisch und dürfen nur ein Mal vorkommen. Ein Beispiel für das properties-Element sehen Sie im folgenden Code:
uuid:00000000-0000-0000-0000-00000000001
2300-05-14T03:00:00+09:00 2300-05-44T03:00:00+09:00 http://northwindtranders.com/PO
160
Kapitel 9
Das identity- Element Das identity-Element ist ein URI, der das BizTalk-Dokument eindeutig identifiziert. Diese Identität kann für Protokolle, die Fehlerbehandlung und andere Zwecke zur Bearbeitung des Dokuments benutzt werden. Als identity-Element kann jeder eindeutige Bezeichner benutzt werden. Das sentAt-Element Das sentAt-Element ist ein Zeitstempel für das Dokument. Der Zeitpunkt kennzeichnet die genaue Uhrzeit, zu der der sendende BFC-Server erstmals versucht hat, das Dokument zu übertragen. Das expiresAt-Element Das expiresAt-Element gibt den Zeitpunkt an, zu dem die BizTalk-Nachricht abläuft. Für jeden Zeitpunkt, der hinter demjenigen liegt, der im expiresAt-Element angegeben wird, wird die BizTalk-Nachricht als abgelaufen betrachtet und kann nicht verarbeitet werden. Deshalb sollte zwischen dem Zeitpunkt, zu dem das Dokument erzeugt wird, und dem, der im expiresAt-Element angegeben wird, eine vernünftige Zeitspanne liegen. Das topic- Element Das topic-Element ist ein URI, mit dem sich der allgemeine Zweck der BizTalk-Nachricht eindeutig identifizieren lässt. Diese Information wird auf verschiedene Weise genutzt, wie z. B. beim interessenbasierten Routing bei Abonnements.
Das manifest-Element Das manifest-Element ist ein untergeordnetes Element des SOAP Header-Elements. Mit ihm wird angegeben, welche Dateien tatsächlich in einem BizTalk-Dokument enthalten oder mit diesem verknüpft sind. Das manifest-Element besteht aus einem Katalog aller Dokumente, die im BizTalk-Dokument enthalten sind. Zusätzliche Dateien, wie z. B. Bilder oder andere binäre Informationen, können in das BizTalk-Dokument aufgenommen werden. Das manifest-Element hat nur ein obligatorisches untergeordnetes Element: das reference-Element, das mehrmals vorkommen darf. Ein Beispiel für das manifest-Element bietet der folgende Code:
Bestellung bei Northwind
gescanntes Bild des Vertrags
Das reference- Element Mit dem reference-Element werden Verweise auf zusätzliche XML- oder andere Dateien eingerichtet, die als Bestandteil einer BizTalk-Nachricht gesendet wurden. Diese Dateien können auch Inhalte sein, die nicht im BizTalk-Dokument transportiert werden. Solche Dateien können
BizTalk
161
als MIME-Teile (MIME – Multipurpose Internet Mail Extensions) oder mit einem anderen Mechanismus implementiert werden. MIME beinhaltet Standard-Tags, die in den Header-Abschnitt des Dokuments integriert werden können. Mit diesen Tags lassen sich dann zusätzliche Dokumente identifizieren, anhängen und senden. BizTalk verwendet momentan MIME. HINWEIS Wenn Sie versuchen, binäre Informationen in Ihr XML-Dokument aufzunehmen, kommt es zu einer Fehlermeldung, weil binäre Informationen unzulässige Zeichen enthalten. Sie müssen die binäre Datei mit Base-64 kodieren, wobei alle binären Informationen in Textzeichen konvertiert werden. Leider vergrößert sich die BizTalk-Nachricht dadurch. Deshalb ist dies sicherlich nicht die beste Lösung. Sie könnten auch Multipart-MIME verwenden. Dies ist ein Standard für den Verweis auf eine oder mehrere Anlagen, die nicht im Textformat vorliegen. Multipart-MIME wird später in diesem Kapitel ausführlicher beschrieben. Das reference-Element kann zwei untergeordnete Elemente haben: uri und description. Das Element uri ist obligatorisch und das Element description ist optional. Beide Elemente dürfen nur ein Mal vorkommen. Das uri-Element enthält einen Verweis, der in die Ressource aufgelöst werden kann, die im reference-Element referenziert wird. Der Verweis kann wie folgt aussehen: b Ein relativer URI-Verweis in Form der #id, die Geschäftsdokumente im SOAP-Body auflöst. b Ein URL mit einer Inhalts-ID in Form der Angabe CID:content-ID-Value, der zu den Anlagen aufgelöst wird, die als MIME-Teile mit der BizTalk-Nachricht gesendet werden. b Ein URL, der zu Anlagen aufgelöst wird, die als MIME-Teile mit der BizTalk-Nachricht gesendet werden, jedoch nicht im BizTalk-Dokument enthalten sind. Das description-Element ist eine Textbeschreibung des Dokuments, auf die vom reference-Element verwiesen wird.
Das process-Element Das process-Element bietet Informationen über den Geschäftsprozess, der mit der BizTalkNachricht verknüpft ist. Das process-Element hat zwei obligatorische untergeordnete Elemente namens type und instance und ein optionales Element namens handle. Alle untergeordneten Elemente dürfen nur ein Mal vorkommen. Ein process-Element könnte wie folgt aussehen:
Kauf:Bestellung von Nahrungsmitteln Kauf:Bestellung von Nahrungsmitteln:0001
port:po_app
Das type- Element Das type-Element enthält einen URI, der die Art von Geschäftsprozess definiert, mit dem die BizTalk-Nachricht verknüpft ist. Das type-Element wird normalerweise durch zwei oder mehr Geschäftspartner definiert und verwendet ein Muster, das in vielen Dokumenten häufig verwendet wird. Der Erwerb eines Artikels wäre ein Beispiel für ein Muster.
162
Kapitel 9
Das instance- Element Das instance-Element enthält eine URI-Referenz, die eine bestimmte Instanz des Gschäftsprozesses eindeutig identifiziert, mit dem ein Geschäftsdokument verknüpft ist. Das type-Element identifiziert möglicherweise den Geschäftsprozess als BizTalk-Dokument des Typs Bestellung, wohingegen das instance-Element den Geschäftsprozess als Bestellnummer 0001 identifiziert. Normalerweise wird der Inhalt des instance-Elements dadurch erzeugt, dass ein eindeutiger Bezeichner, wie oben gezeigt, an das type-Element angehängt wird. Das handle- Element Das handle-Element ist ein optionales Element, mit dem zusätzliche Informationen zur Identifikation eines Prozesses angegeben werden können. Diese Informationen können eingesetzt werden, um festzustellen, auf welcher Stufe im Gesamtgeschäftsprozess sich die BizTalk-Nachricht befindet.
MultiPart-MIME Eine BizTalk-Nachricht kann mit dem Multipart-MIME-Format erzeugt werden, das im RFC 2387 definiert wird (http://www.ietf.org/rfc/rfc2387.txt). Um das MIME-Format in einem HTTP-Dokument einsetzen zu können, müssen verschiedene Punkte berücksichtigt werden. Eine BizTalk-Nachricht im MIME-Format könnte z. B. wie folgt aussehen: MIME-Version: 1.0 Content-Type: Multipart/Related; boundary=biztalk_document_boundary; type=text/xml; start="" Content-Description: Dies ist eine optionale Beschreibung der Nachricht. -- biztalk document boundary Content-Type: text/xml; charset=UTF-8 Content-ID:
Bestellung bei Northwind
gescanntes Bild des Vertrags
BizTalk
163
XML-Darstellung mit XSL und CSS
237
Sie haben nun einige Änderungen am Code vorgenommen, um mehrere Item-Elemente in einer Tabelle anzeigen zu können. Abbildung 12.4 zeigt, wie dieses XML-Dokument in einem Browser aussieht. Wie Sie sehen, werden am unteren Rand zwei Elemente angezeigt.
238
Kapitel 12
Abbildung 12.4: Die Anzeige der Elemente des Dokuments NorthwindPO.xml in einer Tabelle
Betrachten Sie nun das Ende des vorherigen Listings. Dort finden Sie die folgende Codezeile:
Diese Codezeile definiert ein Template, das Textknoten behandelt. Der XSL-Entwurf behandelt dieses Template als eines der beiden integrierten Templates. Das andere integrierte Template sieht wie folgt aus:
In Internet Explorer 5 sind diese Templates integriert, Sie können sie jedoch auch zu ihrem XSL-Dokument hinzufügen. Anhand dieser integrierten Templates lassen sich Stylesheets für unregelmäßige Daten erzeugen, indem Text automatisch vom Quelldokument in die Ausgabe übergeben wird. Das Template xsl:template match="text( )" wird im XSL-Dokument häufig verwendet, wenn ein apply-templates-Element kein select-Attribut benötigt, wie z. B. in der folgenden Deklaration:
Werfen Sie nun einen Blick auf das folgende Template aus dem vorherigen Codelisting, das die Bezeichnung totalAmount trägt, und sehen Sie, was es bewirkt:
Die Codezeile erzeugt ein neues totalAmountTemplate. Jedes apply-templates-Element, bei dem das select-Attribut auf totalAmount gesetzt
XML-Darstellung mit XSL und CSS
239
ist, weist den Parser an, das Template totalAmount auszuwählen. Weil match auf den Wert //body//totalAmount gesetzt ist, muss der Inhalt des totalAmount-Templates in der Lage sein, das totalAmount-Element im XML-Dokument mit XSL umzuwandeln. Der Wert von match definiert auch den Inhalt dieses Templateelements. Das totalAmount-Template enthält das HTML-Start-Tag td für die Tabelle, das XSL-Element apply-templates und das Ende-Tag td. Das apply-templates-Element benutzt das text-Template, um den aktuellen Inhalt als Text zurückzugeben. Weil der aktuelle Inhalt aus dem totalAmount-Element, seinen Attributen und seinem Inhalt besteht, liefert das apply-templates-Element den Textinhalt des totalAmountElements zurück. Somit gibt das Template totalAmount das td-Start-Tag, den Textinhalt des totalAmount-Elements und das td-Ende-Tag zurück. Mit dieser Kombination von apply-templates- und template-Elementen können Sie XSL-Dokumente erzeugen, die fast alles leisten können, was erforderlich ist. Das template-Element kann weit mehr enthalten als nur HTML-Elemente und das XSL-Element apply-templates. Zulässig sind z. B. auch andere XSL-Elemente wie choose, when, otherwise, if, script und eval. Diese werden nun beschrieben. Die Elemente choose, when und otherwise Die Elemente choose, when und otherwise arbeiten zusammen und bewirken etwas Ähnliches wie die Select Case-Anweisung in anderen Programmiersprachen. Das choose-Element hat die folgende Syntax:
Dem choose-Element folgt entweder ein when- oder ein otherwise-Element, das die Wahl zwischen verschiedenen Optionen bietet. Das choose-Element kann ein untergeordnetes Element der folgenden Elemente sein: attribute, comment, copy, element, for-each, if, otherwise, pi, template und when. Das when-Element stellt die Testbedingungen für das choose-Element zur Verfügung. Falls das discount-Element noch nicht definiert wurde, ließe sich die Zeile auch durch den folgenden Code ersetzen:
10
5
15
HINWEIS Dieser Code ließe sich nicht in einem template-Element im XSL-Beispieldokument einsetzen, weil dieses auf das discount-Element verweisen müsste, das den Inhalt als discount-Element definieren würde. Weil das unitPrice-Element nicht im Kontext eines discount-Elements enthalten ist, wäre ein Template nicht anwendbar.
240
Kapitel 12
Erfahren Sie nun, wie das when-Element in einem Template eingesetzt wird. Im XSL-Beispieldokument können Sie einem Element je nach seinem Preis (unitPrice) eine unterschiedliche Farbe zuweisen, in dem Sie den Code:
durch den folgenden Code ersetzen:
In diesem Beispiel wird das test-Attribut im Zusammenhang mit dem when-Element eingesetzt. Artikel mit Preisen unter 500 werden grün angezeigt und alle anderen Artikel rot. Das if- Element Mit dem if-Element können Sie auswählen, was ausgegeben werden soll: do something if true
In der obigen Codezeile ist test die Bedingung in der Datenquelle, deren Überprüfung entweder true oder false ergibt. Im Beispielcode wird getestet, ob der Wert des aktuellen Elements kleiner als 500 ist. Der Inhalt der if-Anweisung ist ein Template, das angewendet wird, wenn der Test den Wert true ergibt. Falls mindestens ein Knoten im aktuellen Quelldokument die if-Bedingung erfüllt, wird der Inhalt von xsl:if in die Ausgabe geschrieben. Das eval- Element Das eval-Element gestattet die Auswertung von Skriptausdrücken. Dieses Element kann nur bei einem Stylesheet mit dem xsl-Namespace, http://www.w3.org/TR/WD-xsl, verwendet werden. Es kann nicht in einem Stylesheet eingesetzt werden, das den XSLT-Namespace, http://www. w3.org/1999/XSL/Transform, benutzt. Der XSLT-Namespace wird später in diesem Kapitel ausführlich geprüft. Das eval-Element kann ein untergeordnetes Element der folgenden Elemente sein: attribute, comment, copy, element, for-each, if, otherwise, pi, template und when. Sie finden den Code, der den Einsatz dieses Elements veranschaulicht, im Abschnitt »Das XML-DOM für XSLT und XSL verwenden« später in diesem Kapitel. Die XSL-Elemente, mit denen XML-Knoten eingerichtet werden Sie können auch XSL-Elemente zur Erstellung neuer Knoten benutzen, die in einem aktualisierten XML-Dokument resultieren. Die Elemente, mit denen Knoten erstellt werden, sind attribute, cdata, comment, element, entity-ref und pi. Um ein HTML-Linkattribut für das ItemElement einzurichten, dessen itemID-Attribut den Wert 0001 hat, könnte der folgende Code dienen:
XML-Darstellung mit XSL und CSS
241
http://www.northwindtraders.com/item0001.gif
Die anderen Knotenelemente funktionieren auf ähnliche Weise.
XSLT, XPath und XSL Formatting Objects Die größte Schwierigkeit bei der Arbeit mit einer neuen Technologie wie XML, die sich immer weiter entwickelt, besteht darin, die vielen Änderungen zu berücksichtigen, die an den Spezifikationen vorgenommen werden. XSL wird nun beispielsweise in drei unterschiedliche Spezifikationen aufgeteilt: XSLT, XPath und XSL Formatting Objects (XSL FO). XPath hat seinen Ursprung in XSL. Deshalb benutzt XSL, wie Sie früher in diesem Kapitel gesehen haben, im Wesentlichen die gleiche Syntax wie XPath. Weil XPath in Kapitel 6 ausführlich beschrieben wurde, soll die Diskussion hier nicht noch einmal wiederholt werden. Die FO-Spezifikation (der fo-Namespace) definiert eine Formatierungssemantik, die als XML-Vokabular für die Arbeit mit Dokumenten wie PDFs entwickelt wurde. b XSLT ist eine Sprache mit dem Zweck, XML-Dokumente in andere textbasierte Dokumente umzuwandeln, wie z. B. XHTML-Dokumente. Mit XSLT lassen sich Templates für die Ausgabe erzeugen. Die XML-Daten können dann an diese gesendet werden. Die in Internet Explorer 5 integrierten XSL-Stylesheets sind nicht mit der abschließenden W3C-Empfehlung für XSLT konform. XSLT hat viele neue Funktionen eingeführt, nachdem Internet Explorer 5 bereits freigegeben war. Deshalb müssen die Stylesheets aktualisiert und an die neuen XSLTFunktionen angepasst werden. Bevor beschrieben wird, wie die XSL-Stylesheets aktualisiert werden, sollen die Elemente von XSLT genauer beschrieben werden.
XSLT-Elemente XSLT verwendet einige Elemente, die in XSL bereits auf dieselbe Weise eingesetzt wurden. Die folgenden Elemente haben sich beispielsweise nicht geändert: apply-templates, attribute, element, comment, copy, for-each, if, choose, when und otherwise. Das pi-Element von XSL heißt in XSLT processing-instruction. Die folgenden XSL-Elemente existieren in XSLT nicht: script, cdata, entity-ref und eval. Wenn ein XSL-Dokument in ein XSLT-Dokument konvertiert wird und diese Elemente im XSL-Dokument verwendet werden, muss ein Skript erzeugt werden, um die Elemente zu ersetzen. Genau dazu dient der Microsoft XSL to XSLT Converter für das eval-Element. Dieser Konverter wird im nächsten Abschnitt beschrieben. Das stylesheet-Element existiert in XSLT noch immer, die Attribute haben sich jedoch verändert. Das stylesheet-Element hat nun die folgenden Attribute: extension-element-prefixes, xmlns:xsl und version. Mit dem Attribut extension-element-prefixes wird ein erweiterter Namespace zugewiesen. Der xmlns:xsl-Namespace muss der Namespace http://www.w3.org/1999/ XSL/Transform sein. Sie können auch andere Namespaces integrieren. Die Tabelle 12.2 listet XSLT-Elemente auf, die nicht in XSL enthalten sind.
242
Kapitel 12
Name und Syntax
Beschreibung
< xsl:include href = uri/ >
Die XSLT-Ressource, die vom Wert des Attributs href lokalisiert wird, wird als XML-Dokument geparst und die untergeordneten Elemente des xsl:stylesheet-Elements in diesem Dokument ersetzen das includeElement im äußeren Dokument. Dieses Element wird im Internet Explorer 5-DOM unterstützt.
< xsl:import href = uri/ >
Importiert ein XSLT-Stylesheet. Der Import eines Stylesheets entspricht der Inklusion, die Definitionen und Templateregeln im importierenden Stylesheet haben jedoch eine höhere Priorität als die Templateregeln und Definitionen im importierten Stylesheet.
< xsl:call-template name = Name/ >
Ein template-Element mit einem name-Attribut spezifiziert ein benanntes Template. Ein xsl:call-template-Element ruft ein Template über seinen Namen auf. Es verfügt über ein obligatorisches name-Attribut, das das Template identifiziert, das aufgerufen werden soll. Anders als xsl:apply-templates ändert xsl:call-template nicht den aktuellen Knoten oder die aktuelle Knotenliste.
< xsl:text disable-output-escaping = "yes" | "no" / >
Erzeugt einen Textknoten mit dem Inhalt des text-Elements aus dem Ergebnisbaum. Nebeneinanderliegende Textknoten im Ergebnisbaum werden automatisch verbunden. Ein Template kann auch text-Knoten enthalten. Jeder text-Knoten in einem Template bleibt erhalten, nachdem der Leerraum entfernt wurde. Das Attribut disable-output-escaping kann den Wert yes oder no haben.
< xsl:number level = "single" | "multiple"|"any" count = pattern from = pattern value = number-expression format = { string } lang = { nmtoken } letter-value = { "alphabetic" | "traditional" } grouping-separator = { char } grouping-size = { number } / >
Fügt eine formatierte Zahl in den Ergebnisbaum ein. Die Zahl, die eingefügt werden soll, kann durch einem Ausdruck angegeben werden.
< xsl:sort select = "string" lang = "nmtoken" datatype = {"text"|"number"} order = {"ascending"|"descending"} case-order = {"upper-first"|"lower-first"} / >
Der XPath-Ausdruck im select-Element gibt den Knoten an, auf dem die Sortierung basieren sollte. Das sort-Element wird im Internet Explorer 5 unterstützt, aber nur mit den Attributen select und order.
< xsl:variable name = qualified-name select = "XPath expression" / >
Richtet eine Variable ein, die in einem XSLT-Stylesheet verwendet werden kann. Das Attribut name gibt den Namen der Variablen an, die in Variablenverweisen verwendet werden soll. Um auf den Wert der Variablen zu verweisen, verwenden Sie die Syntax $variable-name. Dieses Element wird vom Internet Explorer 5-DOM unterstützt.
< xsl:param name = qualified-name select = "XPath expression" / >
Deklariert einen Parameter, der in einem XSLT-Stylesheet verwendet werden kann. Um auf den Wert des Parameters zu verweisen, verwenden Sie die Syntax $parameter-name. Dieses Element wird im Internet Explorer 5-DOM unterstützt.
< xsl:copy-of-select select = "XPath expression" / >
Fügt ein Fragment aus einem Ergebnisbaum oder einen Satz von Knoten in den Ergebnisbaum ein. Dieses Element wird im Internet Explorer 5-DOM unterstützt.
< xsl:with-param name = "qualified-name" select = "XPath expression" / >
Übergibt einen Parameter an ein Template. Dieses Element wird vom Internet Explorer 5-DOM unterstützt. ö
XML-Darstellung mit XSL und CSS
243
Name und Syntax
Beschreibung
< xsl:key name = qualified-name match = pattern use = node-set-expression / >
Das key-Element wird benutzt, um Schlüssel zu definieren. Dieses Element bietet Informationen über Schlüssel des Knotens, der mit dem Muster übereinstimmt, das im Attribut match angegeben wird.
< xsl:decimal-format name = qualified-name decimal-separator = char grouping-separator = char infinity = string minus-sign = char NaN = string percent = char per-mille = char zero-digit = char digit = char pattern-separator = char / >
Deklariert ein Dezimalzahlformat, das die Interpretation eines Formatmusters kontrolliert, das von der Funktion format-number verwendet wird. Wenn es ein name-Attribut gibt, deklariert das Element ein benanntes Dezimalzahlformat, ansonsten das Standarddezimalzahlformat.
< xsl:message terminate ="yes"|"no"/ >
Sendet eine Nachricht in einer Weise, die vom XSLT-Prozessor abhängig ist. Der Inhalt der Nachricht ist ein Template. Um ein XML-Fragment zu erzeugen, kann die Nachricht instantiiert werden, indem der Inhalt instantiiert wird. Dieses XML-Fragment ist der Inhalt der Nachricht. Ein XSLT-Prozessor kann das Nachrichtenelement implementieren, indem er einen Warnhinweis ausgibt oder in eine Protokolldatei schreibt. Falls das terminate-Attribut den Wert yes hat, sollte der XSLT-Prozessor die Verarbeitung beenden, nachdem die Nachricht gesendet wurde.
< xsl:fallback / >
Normalerweise bewirkt die Instantiierung des xsl:fallback-Elements nichts. Wenn ein XSLT-Prozessor jedoch einen Fallback für ein instruction-Element durchführt, dann muss, sofern das instruction-Element eines oder mehrere untergeordnete xsl:fallback-Elemente hat, der Inhalt jedes untergeordneten xsl:fallback-Elements der Reihe nach instantiiert werden. Ansonsten muss ein Fehler angezeigt werden. Der Inhalt eines xsl:fallback-Elements ist ein Template.
< xsl:output method = "xml"|"html"|"text" version = nmtoken encoding = string omit-xml-declaration = "yes"|"no" standalone = "yes"|"no" indent = "yes"|"no" media-type = string / >
Gestattet es Stylesheet-Autoren, anzugeben, ob der Ergebnisbaum ausgegeben werden soll. Dieses Element ist nur als Toplevel-Element zulässig und wird vom Internet Explorer 5-DOM unterstützt.
Tabelle 12.2: XSLT-Elemente
XSL in XSLT konvertieren Wie bereits erwähnt, müssen Sie das XSL-Stylesheet aktualisieren, damit es zu der XSLT-Spezifikation des W3C kompatibel ist. Sie müssen insbesondere XSL- und verwandte Namespaces ändern. Unter http://www.wc.org/1999/XSL/Transform steht ein neuer offizieller XSLT-Namespace zur Verfügung. Der XML-Parser kann den neuen Namespace und den bereits vorhandenen Namespace http://www.w3.org/TR/WD-xsl ab der Version 2.6 interpretieren. Da - und -Blöcke in XSLT nicht unterstützt werden, müssen sie in einen XSLTkompatiblen Mechanismus konvertiert werden. Außerdem müssen Sie bei Bedarf JScript-Imple-
244
Kapitel 12
mentierungen der XTLRuntime-Funktionen ergänzen, da das XTLRuntime-Objekt den W3CStandard erweitert. Sie müssen auch alle Operatoren durch ihre XML-Entsprechungen ersetzen. Der Operator $lt$ muss also durch den Operator < ersetzt werden, der Operator $gt$ durch den Operator > usw. Für die Operatoren, für die es keine XML-Entsprechung gibt, wie z. B. ieq, müssen Sie spezielle Funktionen programmieren. Dies klingt zwar nach ziemlich viel Arbeit, Microsoft stellt zu diesem Zweck jedoch einen Konverter namens XSL to XSLT Converter zur Verfügung. Der Konverter ist in Form einer selbstextrahierenden EXE-Datei namens Xsltconv.exe in der Website von Microsoft verfügbar. Wird die Datei Xsltconv.exe ausgeführt, werden die drei Dateien Xsl-xslt-converter.xslt, Readme-xslt.txt und Convert.js extrahiert. Das Programm Convert.js lässt sich von der Eingabeaufforderung aus ausführen. Verwenden Sie dazu die folgende Syntax: PathToConvert.js/convert.js PathToXSLFile/XSLFileName [XSLTFileName]
Der Parameter ist optional. Das Programm führt die gewünschte Konvertierung von einer XSLDatei in eine XSLT-Datei durch. Die Version, die zu dem Zeitpunkt benutzt wurde, als dieses Buch geschrieben wurde, enthielt einige Marotten. So wurde beispielsweise ein Fehler hervorgerufen, wenn das XSL-Dokument Kommentare enthielt. Wenn Sie das XSL-Dokument, das im Abschnitt »Das for-each- und das apply-templates-Element« in diesem Kapitel beschrieben wurde, in ein XSLT-Dokument konvertieren möchten, werden Sie einige Änderungen vorfinden, die nachfolgend beschrieben werden. Das XSLT-Dokument finden Sie auch auf der CD-ROM zum Buch. Das stylesheet-Element wurde wie folgt geändert:
XML-Darstellung mit XSL und CSS
245
Absolute Child Number:
Auf XML-Daten in einem externen XML-Dokument können Sie auch mit dem xml-Element und dem src-Attribut wie folgt verweisen:
Wie oben erwähnt, bietet das XML-DSO die Möglichkeit, XML-Dateninseln zu lesen und zu bearbeiten. Mit dem XML-DSO können Sie auch bestimmte form-Elemente an XML-Daten binden. Dies bedeutet, dass die Daten im XML-DSO im Element angezeigt werden. Nachdem ein Element mit dem XML-DSO an XML-Daten gebunden wurde, werden alle Veränderungen von Daten, die über das XML-DSO vorgenommen werden, in den Elementen wiedergespiegelt, die an die XML-Daten gebunden sind. Dies vereinfacht die Programmierung von webbasierten Benutzerdienstekomponenten erheblich. Nun wird zunächst erklärt, wie HTML-Elemente mit dem XML-DSO an XML-Daten gebunden werden.
HTML-Elemente mit dem XML-DSO an XML-Daten binden Nachdem Sie mit dem xml-Element einen Verweis auf eine XML-Datenquelle eingerichtet haben, können Sie die Daten an HTML-Elemente in einem Dokument binden. Mit einigen dieser Elemente können sie den Inhalt des Elements als Text oder HTML-Code anzeigen. Die Elemente in Tabelle 13.1 können mit dem XML-DSO an XML-Daten gebunden werden.
270
Kapitel 13
HTML-Element
Gebundene Eigenschaft
a
href
applet*
param
button**
innertext, innerhtml
div**
innertext, innerhtml
frame
src
iframe
src
img
src
input* type=checkbox
checked
input* type=hidden
value
input* type=label
value
Input* type=password
value
input* type=radio
checked
input* type=text
value
label**
innertext, innerhtml
marquee**
innertext, innerhtml
object*
param
select*
option
span**
innertext, innerhtml
table
-
text*
value
* Der Inhalt dieses Elements lässt sich aktualisieren. ** Das Element kann als HTML-Code angezeigt werden.
Tabelle 13.1: Elemente, die mit dem XML-DSO an XML-Daten gebunden werden können
Das table-Element ist das einzige HTML-Element, das die Bindung des gesamten Inhalts eines Elements in einem XML-Dokument gestattet (tabellarische Datenbindung).
Beispiele für den Einsatz des XML-DSO In diesem Abschnitt wird ein Beispiel erzeugt, das dem Benutzer gestattet, die Daten zu betrachten, die in einer Dateninsel in einer HTML-Seite gespeichert sind. Dazu wird das XML-DSO eingesetzt. Das Beispiel erzeugt eine Benutzerdienstekomponente, die in Internet Explorer 5 enthalten ist und alle normalen Navigationsschritte durch Datensätze ausführt, wie z. B. Vorwärts, Rückwärts usw. Zunächst müssen die XML-Daten, eine DTD für die XML-Daten und eine HTML-Seite erstellt werden, um die XML-Daten einzubetten. Anschließend muss das DHTML-Skript zur HTML-Seite hinzugefügt werden. Das DHTML-Skript arbeitet mit dem DSO zusammen und gestattet es Benutzern, die Datensätze mit einem Webbrowser durchzugehen. Für dieses Beispiel werden die XML-Daten aus dem BizTalk-Beispiel in Kapitel 12 verwendet. Erzeugen Sie eine Datei namens NorthwindPO.xml und fügen Sie die folgenden XMLDaten in die Datei ein:
Dynamische Benutzerdienstekomponenten erstellen
271
1 pc1010 200 EACH 800.00 10 144000.00
1 monitor17 200 EACH 300.00 20 48000.00
Erzeugen Sie eine DTD namens NorthwindPO.dtd für dieses XML-Dokument, das die folgenden Deklarationen enthält:
Sie können auch das folgende BizTalk-Schema namens NorthwindPO.xsd erzeugen, um die Gültigkeit der Datei NorthwindPO.xml zu überprüfen:
272
Kapitel 13
Beachten Sie, dass das Item-Element so definiert ist, dass es ein- oder mehrmals verwendet werden kann. Diese Art von Element eignet sich hervorragend für die Bindung an eine Tabelle, denn damit wird jede Instanz des Item-Elements in eine Tabellenzeile gestellt. Sie können das folgende HTML-Dokument erzeugen, das das XML-DSO benutzt, um das XMLDokument NorthwindPO.xml im Browser anzuzeigen:
| Line Item | Part No | Quantity | UOM | Unit Price | Discount | Total |
|---|---|---|---|---|---|---|
Dieses HTML-Dokument sieht im Browser wie in Abbildung 13.3 gezeigt aus.
Dynamische Benutzerdienstekomponenten erstellen
273
Abbildung 13.3: Die Datei NorthwindReturn.htm zeigt, wie die XML-DSO-Datenbindung funktioniert
In diesem Beispiel haben Sie die XML-Daten mit dem xml-Element in das XML-Dokument NorthwindPO.xml gesetzt, und zwar in ein DSO-Objekt namens NorthwindDSO. Außerdem haben Sie die Tabelle mit dem datasrc-Attribut an das NorthwindDSO-Objekt gebunden. Sie sind dabei im Wesentlichen genauso vorgegangen wie bei XSL. Allerdings mit dem Unterschied, dass Sie nun eine Technik benutzt haben, die momentan nur in Internet Explorer 5 funktioniert. HINWEIS Um dieses Beispiel zu verbessern, hätten Stylesheets und andere Elemente integriert werden können. Sie wurden jedoch weggelassen, um das Hauptaugenmerk darauf zu richten, wie die XML-DSO-Datenbindung funktioniert. Es wäre anzunehmen, dass jedes Zeilenelement im vorherigen Code Artikel darstellt, die zusammen gehören. In diesem speziellen Beispiel gab es nur ein Zeilenelement (ein line-Element mit dem Wert 1), bei dem ein Computer zusammen mit einem Monitor verkauft wurde. Was wäre, wenn es zwei Zeilenelemente gäbe? Wenn Sie die folgenden zwei Item-Elemente zum Dokument NorthwindPO.XML hinzufügen, sieht die Seite im Webbrowser wie in Abbildung 13.4 aus. Fügen Sie den folgenden Code zum Dokument NorthwindPO.XML hinzu:
2 pc2010 100 EACH 1200.00 10 108000.00
2 monitor19 100 EACH 500.00 10 45000.00
274
Kapitel 13
Abbildung 13.4: Die Datei NorthwindReturn.htm mit zwei neuen Artikeln
Diese Änderung ist zwar akzeptabel, möglicherweise möchten Sie aber für jeden Artikel separate Abschnitte erzeugen. Dazu müssen Sie das XML-Dokument und die DTD geringfügig ändern. Nehmen Sie als Erstes einige Änderungen am XML-Dokument vor. Fügen Sie ein neues Element namens po ein und machen Sie dieses zum Stammelement des Dokuments. Ersetzen Sie das POLines-Element durch das POLine-Element. Nehmen Sie das line-Element aus dem Item-Element heraus und setzen Sie es in das POLine-Element. Das überarbeitete Dokument NorthwindPO.XML sieht nun wie folgt aus:
1
pc1010 200 EACH 800.00 10 144000.00
monitor17 200 EACH 300.00 20 48000.00
2
pc2010 100 EACH
Dynamische Benutzerdienstekomponenten erstellen
275
1200.00 10 108000.00
monitor19 100 EACH 500.00 10 45000.00
Als Nächstes müssen Sie die DTD überarbeiten, damit diese den Änderungen entspricht, die am XML-Dokument vorgenommen wurden. Löschen Sie insbesondere die Deklaration des POLines-Elements und deklarieren Sie die zwei neuen Elemente po und POLine. Machen Sie POLine-Element zum untergeordneten Element von po und deklarieren Sie es so, dass es ein oder mehrmals vorkommen kann. Machen Sie das line-Element zu einem untergeordneten Element von POLine statt von Item. Die neue DTD sieht wie folgt aus:
POLine (line , Item+)> Item (partno , qty , uom , unitPrice , discount , totalAmount)> line (#PCDATA)> partno (#PCDATA)> qty (#PCDATA)> uom (#PCDATA)> unitPrice (#PCDATA)> discount (#PCDATA)> totalAmount (#PCDATA)>
Sie können die Datei NorthwindReturn.htm nun wie folgt umschreiben:
| Line Item | Details |
|
|---|
Sie haben soeben zwei Tabellen erzeugt, wobei eine in die andere verschachtelt ist. Die erste Tabelle verwendet das Element POLine für das sich wiederholende Element, da dieses Element ein- oder mehrmals vorkommen kann. Für die äußere Tabelle wurde das datasrc-Attribut nicht eingerichtet. Für die eingebettete Tabelle muss das Element angegeben werden, das ein- oder mehrmals vorkommen kann. Im Beispiel ist dies das Element Item. Das Dokument sieht wie in Abbildung 13.5 gezeigt aus.
Abbildung 13.5: Die Datei NorthwindReturn2.htm mit getrennten Zeilenelementen
Dynamische Benutzerdienstekomponenten erstellen
277
Das DSO zeigt die XML-Daten, die es enthält, als ADO-Recordset an. Ein Recordset ist eine Datentabelle im Speicher. Mit einem ADO-Recordset lassen sich die Daten über ein Programm verändern. ADO wird in Kapitel 15 ausführlich beschrieben. Für den Zweck in diesem Kapitel kann das ADO-Recordset einfach als Objekt betrachtet werden, dessen Methoden benutzt werden, um die Datenelemente zu durchlaufen. Im Beispiel sind hauptsächlich die Methoden moveFirst, moveLast, movePrevious, moveNext und Fields von Belang. Wenn Sie wissen, wie diese Methoden programmiert werden, können Sie die Vorgehensweise auch leicht auf weitere Methoden wie delete oder addNew übertragen. Bevor die Verwendung dieser Methoden beschrieben wird, muss nun jedoch auf die Ereignisse eingegangen werden, die mit dem XML-DSO verknüpft sind.
Ereignisse des XML-DSO Das XML-DSO ist wie HTML-Elemente mit Ereignissen ausgestattet. Es sind dies die in Tabelle 13.2 aufgeführten Ereignisse. Ereignis
Beschreibung
ondataavailable
Wird ausgelöst, wenn Daten von der Datenquelle eingehen.
ondatasetcomplete Wird ausgelöst, wenn alle Daten von der Datenquelle eingetroffen sind. ondatasetchanged
Wird ausgelöst, wenn sich Daten ändern.
onreadystatechange Wird ausgelöst, wenn sich die readystate-Eigenschaft des DSO ändert. onrowenter
Wird ausgelöst, wenn eine Zeile eingegeben wird.
onrowexit
Wird für ein Recordset ausgelöst, bevor eine weitere Zeile eingegeben wird.
onrowsdelete
Wird ausgelöst, wenn Zeilen aus der aktuellen Datensatzgruppe gelöscht werden sollen.
onrowsinserted
Wird ausgelöst, nachdem Zeilen zur aktuellen Datensatzgruppe hinzugefügt wurden.
oncellchange
Wird ausgelöst, wenn die Daten in einem gebundenen Steuerelement oder einer Tabellenzelle geändert wurden und der Fokus von der Zelle entfernt wurde.
Tabelle 13.2: XML-DSO-Ereignisse
Mit diesen Ereignissen können Sie XML-Daten im DSO-Objekt verwalten. Neben diesen Ereignissen können Sie auch neue Eigenschaften benutzen, die mit dem event-Objekt verknüpft sind. Die Tabelle 13.3 zeigt diese neuen Eigenschaften. Eigenschaft
Beschreibung
bookmarks
Gibt eine Auflistung von Lesezeichen zurück, die die Datensätze identifizieren, die eingefügt oder gelöscht werden müssen. Die Auflistung kann auch Zellen enthalten, deren Inhalt sich geändert hat.
boundElements
Gibt eine Auflistung von Elementen in der HTML-Seite zurück, die an das DSO gebunden sind und das Ereignis hervorgerufen haben.
dataFld
Gibt den Namen der Spalte oder des Felds aus dem ADO-Recordset zurück, das von einem oncellchanged-Ereignis beeinflusst wurde. Somit kann sie im oncellchanged-Ereignis benutzt werden, um anzugeben, welche Felder sich geändert haben.
recordset
Gibt einen Verweis auf das ADO-Recordset zurück, der an das DSO gebunden ist, das das Ereignis ausgelöst hat.
Tabelle 13.3: Eigenschaften, die mit dem Event-Objekt verknüpft sind
278
Kapitel 13
Betrachten Sie nun ein Beispiel, das DHTML, XML-Daten, die in einer Dateninsel enthalten sind und das DSO benutzt. Schreiben Sie die Datei NorthwindPO.XML wie folgt um:
pc1010 200 EACH 800.00 10 144000.00
monitor17 200 EACH 300.00 20 48000.00
pc2010 100 EACH 1200.00 10 108000.00
monitor19 100 EACH 500.00 10 45000.00
Im obigen Code repräsentieren die vier Elemente eine Bestellung mit vier Artikeln. Erzeugen Sie nun das folgende HTML-Dokument:
| Part No | |
| Quantity | 280 Kapitel 13 |
| UOM | |
| Unit Price | |
| Discount | |
| Total | |
Abbildung 13.6 zeigt, wie das Dokument in Internet Explorer 5 aussieht.
Abbildung 13.6: Eine webbasierte Benutzerdienstekomponente, mit der Daten betrachtet werden können
Wie Sie sehen, wurden Visual Basic-Unterroutinen zum Code hinzugefügt, die das XML-DSO einsetzen, um die Datensatzgruppe zu durchlaufen. Diese Unterroutinen wurden mit den onClick-Ereignissen der Schaltflächen verknüpft. Auf diese Weise wird DHTML-Code normalerweise geschrieben. In diesem Beispiel wurde das XML-DSO nicht an Textfelder gebunden. Stattdessen wurden die Textfelder mit der Funktion UpdateTextBoxes gefüllt. Die move-Funktionen bewirken alle, dass die Datensatzposition verschoben wird und rufen dann die Funktion UpdateTextBoxes auf, um die Textfelder zu aktualisieren.
282
Kapitel 13
Zusammenfassung Mit DHTML und der XML-DSO können Sie dynamische webbasierte Benutzerdienstekomponenten erzeugen, die XML benutzen. Da DHTML auf dem Clientcomputer ausgeführt wird, kann es die Benutzerdienstekomponenten bearbeiten, ohne Daten von einem Webserver abrufen zu müssen. Das DHTML-Objektmodell bietet Zugriff auf die Komponenten des Webdokuments. In Kombination mit den Ereignissen, die mit DHTML-Objekten verknüpft sind, bietet dieser Zugriff Webprogrammierern die Möglichkeit, Webanwendungen zu erstellen, die ausführbare Skripts enthalten und auf Eingaben von Benutzern reagieren. DHTML-Verhaltensweise sorgen dafür, dass die Funktionalität von DHTML leichter zugänglich ist und sich einfacher in einem Dokument einsetzen lässt. Sie können das XML-DSO auch einsetzen, um XML-Daten an HTML-Elemente zu binden, sodass Sie die Elemente und Attribute anzeigen können, die in den XML-Daten enthalten sind. In Kapitel 14 werden DHTML und HTCs zusammen eingesetzt, um clientseitige Geschäftsdienstekomponenten zu erzeugen, die Benutzereingaben auswerten können.
Dynamische Benutzerdienstekomponenten erstellen
283
14 286 296 297
Geschäftsdienstekomponenten
Geschäftsdienstekomponenten mit HTC erstellen Kompilierte Komponenten Zusammenfassung
Wie bereits in Kapitel 10 erwähnt, kapseln die Geschäftsdienstekomponenten die Geschäftsregeln eines Systems. Da es viele Arten von Geschäftsregeln gibt, gibt es auch viele verschiedene Typen von Geschäftsdienstekomponenten. Im Zusammenhang mit XML sind dabei Regeln, die die Gültigkeit der Benutzereingaben überprüfen und Regeln, die definieren, wie die XML-Daten vom Server an den Client zurückgegeben werden, am wichtigsten. Diese zwei Regelarten erfordern völlig unterschiedliche Arten von Geschäftsdienstekomponenten. Die Komponenten, die definieren, wie XML-Daten an den Client zurückgegeben werden, werden auf einem Servercomputer ausgeführt. In einer Webanwendung werden diese Komponenten normalerweise auf einem Webserver ausgeführt. Mit den DOM-Objekten lassen sich Daten entweder im XML-Format erzeugen und abrufen, oder in anderen Formaten, die sich leicht in XML umwandeln lassen. Die Geschäftsdienstekomponenten können von einer Active Server Page (ASP) aufgerufen werden, die die Daten an den Client zurückgeben kann. Sie könnten beispielsweise eine Geschäftsdienstekomponente in Microsoft Visual Basic erzeugen, die Daten aus einer Datenbank abruft, die Daten verändert, sie in eine XML-Dateninsel konvertiert, das passende DHTML-Skript erzeugt und die XML-Daten in das DHTML-Skript einbettet. Diese Visual Basic-Komponente kann dann von einer ASP eingesetzt werden, um die Daten an den Client zurückzugeben. Weil das DOM bereits in Kapitel 11 ausführlich beschrieben wurde, wird diese Art von Geschäftsdienstekomponenten hier ausgespart. Die Geschäftsdienstekomponenten, die in diesem Kapitel beschrieben werden, sind Komponenten, die die Gültigkeit der Benutzereingaben überprüfen. Diese Art von Komponente sollte immer, wenn dies möglich ist, auf den Client ausgelagert werden, damit die Auswertung sofort erfolgt. Wie bereits in Kapitel 10 erwähnt, kann jedes Mal eine Verzögerung in der Anwendung auftreten, wenn eine Anforderung zur Auswertung an den Server gesendet wird. Diese Verzögerungen können die Systemleistung beeinträchtigen. Wenn Sie eine nicht browserbasierte Anwendung erstellen, kann es relativ einfach sein, Geschäftsdienstekomponenten zu erzeugen, die die Gültigkeit der Benutzereingaben überprüfen. Sie können beispielsweise verschiedene Komponenten in Visual Basic erstellen, die diese Gültigkeitsüberprüfung vornehmen. Visual Basic verfügt über eine spezielle Art von Objekt, eine so genannte Datenquellenklasse, mit der sich Objekte erstellen lassen, die Objekte automatisch an
285
Formularelemente wie Textfelder oder Tabellen binden. Bei der Erstellung von webbasierten Awendungen können Sie Geschäftsdienstekomponenten mit Visual Basic erstellen. Es gibt aber noch eine weitere Möglichkeit. Mit HTML Components (HTC) können Sie vollkommen webbasierte Anwendungen erstellen. Momentan werden HTCs nur von Internet Explorer 5 unterstützt, es ist jedoch sehr wahrscheinlich, dass zukünftig auch andere Browser in unterschiedlichen Umgebungen diese Unterstützung bieten. Eine HTC kann auch zur Erstellung von Code für Ereignisse benutzt werden, die von den Geschäftsdienstekomponenten im Browser hervorgerufen werden. Da diese Ereignisse von Benutzereingaben ausgelöst werden, eignet sich die HTC ideal für die Auswertung von Benutzereingaben. Erfahren Sie nun, wie Geschäftsdienstekomponenten erstellt werden, die eine HTC nutzen.
Geschäftsdienstekomponenten mit HTC erstellen Wenn Sie wissen, dass auf den Clientcomputern, die eine Geschäftsdienstekomponente nutzen, Internet Explorer 5 installiert ist, können Sie extrem leistungsfähige Webanwendungen für diese Computer mit HTC und DHTML erstellen. Der Beispielcode, den Sie in Kapitel 13 erzeugt haben, konnte nur ganz einfache Aufgabe erledigen. Der DHTML-Code wurde jedoch zunehmend länger und komplexer. Wenn Sie Ihre webbasierten Anwendungen mit zusätzlichen Funktionen ausstatten möchten, ohne dass der Code dadurch zu lang und kompliziert wird, müssen Sie den DHTML-Code aus der HTML-Seite entfernen und ihn als separate Komponente speichern, auf die von einer HTML-Seite verwiesen werden kann. Das HTML-Dokument wird dadurch leichter lesbar und lässt sich einfacher aktualisieren. Erfahren Sie nun, wie Sie den Leistungsumfang Ihrer webbasierten Anwendung aus Kapitel 13 erweitern, sodass die Benutzer die XML-Daten betrachten und bearbeiten können. Wenn Sie dem Benutzer gestatten, die XML-Daten zu verändern, müssen die Gültigkeit der neuen Werte überprüft werden. Wenn diese Überprüfung auf dem Server erfolgen soll, können die Daten entweder geprüft werden, nachdem der Benutzer ein Feld ausgefüllt oder nachdem er alle Felder ausgefüllt hat. Dadurch entsteht häufig eine Zeitverzögerung. Werden die Daten erst an den Server gesendet, nachdem der Benutzer alle Informationen eingegeben hat, ist es für den Benutzer etwas schwierig, nach der Auswertung die Felder zu finden, die von ihm falsch ausgefüllt wurden. Die beste Lösung besteht darin, Geschäftsdienstekomponenten zu erzeugen, die auf dem Client ausgeführt werden und die Gültigkeit von Daten überprüfen können, nachdem sie eingegeben wurden. HINWEIS Wenn Daten auf dem Client überprüft werden, sollte die Gültigkeitsüberprüfung aus Sicherheitsgründen noch einmal auf dem Server wiederholt werden. Es wäre immerhin denkbar, dass bösartige Hacker ungültige Daten abschicken. HTC bietet Webprogrammierern die Möglichkeit, Verhaltensweisen zu implementieren, die über Eigenschaften, Methoden und benutzerdefinierte Ereignisse verfügen. Wie Sie im Beispiel später in diesem Kapitel sehen werden, lässt sich über die Eigenschaften, die in eine HTC integriert werden, eine Gültigkeitsüberprüfung durchführen, wenn sich der Wert einer Eigenschaft ändert. Die Gültigkeitsüberprüfung mit einer HTC bietet verschiedene Vorteile. Erstens lässt sich der Code, der zur Überprüfung eines bestimmten XML-Dokuments verwendet wird, in jeder Webanwendung wiederverwenden, die XML auf der Basis desselben Schemas oder derselben DTD nutzt. Außerdem wird die HTC auf dem Client gespeichert. Deshalb müssen keine Daten zum
286
Kapitel 14
Server gesendet werden. Und falls sich die Regeln für die Gültigkeitsüberprüfung ändern, muss nur die HTC überarbeitet werden und nicht die gesamte HTML-Anwendung, die die HTC benutzt. Vor dem Beispiel sollten Sie sich aber die verschiedenen Elemente ansehen, die in einem HTCDokument eingesetzt werden können. Diese sind in der Tabelle 14.1 aufgelistet.
Element
Beschreibung
COMPONENT
Definiert, das das Dokument ein HTC-Doument ist. Ist das Stammelement eines HTC-Dokuments (HTC kann auch eingesetzt werden).
ATTACH
Verbindet ein Ereignis im Quelldokument mit einer Funktion in der Komponente.
METHOD
Definiert eine Methode, die vom Quelldokument aufgerufen werden kann.
EVENT
Definiert ein Ereignis, das von der HTC ausgelöst werden kann.
PROPERTY
Definiert eine Eigenschaft, auf die vom Quelldokument aus zugegriffen werden kann.
GET
Definiert die Funktion, die aufgerufen wird, wenn der Wert einer Eigenschaft abgerufen wird.
PARAMETER
Definiert einen Parameter für eine Funktion.
PUT
Definiert die Funktion, die aufgerufen wird, wenn der Wert einer Eigenschaft eingerichtet wird.
Tabelle 14.1: HTC-Elemente
Das Beispiel, das Sie nun erstellen werden, speichert die Werte der Felder in Eigenschaften einer HTC. Die put-Funktionen, die mit den Eigenschaften in der HTC verknüpft sind, werten jeden neuen Wert aus. Somit wird das HTC benutzt, um alle Änderungen zu überprüfen, die an den Feldinhalten vorgenommen werden. Ist eine Änderung ungültig, wird der Feldinhalt auf den ursprünglichen Wert zurückgesetzt. Dazu wird der Wert abgerufen, der momentan in der Eigenschaft gespeichert ist. Für die Elemente wird das Präfix der öffentliche Namespaces verwendet, um die Eigenschaften in der HTC als öffentliche Eigenschaften zu identifizieren. Auf öffentliche Eigenschaften können auch externe Dokumente zugreifen. Erstellen Sie nun als Erstes ein Dokument namens ValidatePO.htc, das den folgenden Code enthält:
Dieses Dokument finden Sie auch auf der CD-ROM zum Buch. Wie Sie sehen, werden im Dokument öffentliche Eigenschaften eingesetzt. Der Vorteil davon ist, dass damit die Gültigkeit von Werten überprüft werden kann, sobald der Benutzer versucht, den Wert der Eigenschaft zu verändern. Ist der Wert ungültig, wird der ursprüngliche Wert der Eigenschaft beibehalten und es wird ein Fehler ausgelöst. Bei der obigen HTC wird jedoch nicht wirklich ein Fehler hervorgerufen, sondern der Fehlereigenschaft wird eine Zeichenfolge zugewiesen, die den Fehler erklärt. Die put-Funktionen in diesem Code dienen dazu, sicherzustellen, dass die neuen Werte gültig sind. Ist dies nicht der Fall, setzt die Funktion strError auf einen Wert, der den Fehler erklärt. Ist der Wert gültig, weist die Funktion diesen Wert einer privaten Variablen zu. Jede put-Funktion ist mit dem PUT-Attribut der entsprechenden Eigenschaft verknüpft. Die putPartNo-Funktion ist beispielsweise mit dem PUT-Attribut der PartNo-Eigenschaft verknüpft. Wird der Eigenschaft PartNo ein Wert zugewiesen, wird die Funktion putPartNo aufgerufen. Die get-Funktionen werden eingesetzt, wenn ein bestimmter Wert der Eigenschaft entspricht. Wird beispielsweise die partNo-Eigenschaft benutzt, wird die Funktion getPartNo aufgerufen. Diese gibt dann die private Variable zurück. In den get-Funktionen wird zwar keine Gültigkeitsüberprüfung durchgeführt, dies lässt sich jedoch ändern.
Geschäftsdienstekomponenten
289
Im Quelldokument, das die HTC benutzen wird, wird keine Datenbindung für die Textfelder eingesetzt. Stattdessen wird DHTML dazu verwendet, die vollständige Kontrolle über das Formular zu erhalten, wie dies auch im Beispiel in Kapitel 13 geschehen ist. Schreiben Sie nun Skriptcode, um die Textfelder mit Benutzereingaben zu füllen, die Datensätze zu durchlaufen und die Werte der Eigenschaften im HTC-Dokument abzurufen. Nachfolgend sehen Sie den ersten Teil des HTML-Dokuments mit der Funktion FillText und dem Ereignis ondatasetcomplete:
| Part No | Geschäftsdienstekomponenten 295 Auf der CD-ROM zum Buch finden Sie den vollständigen Code. Dieses Beispieldokument fordert den Benutzer bei ungültigen Eingaben auf, einen neuen Wert einzugeben. Würde dieses Beispiel in einer echten Anwendung eingesetzt werden, wäre noch eine Funktion erforderlich, um die Änderungen zurück an den Server zu senden, wo die neuen XML-Daten verarbeitet werden. Wie Sie sehen, ist es noch immer ziemlich viel Arbeit, eine funktionsfähige Anwendung zu erstellen. Sie hätten auch eine Methode einsetzen können, um die Felder auszuwerten. Dazu hätten Sie die folgende Methode zum HTC-Dokument hinzufügen können: Die CheckValidity-Funktion würde in VBScript wie folgt aussehen: Function CheckValidity (FieldName, NewValue) Select Case FieldName Case "PartNo" If NewValue = "" Then strError = "The PartNo is invalid." End If Case "Quantity" If Not IsNumeric (NewValue) Then strError = "The Quantity is invalid." End If End Select End Function Sie hätten auch die select case-Anweisung verwenden können, um FieldName zu überprüfen und zu testen, ob NewValue für dieses Feld zulässig ist. Programmieren Sie als Übung den vollständigen Code für diese Funktion. Kompilierte Komponenten Sie können Geschäftsdienstekomponenten nicht nur mit HTC erstellen, sondern auch in Visual Basic, Java oder C++ schreiben und dann kompilierte Objekte erzeugen, die von der HTMLSeite verwendet werden. (Es ist auch möglich, eine kompilierte HTC zu erzeugen. Dies ist jedoch nur mit C++ möglich, und der Prozess ist extrem kompliziert.) 296 Kapitel 14 Sie könnten beispielsweise eine Geschäftsdienstekomponente mit einen Visual Basic-Objekt erzeugen, das das DOM-Objekt für die Bearbeitung der XML-Daten verwendet. Dies wird hier jedoch nicht beschrieben, weil der Code, den Sie in Kapitel 11 mit dem DOM erstellt haben, verwendet werden kann, um entweder Client- oder Serverkomponenten zu erzeugen. Eine kompilierte Geschäftsdienstekomponente wird möglicherweise schneller ausgeführt als eine HTC. Dazu muss aber eventuell eine kompilierte Komponente auf dem Clientcomputer installiert werden. In einer kontrollierten Umgebung, in der Sie sicher sein können, dass sich die kompilierte Komponente leicht auf jedem Client installieren lässt, ist diese Lösung vielleicht die bessere Wahl. In einer Umgebung, in der zwar jeder Client Internet Explorer 5 installiert hat, es jedoch verschiedene Arten von Clients gibt, ist es vielleicht besser, HTC zu nutzen. Zusammenfassung In diesem Kapitel haben Sie eine Geschäftsdienstekomponente mit einer HTC erstellt, die auf dem Client ausgeführt wird und die Gültigkeit der Werte von XML-Daten überprüft, die in einer Dateninsel enthalten sind. Diese Komponente teilt den Benutzern sofort mit, ob sie einen unzulässigen Wert eingegeben haben, und setzt das Textfeld dann auf seinen ursprünglichen Wert zurück. Sie haben außerdem das DSO verwendet, um eine Anwendung zu erzeugen, die es dem Benutzer gestattet, die Daten zu betrachten, die in einer Dateninsel enthalten sind. Mit dem DSO können Sie eine webbasierte Benutzerdienstekomponente erzeugen, die mit dem Benutzer über eine HTC interagieren kann, die die Geschäftsregeln für die Anwendung kapselt. Geschäftsdienstekomponenten 297 15 299 305 308 315 317 Datendienstekomponenten und XML ADO 2.5 und XML Die Datenquelle aktualisieren Die ISAPI-Erweiterung für SQL Server Die XSL ISAPI-Erweiterung Zusammenfassung In den letzten Kapiteln wurden Benutzer- und Geschäftsdienstekomponenten beschrieben. In diesem Kapitel erfahren Sie mehr über Datendienstekomponenten. Wie Sie sich vielleicht erinnern werden, werden Datendienstekomponenten benutzt, um Geschäftsinformationen mit Geschäftspartnern auszutauschen, Daten von anderen Systemen zu integrieren und die Geschäftsdaten zu speichern und abzurufen. Es werden zwei Microsoft-Technologien untersucht, die diesen Zweck erfüllen und mit denen Datendienstekomponenten erstellt werden können. Die erste ist Microsoft ActiveX Data Objects (ADO) 2.5. ADO 2.5 vereinfacht den Zugriff auf Daten über Programme. In der zweiten Hälfte des Kapitels werden zwei ISAPI-Erweiterungen (ISAPI Internet Server Application Programming Interface) für IIS (Microsoft Internet-Informationsdienste) beschrieben. Mit der ersten ISAPI-Erweiterung lassen sich Daten mit einem Webbrowser im XML-Format direkt aus einer Microsoft SQL Server 6.5- oder 7.0-Datenbank abrufen. Mit der zweiten Erweiterung kann IIS XML-Daten direkt an den Clientcomputer senden. Außerdem lassen sich XML-Dokumente mit einem XSL-Dokument automatisch in andere Formate umwandeln, falls Microsoft Internet Explorer 5 nicht auf dem Client installiert ist. Die zweite ISAPI-Erweiterung wird zwar nicht benutzt, um Datendienstekomponenten zu erstellen, die auf Daten zugreifen können, sie wird in diesem Kapitel aber trotzdem beschrieben. Zunächst werden nun die XML-Funktionen erklärt, die in ADO 2.5 enthalten sind. ADO 2.5 und XML Mit ADO 2.5 lassen sich Daten aus nahezu jeder Datenquelle einlesen, in einem ADO-Recordset unterbringen (die einer virtuellen Tabelle für die Daten im Hauptspeicher entspricht) und in XML umwandeln. Nachdem die Daten in XML umgewandelt wurden, können sie in einen Datenstrom geschrieben und als Ausgabe für verschiedene Quellen, wie z. B. eine Datei, das ADO ASP Response-Objekt (mit dem Informationen an den Webclient zurückgegeben werden) und das XML-DOM verwendet werden. Die Ausgabe von Daten als XML-Code erfolgt mit der 299 COM-IStream-Schnittstelle. Die Istream-Schnittstelle dient zur Unterstützung von Datenschreib- und -lesevorgängen zu ADO Stream-Objekten. ADO 2.5 benötigt Unterstützung für die IStream-Schnittstelle. Auf der anderen Seite können XML-Daten als Datenquelle für ein schreibgeschütztes Recordset oder ein Recordset mit Lese-/Schreibzugriff in ADO 2.5 verwendet werden. ADO 2.5 lässt sich beispielsweise auf einem Webserver einsetzen, um Daten aus einer Datenbank abzurufen und in einem ADO-Recordset zu speichern. Die Daten werden dann mit ADO 2.5 als XML-Ausgabe an das ASP-Response-Objekt übergeben. Nachdem die XML-Daten beim Client eingetroffen sind, können sie mit DHTML auf dem Client in ein ADO-Recordset eingelesen werden. Mit dem clientseitigen ADO-Recordset und DHTML kann der Benutzer Daten lesen und aktualisieren. Betrachten Sie nun einige Beispiele für die Ein- und Ausgabe von Daten als XML-Code in ADO 2.5. Daten mit ADO 2.5 als XML-Code ausgeben In diesem Beispiel werden Daten aus der SQL Server 7.0-Datenbank Northwind Traders abgerufen und als XML-Code in einer Textdatei gespeichert. Dazu wird ADO 2.6 in einer Visual Basic-Anwendung eingesetzt. Gehen Sie wie folgt vor, um die Beispielanwendung zu erstellen: 1. Öffnen Sie Visual Basic, erzeugen Sie eine Standard-EXE-Anwendung und weisen Sie dem Standardformular den Namen frmADOXML zu. 2. Wählen Sie im Menü Projekt den Befehl Verweise und fügen Sie einen Verweis auf Microsoft ActiveX Data Objects 2.5 Library hinzu. 3. Fügen Sie eine Befehlsschaltfläche mit dem Namen cmdSave und der Beschriftung Speichern (Eigenschaft Caption) hinzu. 4. Fügen Sie den folgenden Code zur Ereignisbehandlungsroutine des Click-Ereignisses der Schaltfläche cmdSave hinzu: Private Dim Dim Set Set Sub cmdSave_Click() objNWRecordset As ADODB.Recordset objNWConnection As ADODB.Connection objNWRecordset = New ADODB.Recordset objNWConnection = New ADODB.Connection objNWConnection.CursorLocation = adUseClient ’IES-FUJI muss in der folgenden Anweisung durch ’die passende Datenquelle ersetzen werden. objNWConnection.Open "Provider=SQLOLEDB.1; " & _ "Integrated Security=SSPI;Persist Security Info=False;" & _ " User ID=sa;Initial Catalog=Northwind;Data Source=IES-FUJI" objNWRecordset.CursorLocation = adUseClient objNWRecordset.CursorType = adOpenStatic Set objNWRecordset.ActiveConnection = objNWConnection objNWRecordset.Open "Products" ’Speichern von Recordset als XML in Datei. objNWRecordset.Save "C:\Products.xml", adPersistXML End Sub Der Code erzeugt zunächst ein ADO Connection-Objekt namens objNWConnection und ein Recordset-Objekt namens objNWRecordset. Dann weist er den Eigenschaften dieser Objekte Werte zu und öffnet die Objekte. Ein Connection-Objekt stellt eine Verbindung zu einer Datenquelle bereit. Ein Recordset-Objekt ist eine virtuelle Tabelle im Hauptspeicher, die die Daten 300 Kapitel 15 enthält, die aus einer Datenquelle abgerufen werden. Die Eigenschaft CursorLocation des Recordset-Objekts legt fest, ob die Daten auf dem Client oder auf dem Server gespeichert werden. Die Eigenschaft CursorLocation legt auch fest, ob die Verbindung mit der Datenbank aufrechterhalten werden muss (Servercursor) oder getrennt werden kann (Clientcursor), während ein nicht verbundenes Recordset erzeugt wird. Die Open-Methode des ADO Connection-Objekts hat als Parameter eine Verbindungszeichenfolge. Die Verbindungszeichenfolge enthält den Katalog, die Datenquelle und die Benutzer-ID. Der Katalog besteht aus der Datenbank, die benutzt werden wird. Die Datenquelle ist der Name des SQL Servers und die Benutzer-ID ist ein gültiger Benutzername, der verwendet wird, um die Verbindung herzustellen. Die Verbindungszeichenfolge stellt eine Verbindung zu einer SQL Server-Datenbank her. Sie müssen den Namen der Datenquelle durch den Namen Ihrer SQL Server-Datenbank ersetzen, die die Datenbank Northwind enthält. Das ADO Connection-Objekt stellt eine Verbindung zur Datenbank Northwind her und das Recordset-Objekt eine Verbindung zur Tabelle Products der Datenbank Northwind. Nachdem diese Verbindungen bestehen, wird die Methode Save des Recordset-Objekts aufgerufen, mit der die Daten als XML-Code gespeichert werden. Wie Sie sehen, verwendet die Save-Methode den Parameter adPersistXML, um die Daten als XML-Code zu speichern. Die XML-Datei, die erzeugt wird, besteht aus zwei Abschnitten. Der erste Abschnitt enthält ein BizTalk-Schema für die Daten und der zweite enthält die tatsächlichen Daten. In der Datei werden vier Namespace-Präfixe benutzt. Das erste Namespace-Präfix ist das Präfix s, das für die Schemadefinition der Daten verwendet wird. Das zweite NamespacePräfix ist das Präfix dt, das für die Datentypdefinitionen im Schema eingesetzt wird. Das dritte Namespace-Präfix heißt rs; es verweist auf die Eigenschaften und Methoden des ADO-Recordsets. Das vierte Namespace-Präfix heißt z und verweist auf die eigentlichen Daten. Die XMLDatei Products.xml, die vom Code der Schaltfläche cmdSave erzeugt wird, sieht wie folgt aus: Datendienstekomponenten und XML 301 § Nun haben Sie mit ADO 2.5 ein XML-Dokument erzeugt, das das Schema und die Daten für die Tabelle Products aus der Datenbank Northwind enthält. HINWEIS Weitere Informationen zu ADO 2.5 finden Sie im Microsoft Data Access Components (MDAC) 2.5 SDK in der Website von Microsoft. In einigen Fällen werden Sie Änderungen an den generierten Daten vornehmen müssen, bevor diese als XML-Code eingesetzt werden können. Falls ein Spaltenname beispielsweise ein ungültiges Zeichen, wie z. B. ein Leerzeichen enthält, müssen Sie den Namen durch einen gültigen 302 Kapitel 15 XML-Namen ersetzen. Ändern Sie dazu das Attribut name und fügen Sie ein rs:name-Attribut hinzu, das den ursprünglichen Namen des Felds enthält. Wenn also eine Spalte in der Datenbank Shipper Name (Name des Zustellers) heißt, wird die folgende AttributeType-Definition erzeugt: Sie müssen diese dann wie folgt ändern: Dieses Dokument kann in Internet Explorer 5 als XML-Dokument geöffnet oder mit einem XSL-Dokument in XHTML oder ein anderes Format umgewandelt werden. Mit der ursprünglichen Datei, die vom Visual Basic-Code erzeugt wird, kann nur ein schreibgeschütztes ADO-Recordset erzeugt werden. Wenn Sie ein aktualisierbares, clientseitiges nicht verbundenes Recordset erzeugen möchten, müssen Sie ein rs:updatable-Attribut zur ElementType-Definition hinzufügen. Ein clientseitiges, nicht verbundenes Recordset hat keine Verbindung zur ursprünglichen Datenquelle. Ein Benutzer kann Datensätze betrachten, überarbeiten, löschen, aktualisieren und hinzufügen. Es muss aber eine Verbindung zur Datenbank eingerichtet werden, um Änderungen in der Datenbank speichern zu können. Um Änderungen zu speichern, muss die Methode UpdateBatch eines ADO-Recordsets aufgerufen werden, nachdem das nicht verbundene Recordset mit der Datenbank verbunden wird. Die Methode UpdateBatch wird eingesetzt, um mehrere aktualisierte Datensätze in einem Aufruf an den Server zu senden. Damit sich die Daten aktualisieren lassen, müssen Sie die ElementType-Definition wie folgt ändern: XML-Daten mit ADO 2.5 einlesen Es ist genauso leicht, die die mit ADO 2.5 erzeugten XML-Daten einzulesen, wie sie auszugeben. Um zu sehen, wie dies in der Beispielanwendung funktioniert, fügen Sie eine weitere Befehlsschaltfläche zum Formular frmADOXML namens cmdRetrieve mit der Beschriftung Abrufen&Hinzufügen hinzu. Fügen Sie den folgenden Code zur Ereignisbehandlungsroutine des Click-Ereignisses der Schaltfläche cmdRetrieve hinzu: Private Sub cmdRetrieve_Click() Dim objNWRecordset As ADODB.Recordset Set objNWRecordset = New ADODB.Recordset 'Öffnen des Recordsets in Datei als XML-Code. objNWRecordset.Open "C:\Products.XML", Options:=adCmdFile 'Hinzufügen von neuem Datensatz. objNWRecordset.AddNew objNWRecordset.Fields("ProductName") = "Test" End Sub Datendienstekomponenten und XML 303 HINWEIS Falls der Code ausgeführt wird, ohne dass das Attribut rs:updatable=’true’ zum Schemaabschnitt der generierten XML-Datei hinzugefügt wird, wird ein Fehler hervorgerufen. Wird Options auf adCmdFile gesetzt, weiß ADO, dass diese Daten aus einer normalen Datei und nicht aus einer Datenbank stammen. Nachdem Sie einen neuen Datensatz hinzugefügt, bearbeitet oder gelöscht haben, müssen Sie die Methode Update des ADO-Recordsets aufrufen. Jedes Mal, wenn Sie die Update-Methode aufrufen, wird der aktualisierte Datensatz im Recordset markiert. Wenn Sie Änderungen am Recordset vornehmen und sie in einer Datei speichern, können Sie die Änderungen sehen. Diese Änderungen werden nur am Recordset vorgenommen und nicht an den Daten in der Datenbank, da keine Verbindung zu dieser besteht. Daten ändern Nachdem Sie nun gesehen haben, wie Daten mit ADO als XML-Code gespeichert und XMLDaten geöffnet werden, erfahren Sie nun, wie XML-Daten geändert werden. Schreiben Sie als Erstes Code, um die Datei Products.xml zu öffnen. Anschließend lassen sich Änderungen an den Daten vornehmen. Dies geschieht mit der Update-Methode des Recordsets. Dann werden die neuen Daten in einer Datei namens ProductsUpdate.xml gespeichert. Fügen Sie zuerst eine weitere Befehlsschaltfläche namens cmdMakeChanges mit der Beschriftung Änderungen vornehmen zum Formular hinzu. Setzen Sie dann den folgenden Code in die Ereignisbehandlungsroutine für das Click-Ereignis der Befehlsschaltfläche cmdMakeChanges: Private Sub cmdMakeChanges_Click() Dim objNWRecordset As ADODB.Recordset Set objNWRecordset = New ADODB.Recordset objNWRecordset.Open "C:\Products.XML", Options:=adCmdFile objNWRecordset.Fields("ProductName") = "Test" objNWRecordset.Update objNWRecordset.MoveLast objNWRecordset.Delete objNWRecordset.Update objNWRecordset.Filter = adFilterPendingRecords objNWRecordset.Save "c:\ProductsUpdate.xml", adPersistXML End Sub Im Beispiel wurde der Produktname des ersten Datensatzes auf Test gesetzt und der letzte Datensatz wurde gelöscht. Der geänderte Datensatz wird dann in der Datei ProductUpdate.xml gespeichert. Nachdem Sie auf die Schaltfläche Änderungen vornehmen geklickt haben, werden Sie die folgenden Zusätze in der Datei ProductUpdate.xml finden: .. . .. . 304 Kapitel 15 , DELETE ein. 7. Deaktivieren Sie schließlich das Kontrollkästchen Skriptmodul und aktivieren Sie das Kontrollkästchen Überprüfen, ob Datei existiert. Wenn Sie Internet Explorer 5 in Windows 2000 benutzen, sieht die Konfiguration wie in Abbildung 15.8 aus. Klicken Sie zwei Mal auf OK. Abbildung 15.8: Anwendungszuordnungen für Internet Explorer 5 8. Wählen Sie auf der Registerkarte Basisverzeichnis im Listenfeld Ausführungsberechtigungen den Eintrag Skripts und ausführbare Dateien, damit die DLL xslisapi XML-Dokumente auf Ihrer Website ausführen darf. 9. Klicken Sie auf OK und schließen Sie das Eigenschaften-Fenster. Nun passiert jeder Request für eine XML-Datei, die die Verarbeitungsanweisung enthält, die xslisapi-DLL. Wenn der Browser, der den Request sendet, Internet Explorer 5 ist, führt die xslisapi-DLL die XSL-Umwandlung auf dem Server aus. Wenn Sie ein server-href-Attribut innerhalb derselben Verarbeitungsanweisung nutzen, können Sie verschiedene Stylesheets für die server- und die clientseitige Verarbeitung einsetzen. Falls die xslisapi-DLL eine serverseitige Verarbeitung vornehmen muss, sucht sie zunächst nach dem server-href-Attribut. Ist dieses vorhanden, benutzt es die XSL-Seite, auf die das Attribut verweist. Falls auf dem Client nicht Internet Explorer 5 installiert ist, wird das Stylesheet zur Umwandlung des Dokuments verwendet, auf das vom server-href-Attribut verwiesen wird. Somit würde die Verarbeitungsanweisung wie folgt aussehen. 316 Kapitel 15 Sie können auch eine spezielle Datei Config.xml im selben Verzeichnis wie die xslisapi-DLL speichern. Diese Konfigurationsdatei ist optional und stellt der xslisapi-DLL zusätzliche Anweisungen zur Verfügung. Zusammenfassung In diesem Kapitel wurden zwei Microsoft-Technologien beschrieben, mit denen Datendienstekomponenten erzeugt werden können, die auf Daten zugreifen. Dies sind ADO 2.5 und die SQL ISAPI-Erweiterung. ADO gestattet den Zugriff auf Daten in einem beliebigen Datenspeicher, wohingegen die SQL ISAPI den Zugriff auf Daten in einer SQL 6.5- oder 7.0-Datenbank erlaubt. Mit ADO und der SQL ISAPI-Erweiterung können Sie XML-Daten erzeugen, die im Browser angezeigt und vom Benutzer verwendet oder aktualisiert werden können. Die XSL ISAPI-Erweiterung gestattet auch die automatische Umwandlung von XML-Dokumenten mit XSL auf dem Server, falls auf dem Client Internet Explorer 5 nicht installiert ist. Dies ist nützlich, falls Sie ASP-Seiten erstellen möchten, die das DOM für Datenübersetzungen nutzen. Im nächsten Kapitel erfahren Sie mehr über Microsoft BizTalk Server 2000, eine neue Technologie, die Geschäftspartnern den Austausch von Informationen erlaubt. Datendienstekomponenten und XML 317 16 319 326 329 334 334 335 336 Microsoft BizTalk Server 2000 Der BizTalk Editor BizTalk Mapper BizTalk Management Desk BizTalk-Dokumente versenden und empfangen BizTalk Server Administration Console Oberfläche für die Überwachung Zusammenfassung Der neue Microsoft BizTalk Server 2000 bietet leistungsfähige Tools für den Informationsaustausch zwischen Unternehmen. Damit können Sie z. B. BizTalks-Schemas erzeugen, Felder und Datensätze einer Spezifikation denen in einer anderen zuordnen und Daten mit XML von einem Unternehmen an ein anderes senden. Diese Tools basieren auf der XML-Technologie und übernehmen die Datenübersetzung für Anwendungsintegrationsserver. Die Website für Microsoft BizTalk Server 2000 finden Sie unter http://www.microsoft.com/biztalkserver/. Von dieser können Sie sich BizTalk Server 2000 Technology Preview herunterladen. Die Site beinhaltet auch eine Installationsanleitung für BizTalk Server. Die fünf Haupttools von BizTalk Server sind BizTalk Editor, BizTalk Mapper, BizTalk Management Desk, BizTalk Server Administration Console und BizTalk Server Tracking. Diese Tools bieten Ihnen die Möglichkeit, Dokumente in verschiedenen Formaten zu senden, zu überprüfen und zu erstellen, mit mehreren Protokollen zu arbeiten und die Zustellung von Dokumenten sicherzustellen. In diesem Kapitel werden die Tools von BizTalk Server 2000 beschrieben. HINWEIS Zum Zeitpunkt, als dieses Buch gedruckt wurde, war die erste Betaversion von BizTalk Server 2000 freigegeben. Sehr wahrscheinlich haben sich beim Endprodukt geringfügige Änderungen ergeben. Der BizTalk Editor Mit dem BizTalk Editor können Sie BizTalk-Dokumente und -Schemas bearbeiten. In den BizTalk Editor können Sie vorhandene Dokumentdefinitionen importieren wie DTDs, BizTalkSchemas, EDI-Spezifikationen (EDI – Electronic Data Interchange) wie ANSI X12 (ANSI – 319 American National Standards Institute) und EDIFACT (Electronic Data Interchange for Administration, Commerce und Transport), einfache Dateien, wohlgeformte XML-Dokumente, strukturierte Dokumentformate und XML-basierte Templates. Sie können auch neue Spezifikationen aus leeren Templates erzeugen. Eine Spezifikation ist ein strukturiertes Dokument, das BizTalk Server 2000 mitteilt, wie die Daten formatiert werden sollen. Alle Spezifikationen werden als XML-Code gespeichert. Erfahren Sie nun, wie BizTalk Editor funktioniert. Wählen Sie Start/Programme/Microsoft BizTalk Server 2000/BizTalk Editor, um den BizTalk Editor zu öffnen. Die Benutzung von BizTalk Editor wird anhand des Dokuments Northwind. biz beschrieben, das Sie in Kapitel 9 erstellt haben. Nehmen Sie zunächst den folgenden Code aus dem Dokument Northwind.biz und speichern Sie ihn unter dem Namen Categories.xml (das customer-Element wurde entfernt, weil BizTalk Editor momentan nur jeweils eine Komponente importiert): Number automatically assigned to a new category Name of food category Picture representing the food category 320 Kapitel 16 Um ein wohlgeformtes XML-Dokument, eine DTD oder ein BizTalk-Schema zu importieren, wählen Sie im Menü Tools den Befehl Import. Es öffnet sich das Dialogfeld Select Import Module wie in Abbildung 16.1 gezeigt. Abbildung 16.1: Das Dialogfeld Select Import Module Da Sie mit einem BizTalk-Schema arbeiten, wählen Sie XML-Data Schema und klicken Sie auf OK. Wählen Sie anschließend die Datei Categories.xml. Sie werden nun darüber informiert, dass group-Elemente nicht unterstützt werden. Klicken Sie einfach auf OK. Die Datensätze und Felder des importierten Schemas werden nun im Spezifikationsbaum des BizTalk-Editors wie in Abbildung 16.2 angezeigt. Abbildung 16.2: Das importierte Schema im BizTalk Editor Wie Sie sehen, hat der BizTalk Editor die meisten Informationen importiert, wie z. B. die Elemente und die untergeordneten Elemente sowie die Werte dieser Elemente. Die Datentypen wurden jedoch nicht importiert. Sie müssen diese selbst hinzufügen. Klicken Sie für das CategoryID-Element auf die Spalte ganz rechts neben Data Type, öffnet sich ein Listenfeld. Wählen Sie in diesem den Eintrag integer[int]. Geben Sie auf diese Weise auch die Datentypen für die anderen Elemente an. Microsoft BizTalk Server 2000 321 Datensätze und Felder Der BizTalk Editor benutzt Datensätze und Felder, um die Dokumentstruktur anzuzeigen. Datensätze und Felder repräsentieren zwei Arten von Komponenten, die in EDI-Dokumenten enthalten sind: Segmente und Elemente. Ein Feld entspricht einen EDI-Element und ein Datensatz einem EDI-Segment. In bezug auf XML können Felder als Elemente betrachtet werden, die Text enthalten oder leer sind, und Datensätze als Elemente, die Text oder andere Elemente enthalten. Wie Sie in Abbildung 16.2 sehen, war der Stammknoten ein Datensatz, der vier Felder enthielt. Der BizTalk Editor interpretiert die Daten, die in den Datensätzen und Feldern einer Dokumentspezifikation enthalten sind und erzeugt eine Spezifikation, die einer XML-Darstellung des Dokuments entspricht. In Abbildung 16. 2 können Sie sehen, dass der BizTalk Editor die fünf Registerkarten Declaration, Reference, Parse, Dictionary und Code List enthält. Diese sollen nun ausführlicher beschrieben werden. Die Registerkarte Declaration Auf der Registerkarte Declaration können Sie benutzerdefinierte Beschreibungen eingeben und diese verändern und löschen. Die Eigenschaften, die auf der Registerkarte Declaration aufgelistet sind, sehen Sie in der Tabelle 16.1. Eigenschaft Beschreibung Name Name des Elements. Description Beschreibung des Elements. Die Eigenschaft kann als Kommentar benutzt werden. Data Type Datentyp des Elements. Model Mögliche Werte sind closed und open. Beim Wert closed muss die Struktur eines Dokuments, das die Spezifikation nutzt, die momentan im BizTalk Editor definiert wird, zu dieser Spezifikation kompatibel sein. Beim Wert open muss ein Dokument, das diese Spezifikation nutzt, nicht zu der Spezifikation kompatibel sein. Type Legt fest, ob diese Komponente ein Attribut oder ein Element ist. Der Stammknoten kann nur ein Element sein. Content Definiert den Typ des Inhalts für ein Element. Der Stammknoten und alle Datensätze mit untergeordneten Elementen haben den Typ Element Only, was bedeutet, dass sie nur Elemente enthalten dürfen. Alle anderen Datensätze können entweder den Typ empty oder den Typ text only haben. Ist diese Eigenschaft auf den Wert empty gesetzt, ist das Element leer. MinLength, MaxLength Wird für Felder oder Datensätze benutzt, die Zeichenfolgen enthalten. Diese Eigenschaft definiert die Feldlänge. Tabelle 16.1: Eigenschaften auf der Registerkarte Declaration Die Registerkarte Reference Die Registerkarte Reference kann verwendet werden, um Eigenschaftswerte für Verweise festzulegen. Es werden Eigenschaften für jede Komponente von BizTalk Editor angeboten. Die Eigenschaften des Stammknotens, von Datensätzen, die nicht Stammknoten sind und von Feldern unterscheiden sich auf der Registerkarte Reference alle. Die auf der Registerkarte Reference 322 Kapitel 16 verfügbaren Eigenschaften für den Stammknoten sehen Sie in der Tabelle 16.2, die Datensatzund Feldeigenschaften in den Tabellen 16.3 und 16.4. Eigenschaft Beschreibung Schema Name Name dieser speziellen Spezifikation. Standard Name eines Industriestandards, wie z B. XML, X12 oder EDIFACT, mit dem dieser Standard erzeugt wurde (falls einer existiert). Standards Version Version des Standards (falls ein Standard benutzt wurde). Document Type Der Dokumenttyp der Spezifikation (falls eine Spezifikation benutzt wurde). Version Versionsnummer der Spezifikation. Default Record Delimiter Legt das Zeichen fest, das als Trennzeichen für die Datensätze benutzt wird. Für die verschiedenen Datensätze können unterschiedliche Zeichen eingesetzt werden. Dies gilt jedoch nur für Nicht-EDI-Standards. Default Field Delimiter Gibt das Zeichen an, das als Trennzeichen für Felder benutzt wird. Sie können verschiedene Zeichen für die unterschiedlichen Felder festlegen. Dies gilt nur für den Nicht-EDI-Standard. Default Subfield Delimiter Gibt das Zeichen an, das als Trennzeichen für untergeordnete Felder verwendet wird. Sie können unterschiedliche Zeichen für die verschiedenen Felder verwenden. Dies gilt nur für Nicht-EDIStandards. Default Escape Character Kann auf die Werte Tab (0x9), LF (0xa) und CR (0xd) gesetzt werden. Dies gilt nur für Nicht-EDIStandards. Unicode Wenn diese Eigenschaft auf Yes gesetzt wird, wird der Unicode-Zeichensatz für die Daten verwendet, die mit dieser Spezifikation verknüpft sind. Falls für diese Eigenschaft kein Wert festgelegt wird, sind sowohl Unicode- als auch Nicht-Unicode-Daten zulässig. Wird diese Eigenschaft auf No gesetzt, sind Unicode-Daten nicht zulässig. Werden ASCII-Daten verwendet, muss diese Eigenschaft auf No gesetzt werden. Receipt Ist diese Eigenschaft auf Yes gesetzt, geht eine Empfangsbestätigung ein, die mitteilt, dass die Nachricht ihr Ziel erreicht hat. Wird die Eigenschaft auf No gesetzt, wird das Dokument, das mit dieser Spezifikation erstellt wurde, zwar überprüft, es wird jedoch beim Empfang der Nachricht keine Eingangsbestätigung verschickt. Envelope Falls diese Spezifikation zu einer EDI-Spezifikation gehört, wählen Sie Yes; andernfalls No. Target Namespace Falls ein BizTalk-Frameworkdokument eingesetzt wird, das einen Namespace nutzt, muss dieser hier aufgelistet werden. Tabelle 16.2: Eigenschaften von Stammknoten auf der Registerkarte Reference Eigenschaft Beschreibung Min Occurs Minimale Häufigkeit, mit der ein Datensatz auftreten darf. Zulässige Werte sind 0 und 1. Max Occurs Maximale Häufigkeit, mit der ein Datensatz auftreten darf. Zulässige Werte sind 1 und *. Wird das Sternchen (*) als Wert benutzt oder kein Wert angegeben, definiert BizTalk Mapper diesen Datensatz als Schleife, falls die Spezifikation in BizTalk Mapper verwendet wird. Tabelle 16.3: Datensatzeigenschaften auf der Registerkarte Reference Microsoft BizTalk Server 2000 323 Eigenschaft Beschreibung Required Falls das Feld erforderlich ist, muss diese Eigenschaft auf den Wert Yes gesetzt werden. Start Position Falls die Eigenschaft eine Position bezeichnet, gibt die Zahl die Startposition des Felds im Datensatz an. End Position Falls die Eigenschaft eine Position bezeichnet, gibt die Zahl die Endposition des Felds im Datensatz an. Tabelle 16.4: Feldeigenschaften auf der Registerkarte Reference Abbildung 16.3 zeigt die Registerkarte Reference für den Stammknoten. Abbildung 16.3: Der BizTalk Editor zeigt die Eigenschaften des Stammknotens auf der Registerkarte Reference Beachten Sie in der Abbildung, dass ein Namespace fehlt, der ursprünglich vorhanden war. Fügen Sie zur Eigenschaft Target Namespace des Stammknotens auf der Registerkarte Reference den Namespace urn:northwindtraders.com.Categories hinzu. Die Registerkarte Parse Auf der Registerkarte Parse können Sie angeben, wie die Felder in einem Dokument definiert sind, das die Spezifikation benutzt, die vom BizTalk Editor erzeugt wird. Die Registerkarte Parse wird für Dokumente verwendet, die begrenzt sind, wie z. B. Textdateien mit Kommas als Trennzeichen. Die Eigenschaften, die verfügbar sind, hängen davon ab, ob mit Feldern oder Datensätzen gearbeitet wird, welcher Standard verwendet wird (X12, EDIFACT oder XML) und welcher Wert für die Eigenschaft Structure angegeben wird. Für den Standard XML stehen beispielsweise auf der Registerkarte Parse keine Eigenschaften zur Verfügung. Weil das Schema, das Sie importiert haben, eine XML-Spezifikation nutzt, können Sie in BizTalk Editor auf der Registerkarte Parse keine Eigenschaftswerte sehen. Falls Sie den Standard X12 oder EDIFACT wählen, können Sie auf der Registerkarte Parse Eigenschaften für trennzeichengetrennte Doku- 324 Kapitel 16 mente Eigenschaften einrichten. Die Eigenschaften auf der Registerkarte Parse sind in den Tabellen 16.5 und 16.6 aufgeführt. Eigenschaft Beschreibung Structure Kann mit Trennzeichen getrennt oder positionsbezogen sein. Falls der Eigenschaft kein Wert zugewiesen wird, wird die Datei als mit Trennzeichen getrennte Datei betrachtet. Source Tag Identifier Name des Quell-Tags, das benutzt wird, um Datensätze Daten zuzuordnen. Source Tag Position Wird in positionsbezogenen Datensätzen eingesetzt und kennzeichnet den Anfang des Tags. Field Order Entweder Prefix (vor jede Komponente wird ein Trennzeichen gesetzt, wie z. B. *aa *bb *cc), Postfix (ein Trennzeichen wird hinter jede Komponente gesetzt, wie z. B. aa* bb* cc*), Infix (ein Trennzeichen wird zwischen die Komponenten gesetzt, wie z. B. aa*bb*cc), oder Blank (unbekannte Reihenfolge). Diese Eigenschaft wird nur für trennzeichenbegrenzte Datensätze eingesetzt. Delimiter Type Kann auf Character (das Zeichen, das als Trennzeichen benutzt wird, wird in der Eigenschaft Delimiter Value definiert), Inherit Record (Trennzeichenzuweisung aus dem vorherigen Datensatz benutzen), Inherit Field (Trennzeichenzuweisung aus dem vorherigen Feld benutzen) oder Inherit Subfield (Trennzeichenzuweisung aus dem vorherigen untergeordneten Feld benutzen) gesetzt werden. Diese Eigenschaft wird nur für trennzeichengetrennte Datensätze benutzt. Delimiter Value Das Zeichen, das für trennzeichenbegrenzten Text eingesetzt wird, falls die Eigenschaft Delimiter Type auf den Wert Character gesetzt wurde. Diese Eigenschaft wird nur für trennzeichengetrennte Datensätze eingesetzt. Escape Type Kann auf die folgenden Werte gesetzt werden: Character (teilt dem Parser mit, dass die Trennzeichenzuweisung aufgegeben werden soll, falls das Zeichen im Dokument enthalten ist. Das Zeichen, das in der Eigenschaft Escape Value angegeben wurde) oder Inherit Escape (für die Vererbung des Escape Types des vorherigen Datensatzes). Escape Value Falls die Eigenschaft Escape Type den Wert Character hat, gibt diese Eigenschaft das Escapezeichen an. Append New Line Falls diese Eigenschaft auf Yes gesetzt ist, gibt dies an, dass der nächste Datensatz in eine neue Zeile gesetzt werden soll, wenn das Datensatztrennzeichen gefunden wird. Ist die Eigenschaft auf den Wert No gesetzt, befinden sich alle Datensätze in einer Zeile. Skip Carriage Return Ist die Eigenschaft auf den Wert Yes gesetzt, übergeht der Parser das Wagenrücklaufzeichen (CR) nach dem Trennzeichen. Skip Line Feed Wird diese Eigenschaft auf Yes gesetzt, übergeht der Parser das Zeilenvorschubzeichen (LF) nach dem Trennzeichen. Ignore Record Count Wird die Eigenschaft auf den Wert Yes gesetzt, zählt der Parser die CR- und LF-Zeichen nicht mit, wenn er die Anzahl der Zeichen ermittelt. Tabelle 16.5: Eigenschaften für Stammknoten und Datensätze auf der Registerkarte Parse Eigenschaft Beschreibung Custom Data Type Wird für Spezifikationen benutzt, die auf dem X12- oder EDIFACT-Standard basieren. Wird nur angewendet, wenn der Strukturtyp begrenzt ist. Custom Date/Time Wird für Spezifikationen eingesetzt, die auf dem X12- oder EDIFACT-Standard basieren. Gilt nur, Format falls der Strukturtyp »mit Trennzeichen getrennt« ist. Justification Für positionale und begrenzte Dateien. Falls die Eigenschaft auf den Wert Left gesetzt wird, werden die Daten, die kleiner als die maximale Länge sind, links ausgerichtet. Beim Wert Right werden die Daten rechts ausgerichtet. Pad Character Ein Zeichen, das benutzt wird, um Leerzeichen in einem Feld zu füllen. Tabelle 16.6: Feldeigenschaften auf der Registerkarte Parse Microsoft BizTalk Server 2000 325 Die Registerkarte Dictionary Die Registerkarte Dictionary dient dazu, Eigenschaften für Agreements (»Vereinbarungen«) einzurichten. Agreements werden im Abschnitt »BizTalk Management Desk« später in diesem Kapitel besprochen. Einfach gesagt dient ein Agreement dazu, Regeln für die Übergabe von Dokumenten zwischen zwei Unternehmen zu definieren. Mit Agreements lassen sich Pipelines erzeugen, über die Dokumente zwischen zwei Servern übergeben werden können. (Pipelines werden später in diesem Kapitel ausführlicher beschrieben.) Die Registerkarte Dictionary gibt an, wo das Agreement gespeichert ist, das für ein Feld benutzt wird. Die Feldeigenschaften auf der Registerkarte Dictionary zeigt Tabelle 16.7. Eigenschaft Beschreibung Source Type Gibt den Dokumentinstanzwert für die Art der Quelle an. Source Value Kennzeichnet die Daten in der Dokumentinstanz, die benutzt werden, um ein Dokument auszuwerten, wie z. B. eine ID. Destination Type Gibt an, ob die Sender- oder Empfängerdaten, die in der Dokumentinstanz enthalten sind, benutzt werden, um die Gültigkeit des Dokuments zu überprüfen. Destination Value Gibt an, ob die Daten zur Angabe des Ziels in der Dokumentinstanz benutzt werden, um die Gültigkeit des Dokuments zu überprüfen. Document Type Gibt an, dass der Dokumentname in der Dokumentinstanz eingesetzt wird, um die Gültigkeit des Dokuments zu überprüfen. Document Node Beim Einsatz eines Envelope-Schemas gibt diese Eigenschaft den Datensatz an, der das eigentliche Dokument beinhaltet. Version Gibt die Dokumentversion an, die benutzt wird, um die Gültigkeit des Dokuments zu überprüfen. Tabelle 16.7: Feldeigenschaften auf der Registerkarte Dictionary BizTalk Mapper Mit BizTalk Mapper lassen sich Felder und Datensätze aus einer Spezifikation den Feldern und Datensätze in einer anderen Spezifikation zuordnen. BizTalk Mapper verwendet Links und Functoids. Ein Link ist eine einfache Kopieroperation des Werts in einem Feld in ein anderes Feld. Ein Link kann auch ein Functoid kopieren. Ein Functoid ist ein Objekt, das komplexe Strukturveränderungsoperationen zwischen Quell- und Zielelementen erlaubt. Bevor eine Spezifikation in BizTalk Mapper genutzt werden kann, muss sie im BizTalk Editor definiert werden. BizTalk Mapper unterstützt EDI, lineare Dateien, XML-Dateien, Schemas und sogar ADORecordsets. BizTalk Mapper kann für die Zuordnung auch XSL-Stylesheets erzeugen. Als Beispiel dafür, wie BizTalk Mapper eingesetzt wird, werden Sie zwei PO-Spezifikationen verwenden, die im Lieferumfang von BizTalk Server 2000 enthalten sind. Gehen Sie wie folgt vor, um festzustellen, wie BizTalk Mapper funktioniert: 1. Klicken Sie auf Start/Programme/Microsoft BizTalk Server 2000/BizTalk Mapper. 2. Wählen Sie im Menü File den Befehl New. Es öffnet sich das Dialogfeld Select Source Specification Type, in dem Sie Local Files wählen können, wenn die Spezifikation auf Ihrem lokalen Computer oder Netzwerk vorliegt. Die Option Template bezieht sich auf Templates, die im Lieferumfang von BizTalk Server enthalten sind. Die Option WebDav Files (Web- 326 Kapitel 16 Dav – Web Distributed Authoring and Versioning) bezieht sich auf Spezifikationen auf gemeinsam genutzten Servern. Für das Beispiel hier nehmen wir an, dass eine Datei mit Bestellungen aus einer lokalen XML-Datei zu einer XML-Datei mit Bestellungen transferiert werden soll, die in einem WebDav-Speicherort abgelegt ist. 3. Klicken Sie im Dialogfeld Select Source Specification Type auf Templates. Wählen Sie XML und anschließend CommonPO.xml. Sie sehen nun das Dialogfeld Select Destination Specification Type. 4. Wählen Sie als Ziel WebDav Files. Es öffnet sich das Dialogfeld Retrieve Destination Specification. Wählen Sie in diesem Microsoft und dann CommonPO.xml. In diesem Beispiel verwenden beide Spezifikationen Felder mit demselben Namen. In anderen Beispielen haben die Felder möglicherweise völlig andere Namen. 5. Erweitern Sie den POHeader in der Quell- und der Zielspezifikation. Sie können die Felder sehen, die im POHeader enthalten sind. Ziehen Sie das Feld Purpose aus der Quelle in das Ziel. Die Zuordnung sollte nun wie in Abbildung 16.4 aussehen. Abbildung 16.4: Microsoft BizTalk Mapper Dadurch, dass Sie die Quell- mit den Zielfeldern verbinden, können Sie eine Zuordnung zwischen einer Spezifikation für die Quelle und das Ziel einrichten. Wenn Sie nun andere Felder verbinden, können Sie im Menü Tools den Befehl Compile Map wählen, um XSL-Code zu erzeugen, der die Umwandlung zwischen den zwei Spezifikationen einrichtet. Abbildung 16.5 zeigt den XSL-Code, der auf der Registerkarte Output am unteren Rand von BizTalk Mapper erzeugt wird, nachdem verschiedene andere Felder gelinkt und dann kompiliert wurden. Wie bereits erwähnt, können Sie mit Functoids komplexe strukturelle Umwandlungen zwischen Quell- und Zielelementen durchführen. Functoids verwenden vordefinierte Formen und spezifische Werte, um Berechnungen durchzuführen. Functoids können Sie in der Functoid Palette auswählen. Gehen Sie wie folgt vor, um mit Functoids zu arbeiten: Microsoft BizTalk Server 2000 327 1. Wählen Sie im Menü View den Befehl Functoid Palette, um diese Palette einzublenden. Abbildung 16.5: Die Registerkarte Output zeigt den XSL-Code nach der Kompilierung 2. Wählen Sie in der Functoid Palette ein Functoid und ziehen Sie dieses in den Gitternetzbereich zwischen der Quelle und dem Ziel in Microsoft BizTalk Mapper. Klicken Sie z. B. auf der Registerkarte Mathematical der Functoid Palette auf das X-Functoid (Multiplikation) und ziehen Sie dieses auf das Gitternetz. Verbinden Sie ein Feld mit dem Functoid, klicken Sie mit der rechten Maustaste auf das Functoid. Wählen Sie dann im Kontextmenü den Befehl Properties, um das Dialogfeld Functoid Properties zu öffnen. Wählen Sie in diesem Fenster die Registerkarte Script. Sie können nun sehen, dass auf dieser eine Funktion erzeugt wurde (siehe Abbildung 16.6). Abbildung 16.6: Die Registerkarte Script im Dialogfeld Functoid Properties 328 Kapitel 16 Im Beispiel ist die Funktion FctMathMultiply1 wie folgt definiert: Function FctMathMultiply1( p_strParm0 ) If ( IsNumeric( p_strParm0 ) ) Then FctMathMultiply1 = CStr ( CDbl( p_strParm0 ) ) Else FctMathMultiply1 = "" End If End Function Wie Sie sehen, ist diese Funktion nur eine Vorlage. Sie müssen sie mit der benötigten Funktionalität ausfüllen, damit sie funktioniert. In der Betaversion von BizTalk Mapper lässt sich dieses Skript im Dialogfeld Functoid Properties nicht bearbeiten. Dies ist jedoch auf der Registerkarte Advanced des Dialogfelds Functoid Palette möglich. (Möglicherweise müssen Sie etwas scrollen, um die Registerkarte Advanced zu sehen.) Kopieren Sie das Custom Visual Basic Script von der Registerkarte Advanced und fügen Sie es im Gitternetz ein, stellen Sie eine Verbindung von einem Feld im Quelldokument zu einem Feld im Zieldokument her und bearbeiten Sie dann das Skript. Zwischen dem Quell- und dem Zielfeld wird nun eine benutzerdefinierte Umwandlung eingerichtet. Wie Sie sehen, lassen sich Umwandlungen mit Functoids leicht durchführen. Wenn Sie die Zuordnung kompilieren, indem Sie im Menü Tools den Befehl Compile Map wählen, enthält das XSL-Skript Funktionen, mit denen diese Umwandlungen durchgeführt werden können. BizTalk Management Desk Das BizTalk Management Desk dient dazu, Beziehungen innerhalb eines Unternehmens oder zwischen Unternehmen einzurichten oder zu unterhalten. Diese Beziehungen bauen auf Agreements (»Vereinbarungen«) auf, d. h. Regeln, die festlegen, wie Informationen ausgetauscht werden. Jedes Agreement hat eine Quell- und eine Zielorganisation oder eine interne Organisation und eine für ihre Anwendungen. Um ein Agreement einzurichten, besteht der erste Schritt darin, eine Standardorganisation auszuwählen, die entweder die Quelle oder das Ziel jedes Agreements sein kann. Anwendungen können entweder die Quelle oder das Ziel sein, nicht aber beides. Falls eine Anwendung benutzt wird, muss sie Bestandteil der Standardorganisation sein. Es muss mindestens eine Dokumentdefinition geben, die festlegt, welche Dokumente die Quelle an das Ziel senden darf. Ein Open Agreement besagt, dass entweder der Empfänger oder der Sender, aber nicht beide, offen sind. Ein Open-Source Agreement hat immer die Standardorganisation als Zielorganisation und eine Open-Destination hat immer die Standardorganisation als Quellorganisation. Ein Agreement definiert die Bewegung von Informationen in eine Richtung. Falls die Standardorganisation die Quelle ist, handelt es sich um ein Outbound Agreement. Falls die Standardorganisation das Ziel ist, handelt es sich um ein Inbound Agreement. Outbound Agreements überwachen die Bewegung von Informationen, die BizTalk Server 2000 verlassen und Inbound Agreements kontrollieren die Bewegung von Informationen zu BizTalk Server 2000. Microsoft BizTalk Server 2000 329 BizTalk Management Desk nutzen In diesem Abschnitt erfahren Sie, wie BizTalk Management Desk funktioniert. Gehen Sie wie folgt vor: 1. Klicken Sie auf Start/Programme/Microsoft BizTalk Server 2000/Microsoft BizTalk Management Desk. Es öffnet sich nun ein Dialogfeld Help, das die Schritte beschreibt, die erforderlich sind, um Informationen zwischen Unternehmen zu versenden. Wenn Sie BizTalk Management Desk nutzen, müssen Sie eine Standardorganisation auswählen. 2. Klicken Sie in der rechten oberen Ecke auf die Schaltfläche Select im Feld Default Organization. Es öffnet sich das Dialogfeld Select An Organization. Falls Sie noch keine Organisation eingerichtet haben, klicken Sie nun auf New. Es öffnet sich der Organization Editor. Erzeugen Sie für dieses Beispiel eine Organisation für Northwind Traders. 3. Geben Sie in auf der Registerkarte General im Feld Organization Name unter Organization Identifiers den Namen Northwind Traders ein. Auf der Registerkarte Identifiers werden Sie feststellen, dass es bereits eine Standardorganisation namens Organization gibt. Allen Organisationen wird dieser Standardwert zugewiesen und Sie sollten ihn weder löschen noch ändern. Sie können so viele Bezeichner erzeugen, wie Sie möchten. Wenn Sie jedoch das X12-Format verwenden, sollten Sie als Standard einen Bezeichner wählen, der aus zwei Zeichen besteht. 4. Um einen neuen Bezeichner zu erzeugen, geben Sie in das Feld Value auf der Registerkarte Identifier den Wert NWT ein und aktivieren das Kontrollkästchen Set As Default. 5. Klicken Sie auf Refresh, um den neuen Wert zur Liste der Bezeichner hinzuzufügen. HINWEIS Mit BizTalk Management Desk können Sie auch benutzerdefinierte Namen mit einem Bezeichner erzeugen und Anwendungen mit den Standardorganisationen verknüpfen. Mehr hierzu finden Sie in der Hilfe zu Microsoft BizTalk Server 2000. 6. Klicken Sie im Organization Editor auf OK und dann im Dialogfeld Select An Organization ebenfalls. Northwind Traders sollte nun als Standardorganisation aufgelistet sein. 7. Der nächste Schritt besteht nun darin, ein Agreement einzurichten. Klicken Sie dazu im Menü File auf New und dann auf Agreement. Es öffnet sich der Agreement Editor. Richten Sie nun eine Informationsbewegung innerhalb des Unternehmens Northwind Traders von seinem Hauptstandort zu seinem europäischen Standort ein. 8. Geben Sie im Agreement Editor in das Feld Agreement Name den Wert Northwind Traders Europe ein. 9. Klicken Sie auf das Symbol Destination. Es öffnet sich wieder das Dialogfeld Select An Organization. 10. Klicken Sie auf New und erzeugen Sie eine Organisation namens Northwind Traders Europe. Geben Sie auf der Registerkarte Identifiert den Wert NWTE ein und machen Sie diesen zum Standard. Wählen Sie anschließend Northwind Traders Europe als Ziel. Nachdem Sie nun das Agreement eingerichtet haben, besteht der nächste Schritt darin, eine Dokumentdefinition zu erzeugen. Eine Dokumentdefinition stellt einen Verweis auf eine Spezifikation bereit, der mit BizTalk Editor erzeugt werden kann. Die ausgehenden und eingehenden Dokumente werden beide mit einer Dokumentdefinition verknüpft. Eine Pipeline verbindet die Dokumentdefinition eines Outbound-Dokuments mit der Dokumentdefinition eines eingehenden Dokuments. Pipelines werden in Agreements und Verteilungslisten definiert. 330 Kapitel 16 Sie können entweder vordefinierte Dokumentdefinitionen benutzen oder eine Spezifikation, die z. B. mit BizTalk Editor erzeugt wurde, um eine neue Definition einzurichten. Wählen Sie dazu im Menü View den Befehl Document Definitions. Es öffnet sich das Dialogfeld Document Definitions Viewer. Sie können jede Spezifikation verwenden, die auf einem Server veröffentlicht ist. Klicken Sie für dieses Beispiel auf New, um das Dialogfeld Document Definition Editor zu öffnen. Klicken Sie im Dialogfeld Document Definition Editor auf Browse. Wählen Sie dann Microsoft und anschließend die Datei Common PO.xml auf dem lokalen Server. Geben Sie im Feld Document Definition Name den Wert CommonPO.xml ein. Sie können die Registerkarte Tracking wählen, falls Sie Felder protokollieren möchten. Sie können zwei der folgenden Feldtypen hinzufügen, die protokolliert werden sollen: integer, real, date und text. Sie können mehrere Felder als benutzerdefinierte Datentypen auswählen. Diese Felder werden zu einer verbundenen XML-Zeichenfolge. Sie können nur Felder überwachen, für die ein Datentyp angegeben wurde. Die protokollierte Information können Sie benutzen, um bestimmte Arten von Geschäftsoperationen auszuführen. Das Mengenangabefeld für einen bestimmten Artikel oder die Gesamtsumme für Bestellungen sind zwei Beispiele, die Sie aufzeichnen und für die Analyse von verschiedenen Geschäftsprozessen nutzen könnten. Im Document Definition Editor können Sie auch Auswahlkriterien hinzufügen. BizTalk Server 2000 überprüft, welche Dokumentdefinition mit einem Dokument verknüpft sind, indem Informationen vom Dokument abgerufen werden. Bei X12- und EDIFACT-Dokumenten lassen sich keine Informationen vom Dokument abrufen. Somit müssen Informationen zur Dokumentdefinition in den Group-Header des X12- oder EDIFACT-Dokuments gesetzt werden. Das Auswahlkriterium kann auch eingesetzt werden, um Group-Header-Informationen für Envelopes ausgehender EDI-Dokumente zu erzeugen. Wenn Sie mit X12 und EDIFACT arbeiten, müssen Sie die folgenden Auswahlkriterien hinzufügen: application_sender_code, application_receiver_code und functional_identifier. Das X12-Format benötigt außerdem das Auswahlkriterium standards_version selection und EDIFACT benötigt die Auswahlkriterien standards_version_ type und the standards_version_value. Fügen Sie nun Auswahlkriterien für die Überwachung hinzu und klicken Sie dazu im Document Definition Editor auf OK. Klicken Sie anschließend im Document Definition Viewer aus Close. Gehen Sie als Nächstes zum Agreement Editor und klicken Sie auf die Schaltfläche Document Definition. Es öffnet sich das Dialogfeld Select Document Definition. Klicken Sie auf die Datei CommonPO.xml, die Sie soeben ausgewählt haben, und klicken Sie dann auf Add. Klicken Sie auf OK. Unterhalb von Document Definition sollte nun der Text Complete zu lesen sein. Nun müssen Sie eine Transportmethode auswählen. Klicken Sie dazu auf die Schaltfläche Transport. Es öffnet sich das Dialogfeld Transport. In diesem können Sie die Transportart auswählen. Wählen Sie für dieses Beispiel die Transportart HTTP. Geben Sie im Feld Address den Wert http://localhost ein, wobei localhost der Name des lokalen Servers ist. Klicken Sie anschließend auf OK, um das Dialogfeld Transport zu schließen. Nun haben Sie alle Vorbereitungen zur Erstellung von Agreements getroffen. Es gibt nun noch einige optionale Dinge, die Sie tun können. Sie können einen Envelope einrichten, die Köpfe oder manchmal auch Fußzeilen für das Dokument erstellen. BizTalk Server 2000 unterstützt momentan die Envelope-Formate Custom XML, ANSI X12, UN/EDIFACT und lineare Datei (entweder mit Trennzeichen oder positional). Sie können auch benutzerdefinierte EnvelopeFormate einrichten. In diesem Beispiel erzeugen Sie keinen Envelope und richten keine Sicherheitseigenschaften ein. Deshalb können Sie im Agreement Editor nun auf Save klicken, um das Dialogfeld Save As zu öffnen. Klicken Sie auf Save Agreement As Complete und dann auf OK. Im BizTalk Microsoft BizTalk Server 2000 331 Management Desk können Sie sehen, dass dies ein Outbound Agreement ist, weil der Sender die Standardorganisation ist. Erstellen Sie nun ein Inbound Agreement: 1. Klicken Sie im Menü File auf New und wählen Sie dann Agreement. Es öffnet sich der Agreement Editor. Nennen Sie das Agreement Internal Order. 2. Klicken Sie auf die Schaltfläche Source, um das Dialogfeld Select An Organization zu öffnen. Klicken Sie in diesem auf New, um den Organization Editor zu öffnen. 3. Geben Sie im Organization Editor im Feld Organization Name den Wert Northwind Traders Order Dept ein. 4. Klicken Sie auf die Registerkarte Identifiers, geben Sie NWTOD als Wert ein und klicken Sie dann auf Set As Default. Klicken Sie auf Refresh und dann im Organization Editor auf OK. Schließen Sie das Dialogfeld Select An Organization. 5. Klicken Sie im Agreement Editor auf die Schaltfläche Source, um das Dialogfeld Select An Organization zu öffnen. Wählen Sie in diesem Northwind Traders Order Dept und klicken Sie auf OK. 6. Klicken Sie auf die Schaltfläche Document Definition, um das Dialogfeld Select Document Definition zu öffnen. Wählen Sie in diesem CommonPO.xml und klicken Sie dann auf OK. 7. Klicken Sie auf die Schaltfläche Transport, wählen Sie im Feld Transport Type den Wert HTTP und geben Sie dann http://localhost ein. Das Ziel sollte Northwind Traders sein. 8. Klicken Sie auf Save, um das Dialogfeld Save As zu öffnen. Wählen Sie die Option Save Agreement As Complete. Dieses Agreement sollte nun im BizTalk Management Desk aufgelistet sein. Pipelines Pipelines verbinden ein Inbound Agreement mit einem Outbound Agreement. Sie könnten z. B. ein Inbound Agreement für eine Bestellannahmeanwendung eingerichtet haben, das Bestellungen annimmt und diese an BizTalk Server 2000 sendet. Sobald die Bestellungen bei BizTalk Server 2000 eingehen, werden die Bestellungen mit einem Outbound Agreement an einen Verteiler gesendet. Die Verbindung des Inbound Agreements mit dem Outbound Agreement erzeugt eine Pipeline. Um eine Pipeline zu erstellen, müssen Sie immer zuerst das Outbound Agreement auswählen. Klicken Sie auf das Agreement Northwind Traders Europe Outbound. Wählen Sie im Menü File den Befehl New und dann Pipeline. Der Pipeline Editor öffnet sich in der rechten unteren Ecke des BizTalk Management Desk. In diesem Beispiel werden die Bestellungen von der Abteilung Internal Orders an BizTalk Server 2000 gesendet und dann an den europäischen Standort weitergeleitet. Dazu setzen sie die beiden Agreements ein, die Sie für diesen Zweck eingerichtet haben. Geben Sie im Pipeline Editor als Namen PO Pipeline ein. Klicken Sie auf die Schaltfläche Inbound Agreement, um das Dialogfeld Select An Inbound Agreement zu öffnen. Wählen Sie Northwind Internal und dann CommonPO.xml als Dokumentdefinition für ein- und ausgehende Dokumente. Klicken Sie auf Save. Um die Pipeline zu betrachten, die Sie erzeugt haben, wählen Sie im Menü View den Befehl Pipeline. Es öffnet sich der Pipeline Viewer, in dem Sie die verfügbaren Pipelines sehen können. 332 Kapitel 16 Verteilerlisten Eine Verteilerliste (Distribution List) besteht aus einem Satz von Outbound Agreements, mit denen ein Dokument an mehrere verschiedene Handelspartner senden lässt. Eine Verteilerliste kann nur ausgehende Dokumentdefinitionen unterstützen. Wenn eine Verteilerliste eingerichtet wird, wird die Standardorganisation automatisch zur Quellorganisation. Um eine Verteilerliste einzurichten, klicken Sie im Menü File auf New und dann auf Distribution Liste, um den Distribution List Editor zu öffnen. Geben Sie im Feld Distribution List Name den Wert Northwind Distribution List ein. Klicken Sie auf die Schaltfläche Browse und wählen Sie im Dialogfeld Select An Outbound Document Definition die Datei CommonPO.xml. Klicken Sie auf OK. Die Schaltfläche Refresh wird nun im Distribution List Editor aktiviert. Klicken Sie auf diese. Das einzige Outbound Agreement, das wir nun erzeugt haben, ist Northwind Traders Europe. Klicken Sie im Dialogfeld Available Agreements auf Add. Wären andere Agreements vorhanden, könnten Sie diese ebenfalls hinzufügen. Klicken Sie auf OK. Methode Beschreibung CheckSuspendedQueue ([DocName As String], [SourceName As String], [DestName As String]) Wird benutzt, um einen Verweis auf eine Liste von Dokumentbehandlungsroutinen für Dokumente zu erhalten, die in der Suspended Queue enthalten sind. DeleteFromSuspendedQueue (DocumentHandleList) Löscht alle angegebenen Dokumente aus der Suspended Queue. GetSuspendedQueueItemDetails (ItemHandle As String, SourceName, DestName, DocName, ReasonCode, ItemData) Gibt Details zu einem Dokument in der Suspended Queue zurück. Submit (lOpenness As MODELDB_OPENNESS_TYPE, [Document As String], [DocName As String], [SourceQualifier As String], [SourceID As String], [DestQualifier As String], [DestID As String], [PipelineName As String], [FilePath As String], [EnvelopeName As String]) As String Sendet ein Dokument für eine synchrone Verarbeitung als Zeichenfolge an BizTalk Server 2000. MODELDB_OPENNESS_TYPE wird benutzt, um festzustellen, ob das Dokument geöffnet ist und kann eine der folgenden Konstanten sein: SubmitSync (Openness As MODELDB_OPENNESS_TYPE, [Document As String], [DocName As String] [SourceQualifier As String], [SourceID As String], [DestQualifier As String], [DestID As String], [PipelineName As String], [FilePath As String], ResponseDocument) [EnvelopeName As String], SubmissionHandle, ResponseDocument) Sendet ein Dokument für die synchrone Verarbeitung als Zeichenfolge an BizTalk Server 2000 und gibt eine Antwort zurück, falls eine bereitgestellt wird. MODELDB_OPENNESS_TYPE_DESTINATION, MODELDB_OPENNESS_TYPE_NOTOPEN und MODELDB_OPENNESS_TYPE_SOURCE. Tabelle 16.8: Methoden der Schnittstelle IInterchange Microsoft BizTalk Server 2000 333 BizTalk-Dokumente versenden und empfangen Nachdem ein Dokument in BizTalk Server 2000 aufgenommen wurde, leitet BizTalk Server 2000 die Nachricht korrekt weiter. Sie können eine Anwendung für die Quelle oder das Ziel verwenden, solange die Quelle oder das Ziel der Standard ist. Sie können auch eine Anwendung erstellen, die eingehende BizTalk-Dokumente vom Server empfängt und ausgehende Dokumente an BizTalk Server 2000 sendet. BizTalk Server 2000 ist mit der IInterchangeSchnittstelle ausgestattet. Diese können die Anwendungen benutzen, die Sie entwickeln, um mit BizTalk Server 2000 zu kommunizieren. Wenn Sie mit Microsoft Visual Basic arbeiten, müssen Sie einen Verweis auf die Microsoft BizTalk Server Interchange 1.0 Type Library einrichten. Sie erhalten dann einen Verweis auf ein Interchange-Objekt. Dieses Objekt implementiert die BizTalk Server-Schnittstelle IInterchange, die mit den in Tabelle 16.8 aufgeführten Methoden ausgestattet ist. Das BizTalk SDK, das im Lieferumfang von BizTalk Server 2000 enthalten und Bestandteil der Hilfedatei von BizTalk Server 2000 ist, enthält einen kompletten Lehrgang und Visual BasicBeispiele, die zeigen, wie die Schnittstelle benutzt wird. BizTalk Server Administration Console Die BizTalk Server Administration Console kann zur Verwaltung von BizTalk Servern eingesetzt werden. Sie können damit globale Servergruppeneigenschaften konfigurieren, wie gemeinsam genutzte Standorte und Warteschlangen für die Überwachung von Dokumenten. Sie können receive-Funktionen wie FTP, File und Message Queuing einrichten und verwalten und Warteschlangen für Geschäftsdokumente betrachten und verwalten. Die BizTalk Server Administration Console ist ein MMC-Snap-In (MMC – Microsoft Management Console). Die Konsole kann vom Systemadministrator verwendet werden. Um die Eigenschaften einer BizTalk Server-Gruppe zu betrachten, klicken Sie mit der rechten Maustaste auf BizTalk Server Group und wählen Sie im Kontextmenü den Befehl Properties. Es öffnet sich das Dialogfeld BizTalk Server Group Properties. Dieses enthält die vier Registerkarten General, Connection, DTA und Errors. Die Registerkarte General wird verwendet, um den Namen des Servers, den SMTP-Host (falls vorhanden) und den WebDAV-URL einzusehen. Die Registerkarte Connection dient zur Definition der SQL Server-Datenbank, die für die DTADatenbank (DTA – Document Tracking and Activity) und auch die Queue-Datenbank eingesetzt, die von allen BizTalk-Servern in der Gruppe verwendet werden. Auf der Registerkarte DTA können Sie die Überwachung ein- und ausgehender Nachrichten einrichten und festlegen, wann das Protokoll gelöscht werden soll. Die Registerkarte Errors dient dazu, festzulegen, ob der Server stoppen oder nicht stoppen soll, wenn ein schwerwiegender Fehler auftritt. WebDAV ist ein Dateisystem, das HTTP benutzt. Alle Spezifikationen und Zuordnungen, die für die Übersetzung und Veränderung von Dokumenten benutzt werden, können in einem WebDAV-Speicher gespeichert und von allen BizTalk-Servern in einer Gruppe benutzt werden. Ein BizTalk-Server kann Dokumente aus einer beliebigen Warteschlange in die Suspended Queue verschieben, wo sie gelöscht oder erneut gesendet werden können. Die Aktion, die in der Suspended Queue vorgenommen wird, hängt von den Verarbeitungsanweisungen für Geschäftsdokumente ab. In der BizTalk Server Administration Console stehen die in Tabelle 16.9 aufgeführten Warteschlangen zur Verfügung; die Fehler, die in Warteschlangen auftreten können und Aktionen zur Fehlerbehebung listet Tabelle 16.10. 334 Kapitel 16 Warteschlangen Beschreibung Work Queue Enthält alle Elemente, die momentan von BizTalk Server 2000 verarbeitet werden. Ein Administrator kann ein Dokument manuell aus dieser Warteschlange in die Suspended Queue verschieben. Retry Queue Enthält alle Elemente, die darauf warten, zugestellt zu werden. Ein Administrator kann ein Dokument manuell von dieser Warteschlange in die Warteschlange Suspended Queue verschieben. Scheduled Queue Enthält alle Dokumente, die verarbeitet wurden und darauf warten, an ihre Verteilerliste gesendet zu werden. Ein Administrator von BizTalk Server 2000 kann ein Dokument aus dieser Warteschlange manuell in die Suspended Queue verschieben. Suspended Queue Enthält alle Elemente, die nicht verarbeitet werden konnten, wie z. B. Parsefehler, Serialisierungsfehler, Probleme beim Auffinden einer Pipelinekonfiguration usw. Die Elemente in dieser Warteschlange können ausgewählt werden und der Administrator kann die Fehlerbeschreibung oder das Dokument einsehen oder das Dokument löschen. In der nachfolgenden Tabelle finden Sie eine Liste mit Parsefehlern und Aktionen, die zur Fehlerbehebung ausgeführt werden können. Tabelle 16.9: Warteschlangen in der BizTalk Server Administration Console Verarbeitungsstatus Fehlerbeschreibung Aktion in Suspended Queue Parser Failure Das Geschäftsdokument konnte von BizTalk Der Inhalt des Dokuments kann betrachtet Server 2000 nicht geparst werden. werden. Das Dokument sollte erst dann erneut übertragen werden, nachdem der Fehler gefunden und korrigiert wurde. Pipeline Failure Das Geschäftsdokument wurde erfolgreich Das Dokument kann betrachtet und erneut geparst, anschließend trat jedoch ein Fehler gesendet werden. auf. Transmission Failure Das Dokument konnte nicht übertragen werden. Das Dokument kann betrachtet und erneut gesendet werden. User Move From Another Shared Queue Ein BizTalk-Server-Administrator hat das Dokument manuell aus einer anderen Warteschlange eingefügt. Das Dokument kann betrachtet und erneut gesendet werden. Unknown Es trat ein unbekannter Fehler auf. Der Inhalt des Dokuments kann betrachtet werden. Das Dokument sollte erst dann erneut gesendet werden, wenn der Fehler gefunden und korrigiert wurde. Tabelle 16.10: Fehler, die in Warteschlangen auftreten und Aktionen zur Fehlerbehebung Oberfläche für die Überwachung BizTalk Server 2000 wird mit einer Oberfläche für die Überwachung aller Dokumente ausgestattet sein, die BizTalk Server 2000 durchlaufen. Zu dem Zeitpunkt, als dieses Buch in den Druck ging, gab es diese Oberfläche noch nicht. Die Oberfläche kann sowohl von Analysten als auch von Systemadministratoren eingesetzt werden. Die Analysten können die Dokumente überwachen und analysieren, die BizTalk Server 2000 durchlaufen und daraus neue Geschäftsstrategien für das Unternehmen ableiten. Durch die Analyse der Kundendaten in den BizTalk-Dokumenten können Analysten beispielsweise Kaufmuster, Kundentypen und Ähnliches ermitteln. Dazu müssen sie benutzerdefinierte Felder erstellen, die nur für die Analyse von Informationen verwendet werden. Systemadministratoren können festlegen, was überwacht werden soll, die Protokollierung von Aktivitäten einrichten und Analysen zur Problembehandlung durchführen. Microsoft BizTalk Server 2000 335 Es können sowohl Quell- als auch Zieldokumente überwacht werden, wenn sie BizTalk Server 2000 passieren. Sie können wählen, ob nur ein einzelnes Dokument überwacht werden soll oder aber Dokumentstapel und dann die Aktivität protokollieren, die mit den überwachten Dokumenten verknüpft ist. In der Überwachungsoberfläche können Sie feststellen, wo ein Dokument gespeichert ist und Informationen über den Namen und den Typ des Quell- und des Zieldokuments sowie das Datum und die Uhrzeit erheben. Außerdem können Sie die Überwachungsoberfläche nutzen, um Daten entweder im XML-Format oder in einem integrierten Format zu speichern und die Details zu den Informationen über Dokumentaktivitäten zu betrachten. Zusammenfassung BizTalk Server 2000 stellt zahlreiche Tools zur Verfügung, mit deren Hilfe Organisationen Dokumente gemeinsam nutzen und Spezifikationen bearbeitet werden können, auf denen diese Dokumente basieren. BizTalk Server 2000 arbeitet zwar mit einer Bandbreite an Formaten zusammen, das angestammte Format von BizTalk besteht jedoch aus XML-Dokumenten, die mit Schemas definiert sind. Mit BizTalk Server kann XML zum Standardformat für den Transport von Informationen durch Unternehmen werden. Weil BizTalk Server 2000 unterschiedliche Formate nutzen kann, lassen sich vorhandene System weiterhin nutzen, während auch Systeme integriert werden können, die erst in den nächsten Jahren erstellt werden. 336 Kapitel 16 Stichwortverzeichnis !ATTLIST-Anweisung 57 !DOCTYPE-Anweisung 62 !ELEMENT-Anweisung 52 #FIXED 60 #IMPLIED 60 #REQUIRED 60 A Absatzelemente 72, 73 Absatzentitäten 73 ADO Datenquelle aktualisieren 305 ADO 2.5 299 XML-Daten einlesen 303 a-Element einrichten 34 all-Element 127 Allgemeine Entitäten 67 Verweis auf 69 Analysierte (parsed) Entitäten 68 annotation-Element 121 Anwendungsfall 175, 180 ANY 52 apply-templates-Element (XSL) 235 Attribute 26 attribute-Element 124 attributeGroup-Element 125 AttributeType-Element (BizTalk) 167 Attributlistendeklaration 57 Attributdatebtypen 57 Aufzählung (Datentyp) 58 Auszeichnungssprachen XV, 13 B basefont-Element einrichten 34 Benennungskonventionen für Elemente 25 Benutzerdienstekomponenten 180 BFC 154 BizTags 154 155 155 155 155 BizTalk 3 AttributeType-Element 167 datatype-Element 165 delivery-Element 158 description-Element 165 Dokumente versenden/empfangen 334 Dokumentelement 168 Dokument-Header 156 Dokumentstruktur 155, 156 ElementType-Element 169 Empfangsbestätigungen 160 expiresAt-Element 161 from-Element 158 group-Element 167 Grundlagen 153 handle-Element 163 identity-Element 161 instance-Element 163 manifest-Element 161 Multipart-MIME 163 Nachrichtenstruktur 154 process-Element 162 properties-Element 160 reference-Element 161 reliability-Element 159 Schema für Northwind Traders 170 Schema-Element 168 Schemas gemeinsam nutzen 172 sentAt-Element 161 to-Element 158 topic-Element 161 type-Element 162 URL 172 BizTalk Editor 319 Datensätze und Felder 322 Registerkarte Declaration 322 Registerkarte Dictionary 326 Registerkarte Parse 324 Registerkarte Reference 322 BizTalk Framework 2.0 153 BizTalk Management Desk 329 nutzen 330 BizTalk Mapper 326 BizTalk Server 2000 319 Oberfläche für Überwachung 335 Verteilerlisten 333 BizTalk Server Administration Console 334 Warteschlangen 335 BizTalk-kompatibler Server 154 BizTalk-Schema vs. DTD und W3C-Schema 173 block elements siehe Absatzelemente 337 body-Abschnitt 33 Werte hinzufügen 38 Books2.xml 223 C CD zum Buch XVII CDATA 57 CellContent-Element einrichten 36 choice-Element 127 choose-Element (XSL) 240 complexType-Element 121 Dokumentgeltungsbereich 130 compositor 128 Convert.js ausführen 245 copy-Element (XSL) 235 CORBA 140 CSS 28 CSS-Dokumente 226 D datatype-Element (BizTalk) 165 Datendienstekomponenten 181 Datenquelle aktualisieren 305 Datentypen Attribute 57 Aufzählung 58 CDATA 57 einfache 112 ENTITIES 58 ENTITY 58 ID 58 IDREF 58 IDREFS 58 komplexe 116 NMTOKEN 59 NMTOKENS 59 überschreiben 137 delivery-Element (BizTalk) 158 description-Element (BizTalk) 165 DHTML 263 Ereignisse 266 event-Objekt 266 Objektmodell 264 DHTML Behaviors siehe DHTML-Verhaltensweisen DHTML-Verhaltensweisen 268 DNA 7 Benutzerdienstekomponenten 180 Datendienstekomponenten 181 Geschäftsdienstekomponenten 181 logische Komponenten 188 DNS XV, 3, 5 DNS-Geschäftsmodell 5 Dokumentelement 168 Dokumentgeltungsbereich 128 Dokumenttypdefinition siehe DTD 338 DOM 193 Dreischichtenmodell 179 logisches 180 physisches 183 DSO 263 Eigenschaften 278 Ereignisse 278 DTD XVI, 14, 49 erstellen 49 externer Verweis 65 für Schemas 119 interner Verweis 62 konditionale Abschnitte 91 mit XML-Dokument verknüpfen 61 Namespaces 97 Verarbeitungsreihenfolge 90 veröffentlichen 65 E EBNF 19 EDI 322 Einfache Datentypen Attribute 115 mit geordneten Facetten 113 mit ungeordneten Facetten 114 Elemente 24 Benennungskonventionen 25 leere 24 ohne Inhalt 24 Verschachtelung 25 element-Element 123, 167 maxOccurs-Attribut 124 minOccurs-Attribut 124 type-Attribut 123 Elementtypdeklaration 52 ElementType-Element (BizTalk) 169 EMPTY 53 ENF 145 Entitäten 67 allgemeine 67 allgemeine, Verweis auf 69 analysierte 68 externe 67, 85 externe analysierte allgemeine 85 externe nicht analysierte allgemeine 88 interne 67, 68 interne allgemeine 69 interne Parameterentitäten 71 Kategorien 68 nicht analysierte 68 Parameter- 67 parsed 68 Überblick 67 unparsed 68 Entities siehe Entitäten ENTITIES (Datentyp) 58 ENTITY (Datentyp) 58 Ereignisse 71 DHTML-Objekte 266 Stichwortverzeichnis eval-Element (XSL) 241 event-Objekt (DHTML) 266 Event-Objekt (DSO) Eigenschaften 278 events 71 expiresAt-Element (BizTalk) 161 Externe Entitäten 67, 85 Externe Parameterentitäten 89 Extranet 7 F Facette 110 Fault-Element 148 faultstring-Element 150 for-each-Element (XSL) 235 from-Element (BizTalk) 158 G Geschäftsdienstekomponenten 181, 285 HTC 286 Geschäftsereignismodell 175 GET-Methode 141 group-Element 126 BizTalk 167 Gruppierung untergeordnete Elemente 54 Gültiges XML-Dokument 23 H handle-Element (BizTalk) 163 head-Abschnitt 31 Werte hinzufügen 38 Helpdesk-Anwendung Code 46 Hilfe.htm 44 HilfeHTM.htm 83 HTC 286 HTC-Elemente 287 HTML 15 Grundlagen 27 logische Elemente 27 physische Elemente 27 Probleme 15 HTML-Code XMLisieren 29 HTML-Dokument body-Abschnitt 33 head-Abschnitt 31 HTTP-Header 141 I ID (Datentyp) 58 identity-Element (BizTalk) 161 IDREF (Datentyp) 58 IDREFS (Datentyp) 58 if-Element (XSL) 241 Stichwortverzeichnis IInterchange Methoden 333 Inhaltselemente 72 instance-Element (BizTalk) 163 Instanzdokument 136 Interne Entitäten 67, 68, 69 Interoperabilität 153 ISAPI-Erweiterung für SQL Server 308 ISO-Standard 8601 159 IXMLDOMAttribute Eigenschaften 209 IXMLDOMDocument Eigenschaften 195, 196 Ereignisse 198 Methoden 197 IXMLDOMDocument2 Eigenschaften 221 IXMLDOMDocument-Schnittstelle Eigenschaften 195 Methoden 195 IXMLDOMElement Methoden 208 zusätzliche Eigenschaft 207 IXMLDOMNamedNodeMap 194 Methoden 204 IXMLDOMParseError Eigenschaften 213 IXMLDOMText Methoden 211 IXMLDOMXSLProcessor Eigenschaften 254 Methoden 255 IXMLHTTPRequest Eigenschaften 215 Methoden 216 IXTLRuntime-Schnittstelle 249 Methoden 252 J JITA 185 Just-in-Time-Aktivierung 185 K Knotenarten 99 Kommentare 26 Komplexe Datentypen 116 Komponenten zustandslos 184 zustandswahrend 184 Kompositor 128 Konditionale Abschnitte 91 L Leere Elemente 24 lexikalischer Raum 110 Locker verbundene Systeme 8 339 M R manifest-Element (BizTalk) 161 Markup Languages siehe Auszeichnungssprachen MDAC 302 M-POST 141 M-POST-Methode 146 MultiPart-MIME 163 recurringDuration (Schemadatentyp) 112 reference-Element (BizTalk) 161 reliability-Element (BizTalk) 159 Request 141 Response 141 N Schema Informationen identifizieren 174 Schemadatentyp timeDuration 111 timeInstant 111 schema-Element 121 Schema-Element (BizTalk) 168 Schemas Datentypen 110 Schemas 109 all-Element 127 annotation-Element 121 Attribute für einfache Datentypen 115 attribute-Element 124 attributeGroup-Element 125 aus anderem Namespace 136 choice-Element 127 complexType-Element 121 complexType-Elemente, globale 130 compositor 128 Datentypen überschreiben 137 DTD für 119 einfache Datentypen 109, 112 einfache Datentypen mit Facetten 113 element-Element 123 für datenorientierte XML-Dokumente 132 group-Element 126 komplexe Datentypen 116 Kompositor 128 öffnen in XML-Tools 116 particle 128 Partikel 128 Platzhalter 128 schema-Element 121 selber Namespace 135 sequence-Element 127 und Namespaces 134 Scriptlets 264 sentAt-Element (BizTalk) 161 sequence-Element 127 SGML 14 Singleton 25 Skalierbarkeit Hardwarelösungen 6 Softwarelösungen 7 SOAP 139 Anforderungen übersenden 141 einfache Nachrichten 143 Fault-Element 148 faultstring-Element 150 Fehlercodes 149 Nachrichtenübergabe 139 Namensräume siehe Namespaces Namespace Präfixe 95 Standard- 96 Namespaces 94 in DTDs deklarieren 97 und Attribute 97 Nicht analysierte (parsed) Entitäten 68 NMTOKEN (Datentyp) 59 NMTOKENS (Datentyp) 59 Northwind Traders BizTalk-Schema 170 NorthwindDSO 274 NorthwindMessage.xsd 135 NorthwindPO.xml 228 NorthwindPO.xsl 230 Notation-Deklaration 88 O ORB 140 otherwise-Element (XSL) 240 P Parameterentäten XHTML-Standard 72 Parameterentität deklarieren 71 externe deklarieren 90 Parameterentitäten benutzen 72 externe 89 in Attributen 74 interne 71 Probleme 83 Verweis auf 71 Parameterentitäten 67 Parsed Entity siehe analysierte Entitäten payload 142 PCDATA 52 Pipelines 332 POST-Methode 141 Präfixe 95 process-Element (BizTalk) 162 properties-Element (BizTalk) 160 340 S Stichwortverzeichnis SOAP (Fortsetzung) HTTP-Header 141 Inhalt der Response 147 Inhalt des Requests 143 M-POST-Methode 146 Request Header 141 Request/Response-Modell 140 Response Headers 142 SOAPAction-Header-Feld 142 SOAP 4 SOAPAction-Header 142 SQL Server 309 ISAPI-Erweiterung 308 Stammelement 30 Standard.xml 38 Standarddeklaration 60 Standard-Namespaces 96 Standardtemplates Vorteile 42 StandXHTML.dtd 81 StartCD.exe XVII Streams 307 stylesheet-Element (XSL) 231 Stylesheets 28 T table-Element einrichten 34 targetNamespace-Element in Schemas aufnehmen 135 template-Element (XSL) 231 Templates, Vorteile 42 Three-tier model siehe Dreischichtenmodell timeDuration (Schemadatentyp) 111 timeInstant (Schemadatentyp) 111 to-Element (BizTalk) 158 topic-Element (BizTalk) 161 TransformXML.vbp 257 type-Element (BizTalk) 162 U Ungeordnete Menge untergeordnete Elemente 56 Unparsed Entity siehe nicht analysierte Entitäten Untergeordnete Elemente gruppieren 54 ungeordnete Menge 56 URI 65 V value-of-Element (XSL) 231 Verschachtelung von Elementen 25 Verteilte Systeme Kommunikation 139 Verteiltes System Design 185 Stichwortverzeichnis W Webhilfeseite einrichten 38 Werteraum 110 when-Element (XSL) 240 Windows DNA-Systeme 7, 179 Wissensarbeiter 4 Wohlgeformte XML-Dokumente 23 Kriterien 45 X XDRs 164 XHTML CSS 226 XHTMLschema.xsd wichtige Elemente 117 XHTML-Standard 72 XLink 93, 106 Attribute 106 einfache Links 106 erweiterte Links 107 Spezifikation 107 XLink-Element 106 XLL-Spezifikation 19 xml 95 XML 18 ADO 2.5 299 DOM 193 DSO 263 DSO-Ereignisse 278 gültiges Dokument 23 mit XSL umwandeln 230 Vorteile 20 wohlgeformtes Dokument 23 Ziele 18 XML Authority 48 XML Instance 48 XML Namespace 93 XML Notepad 29 XML Pro 44 XML SDK 2.5 220 XML Spy 43, 48 XML-Deklaration 46 XML-Dokument 23 Beispiel 46 Grundbestandteile und Elemente 24 XML-Deklaration hinzufügen 46 wohlgeformt 45 XML-DOM Implementierung 193 XMLDOMAttribute-Objekt 209 XMLDOMCDATASection-Objekt 211 XMLDOMCharacterData-Objekt 210 XMLDOMComment-Objekt 211 XMLDOMDocument-Objekt 194 XMLDOMDocument2-Objekt 221 XMLDOMDocumentFragment-Objekt 207 XMLDOMDocumentType-Objekt 205 XMLDOMElement-Objekt 207 341 XMLDOMEntity-Objekt 209 XMLDOMEntityReference-Objekt 209 XMLDOMImplementation-Objekt 212 XMLDOMNamedNodeMap-Objekt 204 XMLDOMNode-Objekt 198 XMLDOMNodeList-Objekt 202 XMLDOMNotation-Objekt 210 XMLDOMParseError-Objekt 212 XMLDOMProcessingInstruction-Objekt 211 XMLDOMText-Objekt 211 XML-DSO 270 Beispiele 271 XML-Editor 43 XML Authority 48 XML Instance 48 XML Notepad 29 XML Pro 44 XML Spy 43 XML-Elementmarker 54 XMLHTTPRequest-Objekt 215 XMLisieren 29 xmlns 95 XML-Parser, Versionen 220 XML-Pfade 98 XML-Schemas 109 XML-Spezifikation 19 XML-Tools XVII XPath 93, 98, 242 Achsen 100 Achsentypen 101 Attributknoten 99 Boolesche Funktionen 247 Elementknoten 99 Knotenarten 99 Knotenfunktionen 248 Kommentarknoten 100 Namespace-Knoten 99 Pfadangaben 98 Stammknoten 99 Textknoten 100 Verarbeitungsanweisungsknoten 100 Zahlenfunktionen 249 Zeichenfolgenfunktionen 248 342 XPath-Funktionen 247 Boolesche Funktionen 247 XPath-Muster 103 XPointer 93, 104 XSL apply-templates-Element 235 choose-Element 240 copy-Element 235 Darstellung von XML-Dokumenten 226 eval-Element 241 for-each-Element 235 if-Element 241 in XSLT konvertieren 244 otherwise-Element 240 stylesheet-Element 231 template-Element 231 value-of-Element 231 when-Element 240 XMLDOMXSLProcessor-Objekt 254 XMLDOMXSLTemplate 254 XSL FO siehe XSL Formatting Objects XSL Formatting Objects 242 XSL ISAPI-Erweiterung 315 XSL to XSLT Converter 245 XSL-Dokumentelemente 231 XSL-Filteroperatoren 229 Xslisapi.exe 315 xslisapi-DLL 316 XSL-Muster 229 XSL-Operatoren 230 XSL-Spezifikation 19 XSLT 242 Xsltconv.exe 245 XSLT-Elemente 242, 244 XSLT-Funktionen 249 XTLRuntime-Objekt 215 Z Zeichenverweise 69 Zustandsbehaftete Komponenten 184 Zustandslose Komponenten 184 Stichwortverzeichnis Der Autor Jake Sturm verfügt über große Erfahrung auf allen Gebieten der Softwareentwicklung für Unternehmen. Jake hat ein breites Spektrum an Lösungen programmiert, wie z. B. Webanwendungen mit Microsoft Visual Basic, Microsoft Internet-Informationsdienste (IIS), Microsoft Transaction Server (MTS) und Microsoft SQL Server. Er hat die Entwicklung eines Microsoft Windows DNA-Workshops unterstützt und ist Autor zahlreicher Fachbücher, wie z. B. Data Warehousing with Microsoft SQL 7.0 Technical Reference (Microsoft Press, 2000), VB6 UML Design und Development (Wrox Press, 1999) und Visual Basic Project Management (Wrox Press, 1999). Momentan arbeitet Jake für das Unternehmen Innovative Enterprise Solutions als Enterprise Systems Architect und hält Jake Sturm Workshops zu zahlreichen Themen, wie z. B. XML und Windows DNA. Sie erreichen Jake unter der E-Mail-Adresse [email protected] und über die Website seines Unternehmens, http://ies.gti.net. Jake wohnt mit seiner Frau Gwen, ihren beiden Töchtern, Jillian und Lynzie, seinem Sohn William und seiner Tochter Maya in New Jersey. 343 |