Die neue PHP-Version 5 (PHP5) enthält neben zahlreichen anderen Neuerungen auch die Erweiterung SimpleXML. Mit ihr kann XML auf erstaunlich einfache Art in ein PHP Objekt überführt und verarbeitet werden.

Bisher ist SimpleXML auf experimenteller Basis veröffentlicht worden, so dass sich bis zur Erscheinung der finalen Version von PHP 5 noch einiges verändern kann. Insbesondere Funktionsnamen und ähnliches könnten betroffen sein. SimpleXML muss nicht mehr mitinstalliert werden. In den neuen PHP5 Distributionen wird SimpleXML standardmäßig mitkonfiguriert.
 
Und simpel ist SimpleXML in der Tat. Ein einfaches XML Dokument, wie z.B. artikel.xml kann in wenigen Schritten mit SimpleXML verarbeitet werden.

artikel.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel>
<titel>Der Titel</titel>
<teaser>Der Teaser, eine kurze Beschreibung</teaser>
<inhalt>Der Artikelinhalt an sich</inhalt>
</artikel>
 
Um beispielsweise an den Inhalt des <teaser> Elementes zu gelangen, bedarf es nur weniger Zeilen Code:

simplexml_1.php:
 
<?php
 
if (file_exists('artikel.xml')) {
$xml = simplexml_load_file('artikel.xml');
 
echo $xml->teaser[0];
 
} else {
exit('Konnte Datei nicht laden.');
}
?>
 
Durch die simplexml_load_file() Funktion wird die XML Datei eingelesen und direkt in ein Objekt überführt. Auf die Elemente des Objektes kann jetzt wie auf normale Objekte zugegriffen werden. Die Ausgabe erfolgt über das $xml Objekt, welches nichts anderes als das Wurzelelement <artikel> darstellt.

Dabei erfolgt der Zugriff auf die Elemente jeweils über Arrays. Da in unserem Fall nur ein Element innerhalb des Wurzelelementes <artikel> als <teaser> Element verwendet wird, geschieht der Zugriff auf den Inhalt dieses Elementes mit dem Arrayindex 0. Wären zwei <teaser> Elemente verwendet, würde man über den Index 1 auf das zweite Element zugreifen.

Um zu verstehen, wie bei SimpleXML die Daten in Objekten gespeichert werden, kann man sich mit der var_dump() Funktion von PHP schlicht den gesamten Inhalt des Objektes ausgeben lassen. Man ändert den Code einfach wie folgt ab:

simplexml_1.php:

<?php
 
if (file_exists("artikel.xml")) {
$xml = simplexml_load_file("artikel.xml"');
 
var_dump($xml);
}
else {
exit("Konnte Datei nicht laden. ");
}
?>

Die Ausgabe nach Aufruf des Skriptes sieht wie folgt aus:

object(SimpleXMLElement)#1 (3)
{
["titel"]=> string(9) "Der Titel"
["teaser"]=> string(35) "Der Teaser, eine kurze Beschreibung"
["inhalt"]=> string(25) "Der Artikelinhalt an sich"
}
 
Darin erkennt man die gesamte Struktur des XML Dokumentes wieder. SimpleXML erkennt, dass das Dokument genau aus einem Element object(SimpleXMLElement)#1 besteht, welches drei object(SimpleXMLElement)#1 (3) untergeordnete Elemente beherbergt. Diese Elemente, ihr Datentyp und deren Inhalte werden dann in geschweiften Klammern angegeben.

Wenn man bedenkt, dass zum Parsen eines XML Dokumentes mit dem ereignisorientierten Parser Expat mindestens drei Funktionen definiert werden mussten, ist der hierzu notwendige Aufwand mit SimpleXML nicht vergleichbar.

Komplexere XML Dokumente und SimpleXML?
Auch komplexe XML Dokumente lassen sich mit SimpleXML rasch bearbeiten. Folgendes XML Dokument ist fast identisch mit dem Beispiel oben, es wurde jedoch mit Attributen und weiteren Elementen versehen.
 
artikel_2.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<content>
<artikel id="1">
<meta>
  <keywords>ein,netter,artikel</keywords>
  <description>ein,lustiger,artikel</description>
  </meta>
  <titel>Der Titel</titel>
  <teaser>Der Teaser, eine kurze Beschreibung</teaser>
  <inhalt>Der Artikelinhalt</inhalt>
  </artikel>
<artikel id="2">
<meta>
  <keywords>ein,zweiter,netter,artikel</keywords>
  <description>ein,zweiter,lustiger,artikel</description>
  </meta>
  <titel>Der zweite Titel</titel>
  <teaser>Der zweite Teaser, eine kurze Beschreibung</teaser>
  <inhalt>Der zweite Artikelinhalt</inhalt>
  </artikel>
  </content>
 
Da SimpleXML ausgesprochen modular aufgebaut ist und viele Schnittstellen zu weiteren PHP- beziehungsweise XML Technologien aufweist, können komplexe Untersuchungen von XML Dokumenten zum Beispiel über den in SimpleXML integrierten XPath Prozessor durchgeführt werden. Das heißt, man kann über die Pfadangaben in XPath auf die gesuchten Elemente zugreifen.

Dies soll im folgenden Beispiel geschehen – es soll lediglich der vom Besucher angefragte Artikel angezeigt werden. Der gewünschte Artikel wird durch die ID identifiziert, die im <artikel> Element als Attribut definiert ist. Diese ID wird über den URL an das PHP Programm übergeben.

simplexml2.php

<?php

$id = $_GET['id'];

if (file_exists("test.xml")) {

$xml = simplexml_load_file("test.xml");

$path ="/content/artikel[@id=".$id."]";

if (!$res = $xml->xpath($path)) {
echo "Artikel nicht vorhanden!";
}
else {
echo "<h1>".$res[0]->titel."</h1>";
echo "<p><b>".$res[0]->teaser."</b></p>";
echo "<p>".$res[0]->inhalt."</p>";
}
}
else {
exit("Konnte Datei nicht laden.");
}
?>
 
Auf den gewünschten Artikel wird über den XPath Pfad /content/artikel[@id=".$id."] zugegriffen. Die Anfrage wird über die xpath() Methode verarbeitet und das Ergebnis der Variable $res zurückgegeben. In diesem Array sind nun alle Elemente des gesuchten Artikel-Objektes gespeichert. Auf diese kann wie auf ein Objekt zugegriffen werden.

Das Ergebnis beim Aufruf mit id=1

Natürlich kann man ein solches Problem auch ohne XPath lösen, SimpleXML stellt die dazu notwendigen Funktionen zur Verfügung – doch bietet SimpleXML gerade durch die Schnittstelle zu XPath viele weitere Möglichkeiten für die dynamische Programmierung. SimpleXML sollte also nicht unterschätzt werden.

Weitere Informationen zu SimpleXML und PHP5.

Weiterführende Links:

1. Entities, oder einfach Abkürzungen

Innerhalb einer DTD kann sogenannte Entities definieren. Entity steht für "Eintrag". Ein Entity ist eine Art Abkürzung für z.B. ein häufig vorkommendes Zeichen, oder eine Zeichenkette. Wird diese Abkürzung dann in einem XML Dokument ersetzt, dann wird der Entity bei der Ausgabe durch den wirklichen Wert aus der DTD ersetzt.

Enities erstellen
Ein Entity ist schnell in einer DTD definiert.

<!ENTITY name "Thiemo Fetzer">

Hinter dem einleitenden <!ENTITY steht der Name des Entities, über welchen er später angesprochen wird. In den folgenden Anführungsstrichen steht dann der Wert, für den das Entity stehen soll.

Auf diese Entities muss in dem XML Dokument eindeutig verwiesen werden. So ist es durchaus möglich, das innerhalb des XML Dokumentes die Zeichenkette "name" vorkommt. Man muss eindeutig bezeichnen, das es sich bei "name" um einen Entity handelt.
Das geht in XML wie folgt:

&entity;
Oder fürs Beispiel
&name;

Der XML Parser kann so genau erkennen, das auf einen Enity verwiesen wird.
Die Namen der Enities müssen gewissen Regeln folgen. Sie müssen mit einem Buchstaben beginnen, sie dürfen nur aus Buchstaben (keine Sonderzeichen, oder deutsche Umlaute), und aus Unterstrichen bestehen.

Ein Beispiel

data.xml

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE data SYSTEM "data.dtd">

<user>
<name>Mein Name</name>
<nic>Nic</nic>
<signatur>&signatur;</signatur>
</user>

data.dtd

<!ELEMENT user (name, nic, signatur)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT nic (#PCDATA)>
<!ELEMENT signatur (#PCDATA)>
<!ENITY signatur "Keine Signatur">

Das Ergebnis im Browser


Ein Entity im Browser


Entities in DTDs

Auch das ist möglich, so können Sie Entities auch in einer DTD selbst verwenden.
Somit können Sie lange Attributlisten einmal definieren, und dann über Entities einfügen, und wiederverwenden.
Die Verwendung der Entities innerhalb der DTD sieht jedoch ein wenig anders aus.

Die Definition des Entities:

<!ENTITY % name "">

Verwendet wird das Entity jetzt innerhalb der DTD so:

%name;

Besonders einleuchtend ist die Verwendung von Entities innerhalb einer DTD, bei der Definition von Attributen.
Bei diesen müssen Sie viele mögliche Werte definieren. Mit Entities definieren Sie die Attribute einmal in einem Entity, und können diese dann beliebig oft wieder verwenden.

data.dtd

<!ELEMENT user (name, nic, signatur)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT telefon (#PCDATA)>
<!ENTITY % typen "art (privat|buero|mobil) #REQUIRED">
<!ATTLIST telefon %typen;>
<!ELEMENT nic (#PCDATA)>
<!ELEMENT email (#PCDATA)>
<!ATTLIST email %typen;>
<!ELEMENT signatur (#PCDATA)>
<!ENTITY signatur "Keine Signatur">

data.xml

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE data SYSTEM "data.dtd">

<user>
<name>Mein Name</name>
<telefon art="privat">123456</telefon>
<nic>Nic</nic>
<email art="buero">buero@irgendwo.de</email>
<signatur>&signatur;</signatur>
</user>

Die Attributliste wird als Entity %typen; definiert, mit dieser Zeile.
<!ENTITY % typen "art (privat|buero|mobil) #REQUIRED">

Wichtig ist, das Sie das Leerzeichen nach dem % nicht vergessen, sonst wird das ganze selbst als Entity betrachtet.

Das Entity selbst wird in der DTD darauf zwei mal verwendet. In der Definition der Attribute des Elementes telefon, und in der Attributsdefinition des Elementes email.

Sie können Entities auf diese weise noch viel komplexer verschachtelt, und auch weiter strukturiert verwenden. Entities sind eine Erleichterung für die Arbeit mit XML und DTDs.

Weiterführende Links:

1. SimpleXML PHP 5 und XML: Einfach einfach!!

Mit XML Schema kann man bis zu einem gewissen Grad, eigene Datentypen schaffen. Das bedeutet, dass man z.B. das Element "Postleitzahl" so definieren kann, das es nur aus maximal fünf Zahlen bestehen darf, damit das Dokument gültig ist. So kann man über XML Schema auf diese Weise sehr spezifisch festlegen, welche Daten, bzw. Datenmengen ein Element aufnehmen darf. Diese Bedingungen muss der bestimmte Wert einhalten, damit das Element, und somit das gesamte XML Dokument gültig ist.
Nehmen wir einmal nur ein kleines Beispiel. Sie haben innerhalb eines XML Dokumentes das Element <alter>. Der Wert dieses Elementes soll logischerweise mindestens 0 sein, aber maximal 120 (wobei das wohl schon hoch gegriffen ist).

Das XML Schema (nur für das Element "alter") sähe so aus:

<xs:element name="alter">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

Zunächst wird, wie wir es kennen das Element definiert, durch <xs:element>. Wie Sie im letzten Teil des Workshops gelernt haben, muss XML Schema jetzt davon ausgehen, das das Element "alter" ein komplexes Element ist. Da dies jedoch nicht der Fall ist, wird mit dem nächsten Befehl <xs:simpleType> angegeben, dass es sich um ein einfaches Element handelt. Nun wird es interessant. Jetzt kommt die Festlegung, bzw. die Eingrenzung des Wertebereichs, durch den Befehl <xs:restriction>.
Im wird eine Basis gegeben, in dem Fall ist es der Datentyp integer, also eine Ganzzahl. Von dieser Basis aus, wird das Element weiter eingegrenzt. Die folgenden Befehle definieren den Minimalwert, und den Maximalwert. Und schon ist das Element in seinem Wertebereich eingeschränkt worden.

Die Definition kann auch noch ein wenig abgeändert werden. So können Sie den Wertebereich einmal definieren, und dann auf verschiedene Elemente anwenden.
Im folgenden wird der Wertetyp "alter" definiert:
<xs:simpleType name="alter">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
Der Name des Typs wird über das name-Attribut definiert. Über diesen Namen kann man dann von der Definition eines Elementes auf den Datentyp verweisen.
Das folgende Beispiel definiert ein Element <dein_alter>. Über das Attribut type="" wird auf den Datentyp bzw. den Wertebereich verwiesen. Dieser wurde weiter oben definiert. Sie könnten jetzt mehrere Elemente mit diesem Wertebereich definieren.
<xs:element name="dein_alter" type="alter" />

Reguläre Ausdrücke verwenden

Bei der Definition von Wertebereichen können auch eine Form von Regulären Ausdrücken verwendet werden.
Die folgende XML Schema Typ-Definition begrenzt den Zeichenbereich des Elementes "name" auf das kleine ABC.

<xs:element name="name">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[a-z]" />
</xs:restriction>
</xs:simpleType>
</xs:element>

Sie können die Typ-Definition, wie oben beschrieben, auch wieder unabhängig vom Element definieren. Bei dieser Begrenzung wird als Basis der Datentyp "string", also Zeichenkette definiert.
Mit dem Befehl xs:pattern wird der Wertebereich in Form eines Regulären Ausdrucks definiert.
Mit dem oberen Regulären Ausdruck wird nur das kleine ABC aktzeptiert. Mit folgendem Regulären Ausdruck wird sowohl die Buchstaben aus dem Großen, als auch aus dem Kleinen ABC aktzeptiert:
<xs:pattern value="[a-zA-Z]" />

Mit dem nächsten Beispiel werden nur Zahlen von 0-9 als Wert angenommen.
<xs:pattern value="[0-9]" />

Dies bringt uns auf die Anwendung für unsere Postleitzahl. Hierbei wird das Element "<plz>" definiert:

<xs:element name="plz">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

<xs:pattern value="[0-9][0-9][0-9][0-9][0-9]" />
Es werden fünf Zeichen definiert. Diese dürfen nur Werte von 0-9 aufnehmen.
Das Beispiel der Postleitzahl kann auch durch diesen Regulären Ausdruck erreicht werden:
<xs:pattern value="[0-9]{5}" />
Wie bereits zuvor soll das Element aus fünf Zahlen, von 0-9 bestehen.

Wie Sie sehen lassen sich Reguläre Ausdrücke in XML Schema bei den "Bedingten Inhalten" sehr gut verwenden.

Maximale/ Minimale Länge bei Zeichenketten

Folgendes Beispiel definert ein Element "<pseudo>". Dieses soll eine Zeichenkette sein, die aus minimal fünf Zeichen, und maximal aus 10 Zeichen bestehen.

<xs:element name="pseudo">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:minLength value="5"/>
<xs:maxLength value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

Die Eingrenzung der Zeichenlänge wird, durch die Elemente <xs:minLength /> und <xs:maxLength /> erreicht.

Feste Werte definieren

Ähnlich wie bei der Definition von Attributen kann man auch mit XML Schema feste Werte für ein Element definieren.
In diesem Beispiel wird ein Element "<werbung>" definiert. Dieses Element ist nur gültig, wenn der Wert entweder "Banner, Newsletteranzeige oder Textanzeige" ist.

<xs:element name="werbung">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="Banner"/>
<xs:enumeration value="Newsletteranzeige"/>
<xs:enumeration value="Textanzeige"/>
</xs:restriction>
</xs:simpleType>
</xs:element>

Was mit DTDs nicht möglich war, wird mit XML Schema nun möglich. der Benutzer kann die Werte, die als gültig gelten sollen, sehr genau spezifizieren. So wird kann man also durch eine genau Anwendung von XML Schema verhindern, das falsche Daten aufgenommen werden.

Weiterführende Links:

1. Was ist XML Schema? – Einführung in XML Schema
2. XML Schema – Elemente und Attribute

Manchmal ist es notwendig, nur bestimmte Datenteile herauszufiltern Hierfür haben Sie bereits im ersten Teil des XSL Workshops die <xsl:for-each> Anweisung kennen gelernt. Diese kann man so erweitern, das man bestimmte XML Daten ausfiltern kann. Als erstes Beispiel wählen wir eine XML Buchdatenbank, in der der Titel eines Buches, der Name des Autors, und der Verlag gespeichert sind.

buch.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="buch.xsl"?>
<buch_db>
<buch>
<titel>Jetzt lerne ich - XML</titel>
<autor>Günter Born</autor>
<verlag>MUT</verlag>
</buch>
<buch>
<titel>Programmieren lernen</titel>
<autor>Ignatz Schelz</autor>
<verlag>MUT</verlag>
</buch>
<buch>
<titel>XML - Das Einsteigerseminar</titel>
<autor>Michael Seeboerger-Weichselbaum</autor>
<verlag>BHV</verlag>
</buch>
<buch>
<titel>SVG - Das Einsteigerseminar</titel>
<autor>Helma Spoona</autor>
<verlag>BHV</verlag>
</buch>
</buch_db>

Wie Sie in der XML Datei sehen, taucht der Name des Verlags öfters auf. Nun will ein Besucher z.B. nur die Bücher aus dem MUT Verlag sehen. Sie könnten einerseits ein eigenes XML Dokument für die Bücher des MUT Verlags anlegen, oder einfach die Daten herausfiltern.
Über das folgende XSL Stylesheet werden nur die Bücher angezeigt, die auch im MUT Verlag erschienen sind.

buch.xsl

<?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="buch_db">
<html>
<head>
<title>Buch.xsl</title>
</head>
<body>
<xsl:for-each select="buch[verlag='MUT']">
<xsl:value-of select="titel" /><br />
<xsl:value-of select="autor" /><br />
<xsl:value-of select="verlag" /><br /><br />
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Die Ausgabe im Browser (IE 6.0) sieht wie folgt aus:


Gefilterte Daten mit XSL

Der Schlüssel liegt wie schon gesagt in <xsl:for-each> Anweisung.

<xsl:for-each select="buch[verlag='MUT']">
</xsl:for-each>

Hier wird durch die Angabe im select="" Teil nur die Daten der Bücher ausgegeben, deren Verlag MUT ist. Dabei ist buch der Verweis auf das Element <buch>.

Der Filter kann auch anders gestaltet werden:

buch[verlag!='MUT']
Alle Bücher werden angezeigt, bei denen der Verlag nicht MUT ist.
Es stehen noch weitere sogenannte Wahrheitsoperatoren zur Verfügung.

Die XSL Wahrheitsoperatoren

Die Operatoren &lt; und &gt; lassen sich jedoch nur wirklich sinnvoll auf Ganzahlen anwenden.

Sortieren der Daten

Wir greifen das Beispiel von oben nochmals auf, und wollen jetzt die Bücher nach den Verlagen sortieren. Dabei sollen die Verlage nach dem ABC sortiert werden. Das kann mit dem XSL Befehl <xsl:sort />
Befehl erreicht werden.

Das XSL Stylesheet:

<?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="buch_db">
<html>
<head>
<title>Buch.xsl</title>
</head>
<body>
<xsl:for-each select="buch">
<xsl:sort select="verlag" order="ascending"/>
<xsl:value-of select="titel" /><br />
<xsl:value-of select="autor" /><br />
<xsl:value-of select="verlag" /><br /><br />
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Über den <xsl:sort /> Befehl werden die Inhalte nach dem Verlag sortiert. Über den order="" Befehl können Sie die Reihenfolge bestimmen.

Desweiteren kann dem Element die Attribute

Die Sortieranweisung kann mitunter sehr komplex sein. Hierzu wird in den nächsten Wochen ein eigener Artikel veröffentlicht.

Weiterführende Links:

1. XSL/ XSLT Workshop Teil 1
2. XSL/ XSLT Workshop Teil 2

Die Darstellung von XML mit CSS ist wahrscheinlich nicht zeitgemäß, da CSS auch gar nicht dafür gedacht ist. Auch die Darstellung von XML mit XSL ist für so manch einen Entwickler einfach zu Komplex. HTML hilft hier weiter.
So kann über einen XML Namensraum die HTML Definition, bzw. die XHTML Definition, da diese XML konform ist, in einem XML Dokument eingegliedert werden. Deshalb kann man XML mit XHTML kombinieren.

Ein Beispiel:

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/css" href="style.css"?>
<inhalt xmlns:html="http://www.w3.org/Profiles/XHTML-transitional">
<logo>
<html:img src="/images/logo.gif" width="200" height="100" />
</logo>
<beschreibung>
<html:p>Das devmag ist ein Onlinemagazin für alle Internetnutzer, die eine Homepage erstellen, verwalten und weiterentwickeln wollen!</html:p>
</beschreibung>
<todo>
<html:ul>
<html:li>Neues Webmasterlexikon</html:li>
<html:li>Ladezeitoptimierung</html:li>
<html:li>Redaktionssystem entwickeln, und integrieren</html:li>
</html:ul>
</todo>
<html:br />
<anregungen>
<html:bold>Weitere Anregungen?<html:br />
<html:a href="mailto:redaktion@devmag.net">
redaktion@devmag.net
</html:a>
</html:bold>
</anregungen>
</inhalt>

Sie sehen hier eigentlich ein totales Durcheinander, doch es ist sehr genau strukturiert, und gibt formatierte XML Daten aus. Es muss jedoch ein Stylesheet angegeben sein, auch wenn sich in diesem keine Definitionen befinden. Ansonsten wird die XML Datei nicht dargestellt, da diese nur als Datenbank gehandhabt wird.

Möchten Sie über das Stylesheet einzelne XHTML Elemente formatieren, dann müssen Sie das ebenfalls über den Namespace tun.
Sie möchten z.B. den P - Tag für einen Blocksatz in dem stylesheet formatieren, die Definition könnte so aussehen:

html\:p {
font-family: Arial;
font-size: 13px;
color: red;
font-weight: bold;
}

Wichtig ist das html\: vor dem jeweiligen Tag, oder der Klasse.

Sie müssen die CSS Anweisungen nicht in einem externen Stylesheet auslagern, die Definitionen können Sie ebenfalls innerhalb des XML Dokumentes machen.

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/css"?> <!-- Internes Stylesheet -->
<inhalt xmlns:html="http://www.w3.org/Profiles/XHTML-transitional">
<html:style>
html\:p {
font-family: Arial;
font-size: 13px;
color: red;
font-weight: bold;
}
</html:style>

Mit der Kombination von XML Daten und "alten" HTML, bzw. XHTML Elementen haben Sie eine weitere Möglichkeit kennen gelernt, XML im Browser darzustellen.
Diese Methode klappt normalerweise nur bei den aktuellsten Browsern, die über einen XML Parser verfügen.

Weiterführende Links:

1. HTML Kurs – Bilder mit dem img-Tag
2. HTML Code optimieren, andere Ansätze
3. HTML mit Zeit – HTML+Time

Weiterführende Links:

1. XSL/ XSLT Workshop Teil 2
2. XSL/ XSLT Workshop Teil 3

Weiterführende Links:

1. XSL/ XSLT Workshop Teil 1
2. XSL/ XSLT Workshop Teil 3

XML Schema unterscheidet in normalen XML Dokumenten zwischen zwei Arten von Elementen, einfache und komplexe. Ein komplexes Element hat mehrere untergeordnete Elemente, sie sind also mehrfach verschachtelt.

artikel_complex.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel>
<titel>Der Titel</titel>
<teaser>Der Teaser</teaser>
<inhalt>Der Inhalt</inhalt>
</artikel>

Zum Vergleich ein einfaches Element:

artikel_simple.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel>Der Artikel</artikel>

Nehmen wir als erstes Beispiel gleich mal das obige einfache Element "<artikel>". Das Schema für die Definition dieses Elementes sieht so aus:

artikel_simple.xsd

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="artikel" type="xs:string"/>
</xs:schema>

Wie Sie sehen wird das Schema, wird das Schema mit der Definition des Namespaces begonnen. Der Tag <xs:schema></xs:schema> umschließt das komplette Schema. Darauf folgt auch schon die Definition des Elementes "artikel".

<xs:element name="artikel" type="xs:string"/>

Über das Attribut name="" wird der name des Elementes angegeben, welches angesprochen wird. Das Attribut type="" definiert den Datentyp, in dem Fall ist es ein String, also eine Zeichenkette.

In dem XML Dokument muss nun auf das Schema verwiesen werden. Es geschieht wie bereits im ersten Teil beschrieben auf die selbe Art und Weiße. Wichtig ist nur, das die Adresse zu dem Schema über xsi:noNamespaceSchemaLocation="artikel_simple.xsd" korrekt angegeben wird.

artikel_simple.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="artikel_simple.xsd">
Der Artikel
</artikel>

Im Gegensatz dazu nun das Schema für das komplexe Element:

artikel_complex.xsd
<?xml version="1.0"encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="artikel">
    <xs:complexType>
       <xs:sequence>
         <xs:element name="titel" type="xs:string"/>
         <xs:element name="teaser" type="xs:string"/>
         <xs:element name="inhalt" type="xs:string"/>
       </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Eingeleitet wird das Element durch den fast gleichen Befehl <xs:element>. Im name="" Attribut steht der Name des Elementes.
Der nächste Befehl <xs:complexType> definiert, das es sich bei dem Element um ein komplexes Element handelt.

<xs:complexType>
</xs:complexType>

Die anderen Elemente werden als "einfache" Elemente definiert.
Diesen Elementen wird ein Datentyp angegeben, dieser gibt an, welche Daten in ihm gespeichert werden können. In unserem Beispiel sind es einfache Strings, also Zeichenketten. Der Datentyp lautet "xs:string".

<xs:sequence>
 <xs:element name="titel" type="xs:string"/>
 <xs:element name="teaser" type="xs:string"/>
 <xs:element name="inhalt" type="xs:string"/>
</xs:sequence>

Nun muss noch auf das Schema in dem XML Dokument verwiesen werden. Das funktioniert auf die gleiche Art, wie bei einfachen Elementen.

artikel_complex.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="artikel_complex.xsd">
<titel>Der Titel</titel>
<teaser>Der Teaser</teaser>
<inhalt>Der Inhalt</inhalt>
</artikel>

Attribute in XML Schema

In XML Schema wird angenommen, das alle Elemente mit Attributen komplexe Elemente sind. Einfache Elemente können also keine Attribute besitzen.
Ein Attribut wird wie ein einfaches Element definiert. Hierzu dient der XML Schema Befehl <xs:attribute />. Bei folgendem Schema wird dieses XML Dokument definiert:

artikel.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="artikel_schema.xsd" nr="202">
<titel>Der Titel</titel>
<teaser>Der Teaser</teaser>
<inhalt>Der Artikel selbst</inhalt>
</artikel>

Hinweis: In dem XML Dokument wird bereits auf das XML Schema verwiesen.

artikel_schema.xsd
<?xml version="1.0"encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="artikel">
    <xs:complexType>
       <xs:sequence>
         <xs:element name="titel" type="xs:string"/>
         <xs:element name="teaser" type="xs:string"/>
         <xs:element name="inhalt" type="xs:string"/>
       </xs:sequence>
      <xs:attribute name="nr" type="xs:integer"/>
    </xs:complexType>
  </xs:element>
</xs:schema>

Das Attribut wird, wie Sie sehen außerhalb des <xs:sequence> Befehls definiert, aber natürlich innerhalb des <xs:complexType> Elementes, da wie oben bereits erwähnt worden war, nur komplexe Elemente mit Attributen ausgestattet werden können. Attribute können natürlich auch alle Datentypen beinhalten wie normale Elemente.

Wie in DTDs können Sie auch in XML Schema den Attributen noch einige Eigenschaften geben.

<xs:attribute name="nr" type="xs:integer" default="0" />
Bei dieser Definition wird ein default Wert angegeben. Dieser wird verwendet, wenn das Element z.B. nicht gesetzt ist.

<xs:attribute name="nr" type="xs:integer" fixed="10" />
Bei dieser Definition des Attributes wird ein fester Wert angegeben. D.h. es kann kein anderer Wert angegeben werden.

<xs:attribute name="nr" type="xs:integer" use="optional" />
Dieses Attribut ist Optional, d.h. es muss nicht angegeben werden.

<xs:attribute name="nr" type="xs:integer" use="required" />
Dieses Attribut muss gesetzt werden, damit das Element, und das ganze Dokument gültig ist.

XML Schema hat die gleichen Möglichkeiten wie auch DTDs. XML Schema kann jedoch in vielen Dingen noch komplexer als DTDs sein. Es lohnt sich nur noch mit XML Schema zu arbeiten.

Weiterführende Links:

1. Was ist XML Schema? – Einführung in XML Schema
2. XML Schema – Datentypen bzw. Elementwerte

Mit XML können Sie eigene Tags erstellen. Diese Tags sind gültig, sofern die Syntax korrekt ist, und die einzelnen Elemente in einer DTD definiert sind.
Diese Elemente können Sie dann ohne Probleme mit CSS darstellen, da diese genauso veränderbar sind, wie normale HTML-Tags. Die Ausgabe von XML über CSS hängt jedoch stark vom verwendeten Browser ab. Nicht jeder Browser unterstützt die CSS Spezifikationen komplett. Dies führt bei älteren Browsern schnell zu falschen Ausgaben.

Ein Beispiel verdeutlicht die komplexe Verbindung von XML, DTDs und CSS.

adressen.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE adressen SYSTEM "adressen.dtd">
<?xml-stylesheet type="text/css" href="adressen.css" ?>

<adressen_db>

<adresse>
<anrede>Herr</anrede>
<name>Thiemo Fetzer</name>
<strasse>Bilharzstrasse 1</strasse>
<plz>89081</plz>
<ort>Ulm</ort>
</adresse>

<adresse>
<name>Uni Ulm</name>
<postfach>7561</postfach>
<plz>89077</plz>
<ort>Ulm</ort>
</adresse>

</adressen_db>

adressen.dtd:

<!ELEMENT adressen_db (adresse)*>

<!ELEMENT Adresse (anrede?, name, (postfach | strasse), plz, ort)>

<!ELEMENT anrede (#PCDATA)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT postfach (#PCDATA)>
<!ELEMENT strasse (#PCDATA)>
<!ELEMENT plz (#PCDATA)>
<!ELEMENT ort (#PCDATA)>

Das Stylesheet wird in das XML - Dokument mit der Befehlszeile
<?xml-stylesheet type="text/css" href="adressen.css" ?>
eingebunden. Das Stylesheet ist folglich in der selben Verzeichnisebene.

adressen.css:
Insgesamt gibt es acht Elemente, die mit CSS verändert werden. Die Adressen sollen im Ergebnis wie als Empfänger eines Briefes dargestellt werden. Das Ergebnis schon vorweg:


Mit Hilfe von CSS generiert


adressen.css

adressen_db {
position:absolute;
top: 20;
left: 40;
padding: 3;
border: 1 dotted black;
font-family: Arial;
font-size: 10pt;
}
adresse {
width: 150;
padding-top: 5;
padding-bottom: 5;
position: relative;
background-color: #F5F5F5;
display: block;
}
anrede {
display: block;
font-weight: bold;
}
name {
font-weight: bold;
display: block;
}
strasse {
display: block;
}
postfach {
display: block;
}

Die Definitionen des Stylesheets sind recht einfach, vorweg ist zu sagen, das es immer schwieriger ist, mit CSS das gleiche Ergebnis zu kriegen, als mit HTML.
Die Hauptdefinition des Styles liegt im ersten Teil, bei der Definition von adressen_db.
Alle Inhalte sind bedingt durch die Angaben in dieser Definition in einer Ebene. Durch padding: 3; hat der Inhalt 3 px Abstand zum Rand. Zudem wird der Rahmen, und die Schriftart und Größe definiert.

Die Definition des Elementes adresse ist nicht wesentlich komplexer. Der einzige wichtige Befehl der verwendet wird ist display:block; dieser Befehl gibt an, das der Inhalt als ein Block dargestellt werden soll. Damit soll erreicht werden, dass die einzelnen Datensätze getrennt sind.
Genauso wird mit den anderen Elementen verfahren. Sie werden als Block dargestellt, damit jeder Inhalt in einer neuen Zeile steht. Die Tags oder Elemente, welche nicht definiert werden, verändern sich nach den Definitionen im Wurzelelement, also adressen_db.

Die Darstellung von XML - Dokumenten mit CSS ist speziell für Anfänger im Bereich XML leicht zu verstehen, doch XML und CSS hat auch einige Nachteile.

Ältere Browser können mit der Verbindung aus CSS und XML noch nichts anfangen. Meist wird als Ergebnis nur ein unformatierter Text ausgegeben, und das war ja nicht der Sinn der Sache. Zudem ist die Unterstützung, speziell die des CSS 2 Standards noch nicht so weit ausgereift.
Der Schritt zu XSL lohnt sich auf jeden Fall, da die strukturierte Ausgabe von Daten zur Zeit von CSS (noch) nicht unterstützt wird.

Weiterführende Links:

1. Komplexe DTD’s
2. Entities, oder einfach Abkürzungen

XML ist aus dem SGML (Standard Generalized Markup Language) entstanden. Diese wurde bereits in den 80igern von IBM zum größten Teil entwickelt. SGML gilt als Muttersprache aller Markup Sprachen, so auch von XML. HTML ist eine winzige Definition, die aus dem SGML Standard entsprungen ist. Die Befehlswelt von HTML ist beschränkt. Es gibt lediglich eine begrenzte Anzahl von formatierenden Befehlen.

XML hat eine komplett andere Datenstruktur. In XML gibt es beschreibende Befehle. Die Befehle dienen primär der Datenspeicherung und Datenbeschreibung.
Die Formatierung des Inhaltes wird von Stylesheets und anderen Formatierungssprachen wie XSL und XSLT bestimmt.
Ab dem Internet Explorer 5 ist XML integriert. Doch erst mit der Version 6 wurden alle Standards implementiert.
Um ein XML-Dokument zu erstellen benötigt man nur einen Texteditior, wie Notepad. Das erste XML-Dokument, welches wir erstellen wollen sieht so aus:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<artikel>
<titel>Der Titel</titel>
<teaser>Der Teaser, eine kurze Beschreibung</teaser>
<inhalt>Der Artikelinhalt an sich</inhalt>
</artikel>

Der Code und die Schreibweise hat kaum Unterschiede zu HTML, auf den ersten Blick. In der ersten Zeile des Codes wird die XML Version spezifiziert, also die XML Version mit welcher der Inhalt behandelt oder geparsed werden soll. Zudem ist das Attribut encoding gesetzt. Es gibt den Zeichensatz mit welchem das Dokument behandelt werden soll.

Weitere Zeichensätze:

encoding="UTF-8"
internationaler Zeichensatz mit 8 Bit Zeichenbreite

encoding="UTF-16"
internationaler Zeichensatz mit 16 Bit Zeichenbreite

encoding="ISO-8859-1"
ISO-Zeichensatz für westeuropäische Sprachen

Wie an der Struktur des Dokumentes erkennbar wird, ist eine feste Baumstruktur vorhanden. Sie beschreibt die Verschachtelung der einzelnen Befehle. Das sogenannte Wurzelelement ist <artikel> </artikel>. Es ist das erste Element, welches den kompletten Datensatz umringt. Diesem Wurzelelement sind weitere drei Elemente untergeordnet.
Speichern Sie dieses Dokument einfach einmal als versuch.xml ab, und schauen Sie sich das ganze mal mit dem InternetExplorer an. Das Ergebnis wird ernüchternd sein.


Die Ausgabe von versuch.xml

In gewisser Hinsicht können Sie sich jedoch freuen, da das XML Dokument wohlgeformt ist, und das auf den ersten Versuch.

Doch was bedeutet eigentlich, das Dokument ist "wohlgeformt"?

Dies hängt von der korrekten Syntax ab. Hierbei müssen folgende Regeln beachtet werden.

1. XML Deklaration

Die Deklaration des XML Standards am Anfang des Dokumentes ist unabdingbar.
Sie muss immer vorhanden sein.

2. Wurzelelemet

Für ein wohlgeformtes Dokument muss auf jeden Fall ein Wurzelelement, wie in unserem Beispiel "<artikel> </artikel>" vorhanden sein. Dieses umschließt alle untergeordneten Elemente.

3. Richtige Schreibweise

Ein Tippfehler ist schnell geschehen, und wird von XML hart bestraft. Achten Sie darauf, das das öffnende Element genauso geschrieben wird wie das schließende.

4. Attributwerte

Im Gegensatz zu HTML müssen Attribute in "" stehen. Ein Beispiel:

<artikel id=2> <!-- Ungültig -->

<artikel id="2"> <!-- Gültig -->

5. Leere Elemente

Es gibt Tags die kein schließenden Tag besitzen, wie z.B. den <hr> Tag. XML verlangt jedoch immer ein schließenden Tag. Um dies zu erreichen wird von das Ende des jeweiligen Tag ein / gesetzt.

Beispiel:
<linie> <!-- Ungültig -->

<linie /> <!-- Gültig -->

6. Elementnamen

Mit XML kann man frei eigene Tags erstellen, jedoch müssen diese Elementnamen einige Regeln befolgen.
Sie dürfen nicht mit der Zeichenkette XML beginnen, nicht komplett aus Ziffern bestehen, oder mit Ziffern beginnen, und keine Leerzeichen enthalten.
Einige Beispiele:

<xml-artikel> <!-- Ungültig -->

<artikel-xml> <!-- Gültig -->

<123artikel> <!-- Ungültig -->

<artikel123> <!-- Gültig -->

<artikel 12> <!-- Ungültig -->

<artikel-12> <!-- Gültig -->

7. Groß und Kleinschreibung

Besonders wichtig ist, das XML einen Unterschied zwischen Groß und Kleinschreibung macht.
<Teaser> ist nicht gleich </teaser>. Es sind zwei völlig unterschiedliche Elemente.

8. Kommentare

Sie können wie in HTML Kommentare verwenden, und so die XML Dokumete und DTDs leichter verständlich machen. Ein Kommentar beginnt mit <!-- und endet mit -->. Alles was innerhalb der Kommentare steht wird nicht interpretiert.


Doch trotz all dieser Regeln ist ein Dokument noch nicht gültig. Die Gültigkeit besagt, das die verwendeten Elemente definiert sein müssen. XML bzw. der Parser muss "wissen" was für Elemente verwendet werden, und welchen Inhalt bzw. welche Attribute diese Elemente haben können.
Diese Angaben werden in der DTD (Document Type Definition) gemacht.

Es gibt zwei Typen von DTDs. Eine interne DTD steht im selben XML Dokument, und wird auch nur auf dieses angewendet. Diese Art der DTD wird vor allem bei kleinen Dokumenten verwendet. Sollen jedoch viele Dokumente mit einer DTD bearbeitet werden, dann ist eine Auslagerung der DTD empfehlenswert.
Zunächst wollen wir eine kleine interne DTD erstellen.

Wir greifen wieder auf unser erstes Beispiel zurück, dieses mal jedoch mit der DTD:

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE artikel [
<!ELEMENT artikel (titel, teaser, inhalt)>
<!ELEMENT titel (#PCDATA)>
<!ELEMENT teaser (#PCDATA)>
<!ELEMENT inhalt (#PCDATA)>
]>

<artikel>
<titel>Der Titel</titel>
<teaser>Der Teaser, eine kurze Beschreibung</teaser>
<inhalt>Der Artikelinhalt an sich</inhalt>
</artikel>

Wenn Sie diesen Code so ansehen entdecken Sie die DTD bestimmt sehr schnell.
Die gesamte DTD wird von <!DOCTYPE artikel [ ]> umschlossen. In ihr wird der Name der DTD bestimmt, in diesem Fall ist es artikel. Als erstes Element muss immer das Wurzelelement definiert werden. Ein Element wird mit <!ELEMENT > definiert.
Die Definition erfolgt einem festen Schema:

<!ELEMENT Name (Inhalt)>

Nach ihr kommt der Name des Elementes und ihm untergeordnete Elemente.
Die Definition des Wurzelelementes artikel ist in dieser Zeile der DTD:

<!ELEMENT artikel (titel, teaser, inhalt)>

Der Inhalt des Wurzelelemetes besteht (nur) aus weiteren Elementen, diese werden in der Klammer, jeweils mit einem Komma getrennt, angegeben.

Die einzelnen Unterelmente werden so definiert:

<!ELEMENT titel (#PCDATA)>

Das #PCDATA gibt an, das der Inhalt des Elementes jeder beliebige Text oder Code sein kann, er darf jedoch keine weiteren Unterelemente enthalten. Das Element titel hat keine untergeordneten Elemente.

<titel><fett>Der Titel</fett></titel>

Ist ungültig, da dem Element Titel nicht das Element <fett> untergeordnet wurde.
Doch auch von diesem Ergebnis werden Sie enttäuscht sein, da es immer noch keinen formatierten Artikel darstellt. Das System ist jetzt jedoch soweit, das eine komplett gültiges und wohlgeformtes XML Dokument vorhanden ist.

Die formatierende Ausgabe kann nun in Angriff genommen werden!

No related posts.