Suchen
Inside Wiki
Nützliche Links




 
phpforum.de bei Facebook
 
phpforum.de bei Twitter
 

Zurück   PHP Forum: phpforum.de > phpforum.de Wiki > phpforum.de Wiki

PHP Wiki Dieses Wiki sammelt Lösungen, zu Problemen, welche immer wieder im Forum auftauchen.

 
 
Artikel-Optionen Ansicht
  #1  

Standard XML

 

Tutorials - Inhalte

XML - Eine Einführung




Was ist XML?


(aus Wikipedia)

Die Extensible Markup Language (engl. für „erweiterbare Auszeichnungssprache“), abgekürzt XML, ist eine Auszeichnungssprache zur Darstellung hierarchisch strukturierter Daten in Form von Textdaten. XML wird u. a. für den Austausch von Daten zwischen Computersystemen eingesetzt, speziell über das Internet.

XHTML(extensible Hypertext Markup Language) basiert auf XML. Weitere bekannte XML-Sprachen sind RSS(Really Simple Syndication) oder SVG(Scalable Vector Graphics).
XML ist jedoch nicht auf diese Anwendungsgebiete beschränkt. Das westentliche Merkmal von XML ist, dass es erweiterbar(extensible) ist. Mit XML kann man alle möglichen Dinge beschreiben.

Durch das Anlegen von geeigneten DTD-Dateien kann diesen Tags auch eine bestimmte Funktion zugeordnet werden. Die DTD-Datei von XHTML 1.0 English z.B. findet man hier.
XML kann genauso wie HTML durch Stylesheets beeinflusst werden. Entweder durch Cascading Stylesheets (CSS) oder durch die Extensible Stylesheet Language (XSL oder XSLT).

Rein theoretisch kann man auf diese Weise also auch seine Homepage programmieren. Für PHP hat XML aber auch noch eine andere Bedeutung: Zum Speichern und gezielten Abrufen von Daten, wie es z.B. von MySQL bekannt ist. Wir werden in diesem Tutorial auf viele Aspekte von XML eingehen.

XML-Syntax



Wie oben erwähnt, XML ist wie HTML aufgebaut - mit kleinen Unterschieden. Hier einmal ein Beispeil:
HTML Quellcode:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
<stadt>
   <haus typ="Einfamilienhaus">
      <bewohner mitglied="Vater">Paul</bewohner>
      <bewohner mitglied="Mutter">Marie</bewohner>
      <bewohner mitglied="Kind">Tobias</bewohner>
   </haus>
</stadt>

Wie Sie sehen können sind Tags und Attribute frei gewählt. Widmen wir uns jedoch erst einmal der ersten Zeile. Das Haupttag für XML ist <?xml ?>. Das Attribut version beinhaltet die aktuelle XML-Version, im encoding wird die Zeichenkodierung festgelegt und standalone legt fest, ob eine DTD-Datei verwendet wird, in unserem Fall nicht.
Jedes XML-Dokument muss wohlgeformt sein. Also muss jedes Tag was geöffnet wurde in umgekehrter Reihenfolge auch wieder geschlossen werden. Es wird ein Basic-Tag benötigt: <stadt>. Dieses ist unser Basis-Tag. Dieses hat nun verschiedene Childs, oder auch Nodes, Kinderelemente, hier <haus>. Und diese können wiederrum weitere Nodes haben.

XSL



XSL ist die Stilsprache. Sie wird in eine XML-Datei folgendermaßen eingebunden:
HTML Quellcode:
<?xml-stylesheet type="text/xsl" href="stadt.xsl"?>

Man gibt zunächst den Typ an, hier text/xsl und den Pfad, in der die XSL-Datei zu finden ist. XSL wird mithilfe von XSLT (Extensble Style Language Transmission) in andere XML-basierende Ausgabe-Sprachen umgewandelt, wie z.B. XHTML.
Z.B. wird
HTML Quellcode:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="stadt.xsl"?>
<stadt>
   <haus typ="Einfamilienhaus">
      <bewohner1>Paul</bewohner1>
      <bewohner2>Marie</bewohner2>
      <bewohner3>Tobias</bewohner3>
   </haus>
</stadt>

durch XSLT zu
HTML Quellcode:
<ul>Haus</ul>
         <li>Paul</li>
         <li>Marie</li>
         <li>Tobias</li>
      </ul>


Um dies zu erreichen, wird folgender XSL-Code benötigt (stadt.xsl):
HTML Quellcode:
<?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>Stadt.xsl</title>
   </head>
   <body>
      <ul>
         <li><xsl:value-of select="stadt/haus"/></li>
         <ul>
            <li><xsl:value-of select="stadt/haus/bewohner1"/></li>
            <li><xsl:value-of select="stadt/haus/bewohner2"/></li>
            <li><xsl:value-of select="stadt/haus/bewohner3"/></li>
         </ul>
      </ul>
   </body>
</html>
</xsl:template>
</xsl:stylesheet>


Letztenendes kommt folgende Ausgabe im Browser:
  • haus
    • Paul
    • Marie
    • Tobias
Nun zur Erklärung:
Die erste Anweisung hat die Selbe Funktion wie im XML-Code. Die zweite Anweisung stellt zunächst die Version dar. Als zweites Attribut wird der Namensbereich (Namespace) für die speziellen XML-Tags gegeben. Diese werden dann in diversen Tags das ganze Dokument durch mit xsl: gekennzeichnet. Das ist dafür notwendig, damit es zu keinen Komplikationen kommt, die Tags eindeutig zu unterscheiden. Sie verweist auf die URL des XSLT-Standarts. Die Anweisung
HTML Quellcode:
<xsl:template match="/">

legt das Wurzelelement fest, also das Tag, von dem aus XSL das Auslesen beginnen soll. In diesem Fall ist es "/", die unterste Wurzel: <stadt>. Es können aber auch andere Wurzelelemente wie
HTML Quellcode:
<xsl:template match="stadt/haus">

festgelegt werden, wichtig ist, dass die Reihenfolge der Tags im Pfad der Hierachie im XML-Baum entspricht.
Sie müssen nun später nicht mehr über die lange Adresse auf das XML-Element zugreifen.
Die letzte zu klärende Anweisung lautet:
HTML Quellcode:
<xsl:value-of select="stadt/haus/bewohner1"/>

value-of bedeutet "Wert von", damit kann XSL aus XML den Wert des Tags auslesen, dass als Pfad abhängig vom xml:template match im select-Attribut angegeben wurde. Damit wären simple Grundstrukturen geklärt.
Für weitere Erläuterungen, z.B. über for..each, siehe: http://www.devmag.net/xml/xsl_1.htm.


XML und PHP



In den Augen eines PHP-Programmierers hat XML noch eine weitere Bedeutung, wie in Abschnitt 1 erklärt, nämlich zum Speichern von Daten.

Wieso XML?


Die Rolle von XML ist aus dem Web überhaupt nicht mehr wegzudenken. Spätestens in Web 2.0, was ja bekanntlich durch AJAX geprägt ist, muss einem bewusst werden, das die AJAX-Technologie selbst ja schon im Namen Asynchronous JavaScript and XML enthält.
In PHP gibt es 2 Speicherarten: temporär oder dauerhaft. Für temporären Speicher sind Variablen gut, sie finden auf dem flüchtigen Speicher von RAM auch ihren Platz. Zum Speichern von Daten, die dauerhaft zu Verfügung stehen sollen, hat PHP mehrere Möglichkeiten:
  • Speichern in .TXT oder .CSV - Files
  • Einsetzten von Datenbanken, z.B. MySQL
  • In den .PHP oder .HTML Files selbst
  • in XML
Wer Daten in Text-Files speichert, kennt das Problem: eine strukturierte Ausgabe ist nur schwer möglich, meistens stößt man in ein Wirrwarr von Funktionen und deren Konstrukte wie elegante explode()-Funktionen oder mit file(). Man kommt auf Array-Sortierungen usw. Der einzige Vorteil liegt nun darin, dass .TXT-Files sehr sparsam sind, im Gegensatz zu MySQL, was mit seiner eigenen Sprache, SQL, die wohl strukturierteste Ausgabe besitzt und für größere Datenmengen sehr geeignet ist, jedoch viel mehr Traffic und Ladezeit benötigt.
XML hat ein bisschen von beidem. Einerseits ist es eine Datei, und damit Ressourcen sparend, andererseits ist eine (relativ) gute und strukturierte Ausgabe über Objekte möglich. XML besitzt somit viele der Vorteile von MySQL und Files und ist dank der vielen PHP 5-Verbesserungen immer besser zu handhaben.

SimpleXML



XML-Tags auslesen


Um möglichst einfach PHP und XML zu verbinden, nutzen wir in PHP die simplexml-Technologie.
Zunächst kann PHP aus XML-Dateien auslesen. Das passiert mittels der Funktion simplexml_load_file(). Sie läd einen XML-Baum in PHP und gibt ein mehrschichtiges Objekt zurück. Diesen Objekt verkörpert gleichzeitig auch das Wurzel-Tag in XML, in unserem Fall <stadt>. Außerdem existieren in diesem Objekt Arrays, gefüllt mit Sub-Objekten, diese entsprechen den Tags im XML-Baum in der selben Hierachie. Mit dem '->'-Zeiger kann auf sie zugegriffen werden.
stadt.xml:
HTML Quellcode:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="stadt.xsl"?>
<stadt>
   <haus typ="Einfamilienhaus">
      <bewohner>Paul</bewohner>
      <bewohner>Marie</bewohner>
      <bewohner>Tobias</bewohner>
   </haus>
</stadt>

stadt.php:
PHP Quellcode:
<?php

   $file = 'stadt.xml';
   $xml_data = simplexml_load_file($file);   // XML-Datei laden
   echo $xml_data->haus[0]->bewohner[0];   // Auf den ersten Bewohner zugreifen

?>

Wir öffnen die XML-Datei "stadt.xml" per simplexml_load_file(). Die Funktion gibt ein Objekt zurück, welches wir in $xml_data speichern. Dieses Objekt hat mehrere Subobjekte. Diese stecken wiederrum in Arrays. Das wäre in unserem Falle haus[0]. Der Name des Arrays ist der Name des Tags, auf das wir zugreifen. Die Index-Zahl in den eckigen Klammern des Arrays gibt an, das wievielte Tag aus dem XML-Dokument angesprochen werden soll. Wie wir aus stadt.xml ableiten können, stehen innerhalb der <haus>-Tags noch weitere Tags, mit der Folge dass PHP weitere Subobjekte in Form von Arrays erzeugt. Wir nehmen also <bewohner> im Index 0. Die Ausgabe wäre logischerweise auch "Paul".
Um sich einen größeren Überblick über das $xml_data-Objekt zu verschaffen, ist es sinnvoll, es sich durch
PHP Quellcode:
echo '<pre>';
print_r($xml_data);
echo '</pre>';

ausgeben zu lassen. Sie sehen nun, die Daten werden strukturiert in XML gespeichert und können auch gezielt wieder ausgelesen werden. Um gleich alle Inhalte des XML-Dokumentes auslesen zu können, empfiehlt sich der Einsatz der for..each-Schleife:

PHP Quellcode:
$file = 'stadt.xml';
   $xml_data = simplexml_load_file($file);
   foreach($xml_data->haus[0]->bewohner as $value) {
      echo "$value<br />";
   }


Attribute auslesen


Wenn im XML-Baum auch Attribute im Tag vorkommen, wie z.B. mitglied="Vater", bietet sich eine weitere, simple Möglichkeit:

stadt.xml:
HTML Quellcode:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="stadt.xsl"?>
<stadt>
   <haus typ="Einfamilienhaus">
      <bewohner mitglied="Vater">Paul</bewohner>
      <bewohner mitglied="Mutter">Marie</bewohner>
      <bewohner mitglied="Kind">Tobias</bewohner>
   </haus>
</stadt>


stadt.php:
PHP Quellcode:
$file = 'stadt.xml';
   $xml_data = simplexml_load_file($file);
   foreach($xml_data->haus[0]->bewohner as $value) {
      echo $value . ' ist ein(e) ' . $value['mitglied'] . ' in der Familie<br />';
   }

Das Attribut erreichen wir kinderleicht, indem wir den Attribut-Namen als assoziativen Index für den Knoten einsetzten. Parallel könnte man auch schreiben, wenn man den "Status" von Paul wissen möchte:
PHP Quellcode:
echo $xml_data->haus[0]->bewohner[0]['mitglied'];

- Bequem durch ein 2dimensionales Array -

Knoten auslesen


XML wird oft benötigt, wenn man eine API oder RSS-Files auslesen will. Diese können sehr schnell sehr groß werden und es wird zu umständlich, diesen ganzen XML-Baum zu analysieren. Aber die simpleXML-Klasse stellt eine nützliche Methode vor: children().

PHP Quellcode:
$file = 'stadt.xml';
  $xml_data = simplexml_load_file($file);
  $knoten_wurzel_array = $xml_data->children();
  foreach($knoten_wurzel_array as $value_1) {
    $knoten_child_array = $value_1->children();
    foreach($knoten_child_array as $text_node => $text_value) {
      echo $text_node . ': ' . $text_value['mitglied'] . ' ist ' . $text_value . '<br />';
    }
  }

Wir speichern in $knoten_wurzel_array alle Children von $xml_data, dem Wurzelelement. Dieses hat in unserem Falle nur eins: <haus>. Von diesem ermitteln wir nun wiederrum die Children und speichern es in einer for..each-Schleife in $knoten_child_array. Dieses wird nun wiederrum mit for..each() ausgelesen, jeweils Key und Value. Der Key ist in jedem Falle "bewohner", also ihr Tag, der Value die Namen. Der Name kann als Array noch das Attribut auslesen. Die Ausgabe wäre dann:
Code:
bewohner: Vater ist Paul
bewohner: Mutter ist Marie
bewohner: Kind ist Tobias

Auf diese Weise kann man sich nun etwas einfacher durch den XML-Baum manövrieren.

XML mit PHP erzeugen


XML durch PHP speichern

Um Daten mit PHP dynamisch zu speichern, nutzten wir die Methode asXML(). Dies ist sehr praktisch für eine dynamische Speicherverwaltung. Hier eine kleine Anwendung:
index.html:
HTML Quellcode:
<html>
  <head>
    <title>Dynamische XML-Speicherung</title>
  </head>
  <body>
    <h1>Bitte geben Sie Ihren Vor- und Zunamen ein!</h1>
    <hr />
    <form method="post" action="asXML.php">
      <label for="vn">Vorname:</label> <input type="text" id="vn" name="vn" size="24" maxlength="24" />
      <br />
      <label for="zn">Zuname:</label> <input type="text" id="zn" name="zn" size="24" maxlength="24" />
      <input type="submit" value="In XML speichern" />
    </form>
  </body>
</html>


asXML.php
PHP Quellcode:
<?php

// Variablen kürzen und entschärfen...
$vn = htmlentities(addslashes($_POST['vn']));
$zn = htmlentities(addslashes($_POST['zn']));

// XML-String dynmaisch erzeugen
$data = '
<formular>
  <benutzer>
    <vorname>'
. $vn . '</vorname>
    <zuname>'
. $zn . '</zuname>
  </benutzer>
</formular>'
;

$xml_data = simplexml_load_string($data); // String mit dieser Funktion in XML umwandeln
$xml_data = $xml_data->asXML();

// In Datei schreiben
$fp = fopen('benutzer.xml', 'wb');
if($fp) {
  $wr = fputs($fp, $xml_data);
  if($wr) echo 'Ihre Daten wurden gespeichert, ' . $vn . ' ' . $zn . '!';
  else echo 'Fehler beim Speichern Ihrer Daten!';
}
else {
  echo 'Konnte Speichermedium nicht öffnen!';
}

fclose($fp);

?>


Wir kürzen zunächst die Variablen und entschärfen sie. Anschließend wird ein XML-Objekt durch simplexml_load_string() erzeugt und durch asXML() als XML definiert. Das <?xml ?>-Tag wird automatisch von PHP eingefügt.
Zu guter letzt erstellt PHP eine Datei und legt den XML-String in ihr ab.

XML-Files mit PHP erweitern

Um eine XML-Datei zu erweitern, wurde die addChild()-Methode eingeführt. Wir ändern asXML.php leicht ab: (Vorraussetzung: Es ist bereits XML in benutzer.xml!)
PHP Quellcode:
<?php

// Variablen kürzen und entschärfen...
$vn = htmlentities(addslashes($_POST['vn']));
$zn = htmlentities(addslashes($_POST['zn']));

// Altes XML laden und neue Nodes hinzufügen
$old_xml = simplexml_load_file('benutzer.xml');
$add_child = $old_xml->addChild('benutzer'); // Neues <benutzer>-Tag
$add_child->addChild('vorname', $vn); // Neues <vorname>-Tag
$add_child->addChild('zuname', $zn); // Neues <zuname>-Tag
$xml_data = $old_xml->asXML();

// In Datei schreiben
$fp = fopen('benutzer.xml', 'wb');
if($fp) {
  $wr = fputs($fp, $xml_data);
  if($wr) echo 'Ihre Daten wurden gespeichert, ' . $vn . ' ' . $zn . '!';
  else echo 'Fehler beim Speichern Ihrer Daten!';
}
else {
  echo 'Konnte Speichermedium nicht öffnen!';
}

fclose($fp);

?>

Wir laden die alte XML-Datei in ein Objekt, fügen ein neues <benutzer>-Tag ein, dazu die <vorname> und <nachname>-Tags in das neue <benutzer>-Tag. Dieses Objekt gibt uns ganz praktisch addChild() zurück. Wir brauchen es nicht mehr mit simplexml_load_string in ein Objekt umzuwandeln, das ist es ja bereits, wir wandeln es lediglich mit asXML() in XML um. Zu guter letzt überschreiben wir den alten Datei-Inhalt einfach.

Was XML nicht bietet


Wie sie sehen, ist XML ein ausgezeichneter Speicher zum strukturiertem Sichern von Daten und Abrufen. Man kann es bequem mit simpleXML handhaben. Dennoch ist MySQL in vieler Hinsicht überlegen: die SQL-Sprache besitzt viele, schöne Features wie COUNTS oder SELECT-Bedingungen, die simpleXML nicht bieten kann. Man könnte sie zwar rein theoretisch auch in einem eigenen Framework programmieren, das wäre aber umständlich, dann besser gleich MySQL. Außerdem ist keine Datensicherheit gewährleistet. Jeder kann auf die XML-Datei zugreifen, hat Einblick in den Baum. Für sensible Daten ist das ein Tabu und kommt nur MySQL in Frage.
Wieso denn dann noch XML? Naja, mal abgesehen von dem zusätzlichen Traffic, den MySQL zieht, ist XML sehr gut mit JavaScript und AJAX anpassbar. JavaScript ist selbstständig in der Lage - auch ohne PHP - XML-Dateien durch AJAX auszulesen. Würde man mit AJAX noch MySQL einbinden, wäre das größere Ladezeit.

Zusammenfassung


Dies war ein kurzer Überblick über die Hauptfunktionen von XML. Wir sind auf seine Bedeutung, seine Syntax, sind auf XSL/XSLT mit den Namespaces eingegangen, haben seine Vor- und Nachteile erläutert und haben es mit PHP bearbeiten können. Viele weitere Informationen mit sehr vielen Tutorials bietet Google. Viel Spaß mit XML!


Link-Liste


« Vorheriges Kapitel   Tutorials

Mitwirkende: Ad aCTa, Sebbl
Erstellt von Ad aCTa, 03.12.2008 am 22:01
Zuletzt bearbeitet von Ad aCTa, 05.12.2008 am 20:53
4 Kommentare , 17115 Betrachtungen

Dieser Text steht unter der GNU-Lizenz für freie Dokumentation


 

Lesezeichen

Artikel-Optionen
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.

Gehe zu

Alle Zeitangaben in WEZ +2. Es ist jetzt 18:59 Uhr.


Powered by vBulletin® Version 3.8.8 (Deutsch)
Copyright ©2000 - 2018, Jelsoft Enterprises Ltd.
Powered by NuWiki v1.3 RC1 Copyright ©2006-2007, NuHit, LLC