|
Was ist XML
Auslesen eines XML Dokumentes mit XSL
Ausführen eines XSL Stylesheets
Nur manche Knoten zeigen
HTML Tags über ein XSL Stylesheet generieren
lassen
XML Dokumente direkt im Browser zeigen
XML erlaubt es, die hierarschische Struktur
von Daten in beliebiger Präzision darzustellen. Allerdings
macht XML weder eine Aussage darüber wie die Daten dargestellt
werden noch auf welchem Medium. Somit ist klar, dass XML mit
HTML praktisch nichts zu tun hat. Bei HTML geht es fast ausschliesslich
um die Darstellung von Daten im Web. Bei HTML geht es primär
um die Darstellung von Daten. Bei XML spielt das überhaupt
keine Rolle. XML erlaubt es lediglich, Daten in einer hierarchischen
Struktur, einer Baumstruktur, darzustellen. Um XML Dokumente
dann tatsächlich darzustellen und die Gestaltung der
Daten zu beeinflussen bedarf es einer weiteren Programmiersprache.
Die Mächtigste davon ist wohl XSL. Zu den verschiedenen
Anätzen XML Dokumente auszulesen werden wir in Kürze
ein Handbuch schreiben. Hier wird nur das beschrieben, was
man braucht, um das folgende Kapitel, XML/XSL und Sablotron
zu verstehen. Das XML Dokument, auf dem alle Beispiel aufsetzen,
sieht so aus.
<?xml version="1.0" encoding="iso-8859-1"
?>
<waren>
<nahrungsmittel>
<Milchprodukte>
<kaese>
<preis was="kilo">12</preis>
<währung>€</währung>
<herkunftsland genau="Amsterdam">Holland</herkunftsland>
<name>Gouda</name>
</kaese>
<kaese>
<preis was="kilo">23</preis>
<währung>€</währung>
<herkunftsland genau="Biel">Schweiz</herkunftsland>
<name>Emmentaler</name>
</kaese>
<yoghurt>
<preis was="kilo">1.20</preis>
<währung>€</währung>
<herkunftsland genau="Florenz">Italien</herkunftsland>
<name>Bioghurt, Geschmack, Kaffee</name>
</yoghurt>
</Milchprodukte>
<Fleischwaren>
<Wurst>
<preis was="gramm">2.44</preis>
<währung>€</währung>
<herkunftsland genau="Thüringen">Deutschland<sprache>Deutsch</sprache></herkunftsland>
<name>Thüringer Rostbratwurst</name>
</Wurst>
<Wurst>
<preis was="gramm">3.40</preis>
<währung>€</währung>
<herkunftsland genau="Freiburg">Deutschland</herkunftsland>
<name>alemanischer Leberkaes</name>
</Wurst>
</Fleischwaren>
</nahrungsmittel>
<kosmetik>
<duft>
<parfüm>
<name>Ives Saint Laurent</name>
<preis>230</preis>
<währung>€</währung>
</parfüm>
<parfüm>
<name>Le Rocher</name>
<herkunftsland genau="Biel">Schweiz</herkunftsland>
<preis>230</preis>
<währung>€</währung>
</parfüm>
</duft>
</kosmetik>
</waren>
Wir sehen, dass dieses Dokument eine Baumstruktur hat, die
so aussieht.
Die Struktur des XML Dokuments ist damit
selbsterklärend. Mit der Zeile
<?xml version="1.0" encoding="iso-8859-1"
?>
teilen wir dem verarbeitenden Programm,
Browser, saxon, sablotron etc. mit, welche XML Version wir
verwenden. Weiter geben wir den Zeichensatz an, den wir verwenden.
Das ist wichtig, weil sonst unter Umständen z.B. deutsche
Umlaute nicht dargestellt werden. Als nächstes kommt
das sogenannten Wurzelelement waren. Es steht am Anfang der
Hierarchie und umfasst alle anderen Tags. Anschliessend werden
die Blöcke definiert, Nahrungsmittel und Kosmetik, die
selber wieder aufgeteilt sind in Blöcke. Jeder Block
wird von einem öffnenden und einem schliessenden Tag
umklammert. Tags können, wie in HTML auch, Attribute
haben. Wir haben dies zum Beispiel bei den Wurstwaren, von
der Tag Preis das Attribut Gramm hat. Der Name der Tags kann
freigewählt werden, allerdings, grosser Unterschied zu
HTML, die Tags sind case sensitiv, es ist also falsch, einen
Block mit
<Kaese>
zu öffnen und mit
</kaese>
zu schliessen. Weiter müssen die Blöcke
korrekt verschachtelt sein, der innere Block muss also immer
vor dem äusseren Block geschlossen werden. Weiter gibt
es in XML keine Tags, die keinen schliessenden Tags haben
wie etwa <pre>, <br>,
<img src=tralala.jpg>. Für
das oben gezeigte xml-Dokument wird im Interent Explorer die
Struktut angezeigt: zeigen
Kommen wir zum eigentlich spannenden Teil. Wie liest man XML
Dokumente aus.
| Auslesen
eines XML Dokumentes mit XSL |
|
Installation saxon
Das erste was wir brauchen, ist eine Software,
die XSL versteht. Hier stehen uns im wesentlichen drei Pakete
zur Verfügung. Zum einen Sablotron, den werden wir verwenden,
wenn wir tatsächlich über PHP XML Dokumente auslesen,
siehe XML / XSL Sablotron.
Weiter, wenn wir uns die Dokumente direkt im Browser anschauen
wollen, könnten wir auch msxml von Microsoft verwenden.
Das werden wir nachher kurz tun. Für den Einstieg ist
aber die einfachste Variante es mit Saxon zu machen, den wir
hier downloaden können.
Wir packen die Datei saxon.exe in einen Ordner, den wir vorher
eingerichtet haben, z.B. xmltest. Dann sind wir startklar
und es kann losgehen.
| Ausführen
eines XSL Stylesheets |
|
Im gleichen Ordner, in den die Datei
saxon.exe abgelegt wurde, speichern wie auch oben stehendes
XML Dokument unter dem Namen nahrung.xml. Es ist günstig,
es so zu machen, da im folgenden immer davon davon ausgegangen
wird, dass die Datei so heisst. Unser erstes XSL Stylesheet
hat folgendes Aussehen.
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:value-of select="."/>hallo
</xsl:template>
</xsl:stylesheet>
Bevor wir besprechen, wie es funktionniert,
lösen wir es erstmal aus. Wir fahren mit der Dos Box
oder der Eingabeaufforderung in den Ordner, wo die drei Dateien
sind, also saxon.exe, die XML Datei und das obige XSL Stylesheet.
Dann geben wir ein saxon name_der_xml_datei.xml name_der_xsl_datei.xsl
Wir sehen dann, dass alle Knoten des Dokuments
auf dem Schirm erscheinen. Zur Verdeutlichung zeigen wir einen
Ausschnitt
... weitere Daten.....
Bioghurt, Geschmack, Kaffe
2.44
€
DeutschlandDeutsch
Thüringer Rostbratwurst
3.40
€
Deutschland
alemanischer Leberkaes
Ives Saint Laurent
230
€
Le Rocher
Schweiz
230
€
hallo
Aus Gründen der besseren Lesbarkeit,
wurden die Sonderzeichen wieder eingesetzt. Bei einer Auswertung
im Browser, was wir eigentlich wollen, entsteht dieses Problem
nicht. Die Frage, die sich jetzt stellt, ist wieso wir alle
Datensätze sehen. Die Erklärung hierfür ist
einfach. Mit
<xsl:template match="/">
</xsl:template>
legen wir fest, für welchen Knoten
wir das Template definieren. Hierbei steht der Slash für
den Wurzelknoten, den es nur einmal gibt. Ein template wird
aber so oft aufgerufen, wie es den dazugehörigen Knoten
gibt. Beispielsweise würde das Template
<XSL:TEMPLATE MATCH="waren/Nahrungsmittel/Milchprodukte/kaese">
</XSL:TEMPLATE>
zweimal aufgerufen, da es zwei Knoten
gibt, die kaese heissen (
<kaese>Inhalt</kaese>
gibt es zweimal). Wir stellen also fest,
ein Template wird so oft aufgerufen, wie es den entsprechenden
Knoten gibt. Das wäre nun noch lange kein Grund, alle
Knoten zu zeigen, was ja tatsächlich passiert. Auch dies
läßt sich aber erklären. Innerhalb eines Templates
wird definiert, was passieren soll, wenn der entsprechende
Knoten aufgerufen wird. Wir definieren in dem Beispiel oben
mit
<XSL:VALUE-OF SELECT="."/>hallo
dass er den Knoten zeigen soll, in dem er sich
aktuell befindet. Der default ist nun aber nicht, dass ein
Knoten, der nicht explizit aufgerufen wird, nicht erscheint,
sondern genau umgekehrt. Auch ein Knoten, der nicht expressis
verbis aufgerufen wird erscheint. Will man, dass er nicht
erscheint, so muss man das angeben. Da wir aber keine Knoten
ausschliessen, erscheinen alle. Das hallo dient hier didaktischen
Zwecken. Wie deutlich zu sehen, erscheint hallo nur einmal,
weil das Template ja auch nur einmal aufgerufen wird, da es
den Wurzelknoten nur einmal gibt. Anders herum ausgedrückt,
eine solche Definition eines Templates nützt uns in der
Regel gar nichts. In der Regel wollen wir jeden Knoten einzeln
erwischen, z.B. weil wir ihn einbetten wollen in einen HTML
Tag. Genau das ist aber mit der Konstruktion oben nicht möglich,
weil wir alle Knoten en bloque haben, das heisst, auf einen
einzelnen Knoten können wir so nicht zugreifen.
Nehmen wir mal an, wie wollen uns nur
die kaesesorten anzeigen lassen. Das können wir mit diesem
Stylesheet tun.
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:apply-templates select="waren/nahrungsmittel/Milchprodukte/kaese/name"/>
</xsl:template>
<xsl:template match="name">
<xsl:value-of select="."/>hallo
</xsl:template>
</xsl:stylesheet>
Man beachte, dass XSL Dokumente selber
XML Dokumente sind und folglich deren Ansprüche an Wohlgeformtheit
entsprechen müssen. Das heisst, dass alle Tag einen schliessenden
Tag haben müssen, habe sie das nicht, muss der Tag mit
einem Slash am Ende besonders gekennzeichnet werden. Weiter
dürfen innerhalb von einer xsl:template-match-Definition
nicht weitere xsl:template match Definitionen stehen. Der
Aufruf eines Templates aus einem Template heraus erfolgt also
mit
<XSL:TEMPLATE MATCH="/">
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/kaese/name"/>
Wenn man sehen will, was dieses XSL Stylesheet
macht, ist es wieder unter dem Namen irgendein_name.xsl im
selben Ordner abzulegen, wo auch die Datei
nahrung.xml und die saxon.exe liegt. Der Aufruf ist dann wieder
wie oben. Man muss sich in dem Ordner befinden, wo die Dateien
liegen.
saxon nahrung.xml irgendein_name.xsl
Das Ergebnis sieht dann so aus.
C:\saxon2\test3>saxon nahrung.xml n_manche_zeigen1.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>
Goudahallo
Emmentalerhallo
C:\saxon2\test3>
Wir erhalten das, was wir wollen, und
wir haben auch Zugriff auf jeden einzelnen Knoten isoliert.
Wir sehen, dass das Template zweimal aufgerufen wurde, den
wir erhalten zweimal hallo, einmal für jeden Aufruf.
Die Knoten, die wir nicht sehen wollen, erscheinen nicht.
Wie haben wir das gemacht ? Zuerst haben wir wieder das Wurzelelement
aufgerufen. Im Gegensatz zum vorherigen Beispiel, haben wir
jetzt aber verhindert, dass alle Knoten angezeigt werden,
indem wir einen Knoten der letzten Hierarchiestufe aufrufen
und damit alle anderen Hierarchiestufen ausschalten. Ein Template
für den Knoten den wir tatsächlich sehen wollen
rufen wir auf mit
<XSL:APPLY-TEMPLATES SELECT="Pfad_zu_dem_Knoten_den_wir_sehen_wollen"/>
Dieses Templates müssen wir dann
anschliessend definieren, was im Beispiel oben ja auch tatsächlich
passiert. Es macht wahrscheinlich Sinn, anhand eines anderen
Beispiels sich die Zusammenhänge nochmals zu verdeutlichen.
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:apply-templates select="waren/nahrungsmittel/Milchprodukte"/>
</xsl:template>
<xsl:template match="Milchprodukte">
<xsl:value-of select="."/>Hallo
</xsl:template>
</xsl:stylesheet>
Bei diesem Beispiel sind wir durchmaschiert
bis auf die Hierarchiestufe Milchprodukte, das heisst, die
Schwestern Knoten, die auf der selben Hierarchiestufe liegen,
wurden ausgeblendet. Allerdings gibt es nur einen Knoten Milchprodukte
(
<Milchprodukte>Inhalt</Milchprodukte>
). Folglich erscheint auch nur einmal
Hallo, da das Template nur einmal aufgerufen wird. Alle Knoten
unter Milchprodukte erscheinen en bloque.
Das Ergebnis sieht so aus:
C:\saxon2\test3>saxon nahrung.xml n_manche_zeigen1.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>
12
€
Holland
Gouda
23
€
Schweiz
Emmentaler
1.20
€
Italien
Bioghurt, Geschmack, Kaffe
Hallo
C:\saxon2\test3>
Zur Illustrierung noch ein letztes Beispiel,
das Zeigt, dass Knoten, die nicht definiert werden, gezeigt
werden:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/waren/nahrungsmittel/Milchprodukte/kaese">
hallo
</xsl:template>
</xsl:stylesheet>
Auch bei diesem Beispiel ist für
den Knoten waren/nahrungsmittel/Milchprodukte/kaese ein Template
definiert. Von der Sorte kaese gibt es zwei Knoten, folglich
sagt dieser Stylesheet zweimal hallo. Für alle anderen
Knoten allerdings ist kein Template definiert. Dies hat zur
Folge,dass sie aufgeblendet werden. Wenn man das nicht will,
müsste man ein Template für den Wurzelknoten definieren
und innerhalb dieses Templates dann obiges Templates aufrufen.
Mit der bis jetzt vorgestellten Syntax wäre es umständlich,
Knoten auf der selben Hierachiestufe zu erfassen. Wenn man
z.B. alle Namen der Milchprodukte sehen will, müsste
man bei diesem Ansatz zwei Templates definieren, eines für
den kaese und eines für den Yoghurt. Das kann man tun.
Es würde dann so aussehen.
<?XML VERSION="1.0" ENCODING="iso-8859-1"?>
<XSL:STYLESHEET VERSION="1.0" XMLNS:XSL="http://www.w3.org/1999/XSL/Transform">
<XSL:TEMPLATE MATCH="/">
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/kaese/name"/>
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/Milchprodukte/Yoghurt/name"/>
</XSL:TEMPLATE>
<XSL:TEMPLATE MATCH="name">
<XSL:VALUE-OF SELECT="."/>Hallo
</XSL:TEMPLATE>
</XSL:STYLESHEET>
Das Ergebnis sieht dann so aus:
C:\saxon2\test3>saxon
nahrung.xml n_manche_zeigen3.xsl
<?XML VERSION="1.0" ENCODING="utf-8"?>GoudaHallo
EmmentalerHallo
Bioghurt, Geschmack, KaffeHallo
Thüringer RostbratwurstHallo
alemanischer LeberkaesHallo
C:\saxon2\test3>
Wird das zugrunde liegende XML Dokument
komplexer, ist das kein gangbarer Weg mehr. Mit dieser Schreibweise
lassen sich Knoten auf der selben
Hierarchiestufe auf einen Schlag erfassen.
<?XML VERSION="1.0" ENCODING="iso-8859-1"?>
<XSL:STYLESHEET VERSION="1.0" XMLNS:XSL="http://www.w3.org/1999/XSL/Transform">
<XSL:TEMPLATE MATCH="/">
<XSL:APPLY-TEMPLATES SELECT="waren/nahrungsmittel/child::*/child::*/name"/>
</XSL:TEMPLATE>
<XSL:TEMPLATE MATCH="name">
<XSL:VALUE-OF SELECT="."/>Hallo
</XSL:TEMPLATE>
</XSL:STYLESHEET>
Mit dieser Syntax erfassen wir alle Schwesternknoten
(Knoten auf derselben Hierarchiestufe), die unterhalb von
nahrungsmittel liegen, also kaese und Wurst und
alle Schwesternknoten die wiederum unterhalb von kaese bzw.
Wurst liegen und von denen allen zusammen wiederum den Knoten
name. Weiter erfassen wir
jeden Knoten einzeln, das heisst es wäre ein Leichtes,
jeden Knoten in HTML Tags einzubinden.
HTML Tags über ein XSL Stylesheet generieren lassen
|
|
Für XSL interessiert man sich in
der Internetprogrammierung vor allem deshalb, weil man sich
mit XSL XML Dokumente in HTML Dokumente transformieren lassen.
Wir haben gesehen, dass das nur gelingt, wenn auf die Knoten,
die man in HTML Tags einbinden will, isoliert zugegriffen
werden kann. Im folgenden nun ein Beispiel,
das zeigt, wie eine XML Datei in eine HTML Datei transformiert
wird. Wer das Beispiel nachvollziehen will, sollte dieses
XML Dokument
in den Ordner legen, wo sich auch die Datei saxon.exe befindet.
<?xml version="1.0" encoding="iso-8859-1"
?>
<buecher>
<buch>
<title lagerbestand="500">Der Mann ohne Eigenschaften</title>
<autor>Robert Musil</autor>
<erscheinungsjahr>1922</erscheinungsjahr>
</buch>
<buch>
<autor>Thomas Mann</autor>
<erscheinungsjahr>1917</erscheinungsjahr>
<title lagerbestand="300">Der Zauberberg</title>
</buch>
<buch>
<title lagerbestand="400">Die Stadt und die
Hunde</title>
<autor>Mario Vargas Llosa</autor>
<erscheinungsjahr>1988</erscheinungsjahr>
</buch>
</buecher>
Mit diesem XSL Stylesheet können
wir diese Datei in ein HTML Dokument konvertieren.
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html><head><title>Test></title></head><body>
<xsl:apply-templates select="buecher/buch"/>
</body></html>
</xsl:template>
<xsl:template match="buch">
<table width="500">
<xsl:apply-templates select="title"/>
<xsl:apply-templates select="autor"/>
<xsl:apply-templates select="erscheinungsjahr"/>
</table>
</xsl:template>
<xsl:template match="title">
<tr><td bgcolor="yellow"><xsl:value-of
select="."/></td></tr>
</xsl:template>
<xsl:template match="autor">
<tr><td bgcolor="green"><xsl:value-of
select="."/></td></tr>
</xsl:template>
<xsl:template match="erscheinungsjahr">
<tr><td><xsl:value-of select="."/></td></tr>
<tr><td><hr/></td></tr>
</xsl:template>
</xsl:stylesheet>
Aus Gründen der Übersichtlichkeit
und damit wir diese transformierte Datei anschliessend auch
gleich im Browser betrachten können lassen wir sie
auf die Festplatte drucken. Um dies zu erreichen, müssen
wir die Art der Übergabe der XML Datei und der XSL Datei
an den saxon Interpreter etwas
modifizieren.
Der Aufruf sieht dann so aus.
C:\saxon\>saxon irgendeiname_fuer_die_XML_Datei.xml
irgendein_Name_fuer_die_XSL_Datei.xsl>name_der_transformierten_Datei.htm
Das Ergebnis dieser Transformation, oder
genauer, der HTML Quelltext der Datei name_der_transformierten_Datei.htm,
die sich im gleichen Ordner
eingerichtet wird, wie die Dateien, die sie generieren, sieht
dann so aus.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=utf-8">
<title>Test></title>
</head>
<body>
<table width="500">
<tr><td bgcolor="yellow">Der Mann ohne
Eigenschaften</td></tr>
<tr><td bgcolor="green">Robert Musil</td></tr>
<tr><td>1922</td></tr>
<tr><td><hr></td></tr>
</table>
<table width="500">
<tr><td bgcolor="yellow">Der Zauberberg</td></tr>
<tr><td bgcolor="green">Thomas Mann</td></tr>
<tr><td>1917</td></tr>
<tr><td><hr></td></tr>
</table>
<table width="500">
<tr><td bgcolor="yellow">Die Stadt und
die Hunde</td></tr>
<tr><td bgcolor="green">Mario Vargas
Llosa</td></tr>
<tr><td>1988</td></tr>
<tr><td><hr></td></tr>
</table>
</body>
</html>
Was im Browser so wiedergegeben wird:
zeigen.
Wie wir sehen, handelt es sich um ein perfektes HTML Dokument.
Der XSL Stylesheet ist schnell erklärt. Das erste Template,
das aufgerufen wird, definiert das Wurzelelement. Dieses wird
nur einmal ausgeführt. In diesem definieren wir die Bestandteile
der HTML Seite, die einmalig sind und das gesamte HTML Dokument
umklammern. Innerhalb der HTML Tags
<html><head><title>Test></title></head><body
und
</body></html>
rufen wir wieder ein Template auf, nämlich
das Template, dass die HTML Tags definiert, die jedes einzelne
Buch umklammern. Da wir wollen, dass jedes Buch innerhalb
eines tables erscheint schreiben wir
<table>
und
</table> .
Innerhalb dieser Tags rufen wir dann die
templates auf, die festlegen von welchen Tags die Werte titel,
autor, erscheinungsjahr umklammert werden. Das wars dann.
XML Dokumente direkt im Browser zeigen
|
|
Unser Ziel ist es, XML Dokumente über
ein XSL Stylesheet zu tranformieren und es direkt im Browser
aufzurufen. Wir wollen dies schluss endlich mit PHP realisieren.
Die eigentliche Transformation wird hierbei die ab PHP 4.2.2
mitgelieferte Sablotron Extension realisieren. Es gäbe
aber noch einen Weg, ein XML Dokument über ein XSL Stylesheet
zu tranformieren und es direkt im Browser anzeigen zu lassen.
Möglich wäre dies auch durch den XSL Interpreter
von Microsoft msxml, den man hier
downloaden kann. Man installiert ihn, indem man einen Doppelclick
auf die Datei macht und dann mit next, yes, ok, weiter alles
bestätigt. Um die transformierte HTML Datei dann im Browser
anzeigen zu lassen muss lediglich das XSL Stylesheet, das
die Transformation durchführt in die XML Datei eingebunden
werden.
Das sieht dann so aus.
<?xml version="1.0" encoding="iso-8859-1"
?>
<?xml-stylesheet href="direkt_in_Browser.xsl"
type="text/xsl"?>
<buecher>
<buch>
<title lagerbestand="500">Der Mann ohne Eigenschaften</title>
<autor>Robert Musil</autor>
<erscheinungsjahr>1922</erscheinungsjahr>
</buch>
<buch>
<autor>Thomas Mann</autor>
<erscheinungsjahr>1917</erscheinungsjahr>
<title lagerbestand="300">Der Zauberberg</title>
</buch>
<buch>
<title lagerbestand="400">Die Stadt und die
Hunde</title>
<autor>Mario Vargas Llosa</autor>
<erscheinungsjahr>1988</erscheinungsjahr>
</buch>
</buecher>
Nachdem wir den Mircrosoft XSL Parser
installiert haben und die XML Datei wie oben modifiziert haben,
also die Zeile
<?XML-STYLESHEET HREF="direkt_in_Browser.xsl"
TYPE="text/xsl"?>
hinzugefügt haben, müssen wir noch
noch beide Dateien also die XML Seite und das XSL Stylesheet
direkt_in_Browser.xsl in der document root des http Servers
ablegen. Anschliessend können wir die Datei über
http://127.0.0.1/name_der_xml_datei.xml aufrufen. Wir sehen
dann das gleiche Dokument sofort im Browser, dass wir oben
auf die Festplatte gedruckt haben.
Der ganze Umfang von XSL wurde hier natürlich nicht dargestellt.
Es sollte aber reichen, um das im Kapitel XML / XSL Sablotron
Beschriebene zu verstehen. Denn unser Thema ist, wie transformiert
man XML Dokumente mit PHP.
|
 |
