XML Tutorial/de
│
Deutsch (de) │
English (en) │
español (es) │
français (fr) │
magyar (hu) │
Bahasa Indonesia (id) │
italiano (it) │
日本語 (ja) │
한국어 (ko) │
português (pt) │
русский (ru) │
中文(中国大陆) (zh_CN) │
Einleitung
Die Extensible Markup Language ist eine von W3C empfohlene Sprache, die für den Informationsaustausch zwischen verschiedenen Systemen geschaffen wurde. Es ist eine textbasierte Möglichkeit, um Informationen zu speichern. Moderne Datenaustauschsprachen wie XHTML, ebenso wie die meisten WebServices Technologien, basieren auf XML.
Gegenwärtig gibt es eine Reihe von Units, die XML unter Free Pascal unterstützen. Diese Units sind "XMLRead", "XMLWrite" und "DOM" und sind ein Teil der Free Component Library (FCL) des Free Pascal Compilers. Die FCL ist bereits im Standard-Suchpfad für den Compiler in Lazarus. Daher müssen sie nur die Units zu ihrem uses Abschnitt hinzufügen, um die XML Unterstützung zu erhalten. Die FCL ist gegenwärtig (Oktober 2005) noch nicht dokumentiert. Daher hat dieses kurze Tutorial das Ziel, einen Einstieg in XML unter Verwendung dieser Units zu bieten.
Das XML DOM (Document Object Model) ist eine Reihe standardisierter Objekte, die eine ähnliche Schnittstelle für die Benutzung von XML für verschiedene Sprachen und Systeme bieten. Der Standard spezifiziert nur die Methoden, Eigenschaften und andere Schnittstellen Teile des Objekts. Die Implementierung in verschiedenen Sprachen ist frei gelassen. Die FCL unterstützt gegenwärtig vollständig das XML DOM 1.0.
Beispiele
Unten finden sie eine Liste von Beispielen zur XML-Datenmanipulation mit wachsender Komplexität.
Lesen eines Textknotens
Für Delphi Programmierer: Wenn sie mit TXMLDocument arbeiten, ist zu beachten, dass der Text innerhalb eines Knotens ein separater Textknoten ist. Deshalb müssen sie auf den Text eines Knotens als separaten Knoten zugreifen. Gehen sie zum Beispiel von folgender XML-Datei aus:
<xml>
<?xml version="1.0"?> <request> <request_type>PUT_FILE</request_type> <username>123</username> <password>abc</password> </request>
</xml>
Das folgende Code-Beispiel zeigt sowohl den richtigen als auch den falschen Weg, um den Wert eines Textknotens zu erhalten:
<delphi>
var PassNode: TDOMNode; Doc: TXMLDocument; begin // Einlesen der xml Datei ReadXMLFile(Doc, 'c:\xmlfiles\test.xml'); // Abrufen des "password" Knotens PassNode := Doc.DocumentElement.FindNode('password'); // Ausgeben des Wertes des gewählten Knotens WriteLn(PassNode.NodeValue); // wird leer sein // Der Text des Knotens ist ein separater Kindknoten WriteLn(PassNode.FirstChild.NodeValue); // gibt "abc" korrekt aus
</delphi>
Ausgeben der Knotennamen
Das folgende Beispiel zeigt, wie man die Knotennamen in einem Memo (platziert auf einem Formular) ausgibt.
Unterhalb sehen sie die XML-Datei namens 'C:\Programas\teste.xml':
<xml>
<?xml version="1.0"?> <images directory="mydir"> <imageNode URL="graphic.jpg" title=""> <Peca DestinoX="0" DestinoY="0">Pecacastelo.jpg1.swf</Peca> <Peca DestinoX="0" DestinoY="86">Pecacastelo.jpg2.swf</Peca> </imageNode> </images>
</xml>
Und hier der Pascal Code um die Aufgabe auszuführen:
<delphi>
var Documento: TXMLDocument; i, j: Integer; begin ReadXMLFile(Documento, 'C:\Programas\teste.xml'); Memo.Lines.Clear; with Documento.DocumentElement.ChildNodes do begin for i := 0 to (Count - 1) do begin Memo.Lines.Add(Item[i].NodeName + ' ' + Item[i].Attributes.Item[0].NodeValue); for j := 0 to (Item[i].ChildNodes.Count - 1) do begin Memo.Lines.Add(Item[i].ChildNodes.Item[j].NodeName + ' ' + Item[i].ChildNodes.Item[j].FirstChild.NodeValue); end; end; end; Documento.Free; end;
</delphi>
Dies führt zur Ausgabe von:
imageNode graphic.jpg Peca Pecacastelo.jpg1.swf Peca Pecacastelo.jpg1.swf
Füllen eines TreeView mit XML
Eine übliche Verwendung von XML Dateien ist, sie zu analysieren und ihren Inhalt in einem baumartigen Format anzuzeigen. Sie können die TTreeView-Komponente auf dem "Common Controls" Tab von Lazarus finden.
Die Funktion unten nimmt ein zuvor geladenes oder im Code erzeugtes XML-Dokument und füllt einen TreeView mit seinen Inhalten. Die Beschriftung von jedem Knoten ist der Inhalt des ersten Attributs eines jeden Knotens.
<delphi> procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument); var
iNode: TDOMNode;
procedure ProcessNode(Node: TDOMNode; TreeNode: TTreeNode); var cNode: TDOMNode; begin if Node = nil then Exit; // Aufhören, wenn ein Blatt erreicht ist // Einen Knoten zum Baum hinzufügen TreeNode := tree.Items.AddChild(TreeNode, Node.Attributes[0].NodeValue);
// Zum Kindknoten weiter gehen cNode := Node.ChildNodes.Item[0];
// Alle Kindknoten bearbeiten while cNode <> nil do begin ProcessNoDe(cNode, TreeNode); cNode := cNode.NextSibling; end; end;
begin
iNode := XMLDoc.DocumentElement.ChildNodes.Item[0]; while iNode <> nil do begin ProcessNode(iNode, nil); // Rekursiv iNode := iNode.NextSibling; end;
end; </delphi>
Modifizieren eines XML-Dokuments
Das wichtigste, das man sich merken muss ist, das TDOMDocument das "handle" für DOM ist. Eine Instanz dieser Klasse erhält man, indem man eine erzeugt oder indem man ein XML-Dokument lädt.
Dagegen können Knoten nicht wie normale Objekte erzeugt werden. Man muss die Methoden von TDOMDocument für die Erzeugung verwenden und sie danach mit anderen Methoden an die richtige Stelle zu bringen. Der Grund dafür ist, dass die Knoten einem speziellen Dokument auf DOM gehören müssen.
Nachfolgend sind einige gebräuchliche Methoden von TDOMDocument:
<delphi>
function CreateElement(const tagName: DOMString): TDOMElement; virtual; function CreateTextNode(const data: DOMString): TDOMText; function CreateCDATASection(const data: DOMString): TDOMCDATASection; virtual; function CreateAttribute(const name: DOMString): TDOMAttr; virtual;
</delphi>
Und jetzt eine Beispielsmethode, die das ausgewählte Element auf einem TTreeView lokalisiert und einen Kindknoten in das entsprechende XML-Dokument einfügt. Der TreeView muss vorher mit den Inhalten einer XML-Datei unter Verwendung der XML2Tree Funktion gefüllt werden.
<delphi> procedure TForm1.actAddChildNode(Sender: TObject); var
Posicao: Integer; NovoNo: TDomNode;
begin
{******************************************************************* * Ausgewähltes Element bestimmen *******************************************************************} if TreeView1.Selected = nil then Exit;
if TreeView1.Selected.Level = 0 then begin Posicao := TreeView1.Selected.Index;
NovoNo := XMLDoc.CreateElement('item'); TDOMElement(NovoNo).SetAttribute('nome', 'Item'); TDOMElement(NovoNo).SetAttribute('arquivo', 'Arquivo'); XMLDoc.DocumentElement.ChildNodes.Item[Posicao].AppendChild(NovoNo);
{******************************************************************* * Den TreeView updaten *******************************************************************} TreeView1.Items.Clear; XML2Tree(TreeView1, XMLDoc); end else if TreeView1.Selected.Level >= 1 then begin {******************************************************************* * Diese Funktion bearbeitet nur eine Ebene des Baumes, * kann aber leicht so geändert werden, dass eine beliebige Anzahl von Ebenen bearbeitet wird. *******************************************************************} end;
end; </delphi>
Erzeugen eines TXMLDocument aus einem String
Ist eine XML-Datei in MyXmlString gegeben, erzeugt der folgende Code ihre DOM:
<delphi> Var
S : TStringStream; XML : TXMLDocument;
begin
S:= TStringStream.Create(MyXMLString); Try S.Position:=0; XML:=Nil; ReadXMLFile(XML,S); // Komplettes XML-Dokument // Alternativ: ReadXMLFragment(AParentNode,S); // Nur das XML-Fragment lesen. Finally S.Free; end;
end; </delphi>
Überprüfen der Gültigkeit der Struktur einer XML-Datei
Seit März 2007 besitzt der FCL XML-Parser die Fähigkeit ein XML-Dokument anhand einer DTD zu überprüfen. Dabei wird überprüft, ob die logische Struktur des Dokumentes mit vordefinierten Regeln aus einer Document Type Definition (DTD) übereinstimmt. Diese Technik wird auch bei Webseiten mit HMTL angewendet.
Hier ist ein kleines Beispiel einer XML-Datei mit interner DTD:
<xml>
<?xml version='1.0'?> <!DOCTYPE root [ <!ELEMENT root (child)+ > <!ELEMENT child (#PCDATA)> ]> <root> <child>This is a first child.</child> <child>And this is the second one.</child> </root>
</xml>
Diese DTD legt als 'root' als Wurzelelement fest. Dieses Wurzelelement muss mindestens ein Kindelement mit dem Namen 'child' besitzen. Diese 'child'-Elemente dürfen nur Buchstaben (PCHDATA = parsed character data, verarbeite Buchstaben-Daten) enthalten. Wenn der Parser irgendwelche Abweichungen gegenüber diesen Regeln feststellt, wird er diese melden.
Durch das Überprüfen der Dokumentstruktur ist das Laden der XML-Datei etwas komplizierter. In diesem Beispiel können wir auf die XML-Datei über ein TStream-Objekt zugreifen:
<delphi> procedure TMyObject.DOMFromStream(AStream: TStream); var
Parser: TDOMParser; Src: TXMLInputSource; TheDoc: TXMLDocument;
begin
// ein neues parser Objekt erstellen Parser := TDOMParser.Create; // die XML-Datei muss über ein TXMLInputSource-Objekt geladen werden Src := TXMLInputSource.Create(AStream); // wir wollen eine Überprüfung der Dokumentstruktur Parser.Options.Validate := True; // Festlegen einer Methode, die bei Fehlern aufgerufen wird Parser.OnError := @ErrorHandler; // nun beginnen wir die Überprüfung Parser.Parse(Src, TheDoc); // ... und räumen hinterher wieder auf Src.Free; Parser.Free;
end;
procedure TMyObject.ErrorHandler(E: EXMLReadError); begin
if E.Severity = esError then // wir sind nur in Fehlern bezüglich der Verletzung der DTD interessiert writeln(E.Message); // an dieser Stelle können wir auch alles andere machen, dass bei einem Fehler getan werden soll
end; </delphi>
Encoding
Nach den XML-Standards darf in der ersten Zeile ein Encoding-Attribut auftauchen. Dieses Attribut ist aber nicht vorgeschrieben. In Lazarus Version 0.9.26 hat TXMLDocument eine Eigenschaft Encoding, die aber momentan ignoriert wird. writeXMLFile benutzt immer UTF-8 und erzeugt kein Encoding-Attribut in der ersten Zeile der XML-Datei.
Externe Links
- W3Schools XML-Tutorial