XML Tutorial/it
│
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) │
Introduzione
L'Extensible Markup Language è un linguaggio raccomandato dal W3C creato per l'interscambio di informazioni tra sistemi differenti. Si tratta di un sistema di memorizzazione di informazioni basato su file di testo. Linguaggi moderni di interscambio di dati come XHTML, così come la maggior parte delle tecnologie WebService, sono basati su XML.
Al momento esistono una serie di unit che forniscono supporto per XML su Free Pascal. Queste unit sono chiamate "XMLRead", "XMLWrite" e "DOM" e sono parte della Free Component Library (FCL) del Free Pascal Compiler. La FCL si trova già nei percorsi di ricerca di default per il compilatore in Lazarus, così bisogna soltanto aggiungere queste unit alla clausola uses per avere il supporto di XML. La FCL al momento (Ottobre / 2005) non è documentata, quindi questo breve tutorial introdurrà XML tramite l'utilizzo di queste unit.
XML DOM (Document Object Model) sono una serie di oggetti standardizzati che forniscono un'interfaccia simile per l'utilizzo di XML con differenti linguaggi e su differenti sistemi. Lo standard specifica soltanto i metodi, le proprietà e altre parti dell'interfaccia dell'oggetto, lasciando l'implementazione libera per i diversi linguaggi. La FCL al momento offre pieno supporto per XML DOM 1.0.
Esempi
Di seguito c'è una lista di esempi di manipolazione dati tramite XML di complessità crescente.
Leggere un nodo di testo
Per Programmatori Delphi: Notare che quando si lavora con TXMLDocument, il testo all'interno di un Node viene considerato come un TEXT Node separato. Quindi si deve accedere al valore del testo del nodo come se si trattasse di un nodo separato. In alternativa, è possibile utilizzare la proprietà TextContent per ottenere il contenuto di tutti i nodi di testo al di sotto del nodo specificato, concatenati assieme.
La procedure ReadXMLFile crea sempre un nuovo TXMLDocument, quindi non c'è bisogno di crearlo prima. In ogni caso, assicuratevi di distruggere il documento tramite una chiamata a Free quando avete terminato.
Per esempio, consideriamo il seguente XML:
<xml>
<?xml version="1.0"?> <request> <request_type>PUT_FILE</request_type> <username>123</username> <password>abc</password> </request>
</xml>
Il seguente codice di esempio mostra sia il modo corretto che quello non corretto di ottenere il valore del testo del nodo:
<delphi>
var PassNode: TDOMNode; Doc: TXMLDocument; begin // Read in xml file from disk ReadXMLFile(Doc, 'c:\xmlfiles\test.xml'); // Retrieve the "password" node PassNode := Doc.DocumentElement.FindNode('password'); // Write out value of the selected node WriteLn(PassNode.NodeValue); // will be blank // The text of the node is actually a separate child node WriteLn(PassNode.FirstChild.NodeValue); // correctly prints "abc" // alternatively WriteLn(PassNode.TextContent); // finally, free the document Doc.Free;
end; </delphi>
Stampare i nomi dei nodi
Una nota veloce sulla navigazione di un albero DOM: quando c'è bisogno di accedere i nodi in sequenza, è preferibile utilizzare le proprietà FirstChild e NextSibling (per scorrerlo in avanti), o LastChild e PreviousSibling (per scorrerlo indietro). Per un accesso random è possibile utilizzare i metodi ChildNodes o GetElementsByTagName, ma questi creeranno un oggetto TDOMNodeList che alla fine deve essere rilasciato. Questo comportamento differisce da altre implementazioni di DOM come MSXML, perché l'implementazione di FCL è basata sugli oggetti, non sulle interfacce.
Il seguente esempio mostra come stampare i nomi dei nodi in un TMemo posizionato su un form.
Qui sotto c'è il file XML chiamato '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>
E qui il codice Pascal per eseguire il compito:
<delphi>
var Documento: TXMLDocument; Child: TDOMNode; j: Integer; begin ReadXMLFile(Documento, 'C:\Programas\teste.xml'); Memo.Lines.Clear; // using FirstChild and NextSibling properties Child := Documento.DocumentElement.FirstChild; while Assigned(Child) do begin Memo.Lines.Add(Child.NodeName + ' ' + Child.Attributes.Item[0].NodeValue); // using ChildNodes method with Child.ChildNodes do try for j := 0 to (Count - 1) do Memo.Lines.Add(Item[j].NodeName + ' ' + Item[j].FirstChild.NodeValue); finally Free; end; Child := Child.NextSibling; end; Documento.Free; end;
</delphi>
Questo stamperà:
imageNode graphic.jpg Peca Pecacastelo.jpg1.swf Peca Pecacastelo.jpg1.swf
Popolare un TreeView tramite XML
Un utilizzo comune dei files XML è quello di eseguire un parsing su di essi e mostrare il loro contenuto in una struttura ad albero. E' possibile trovare il componente TTreeView nella linguetta "Common Controls" in Lazarus.
La funzione qui in basso prenderà un documento XML precedentemente caricato da file o generato via codice e popolerà un TreeView con il suo contenuto. La caption di ogni nodo sarà il contenuto del primo attributo di ogni nodo.
<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; // Stops if reached a leaf // Adds a node to the tree TreeNode := tree.Items.AddChild(TreeNode, Node.Attributes[0].NodeValue);
// Goes to the child node cNode := Node.FirstChild;
// Processes all child nodes while cNode <> nil do begin ProcessNode(cNode, TreeNode); cNode := cNode.NextSibling; end; end;
begin
iNode := XMLDoc.DocumentElement.FirstChild; while iNode <> nil do begin ProcessNode(iNode, nil); // Recursive iNode := iNode.NextSibling; end;
end; </delphi>
Modificare un documento XML
La prima cosa da ricordare è che TDOMDocument rappresenta l'"handle" al DOM. E' possibile ottenere una istanza di questa classe creandone una o caricando un documento XML.
D'altro canto i nodi non possono essere creati come normali oggetti. Per crearli si *devono* utilizzare i metodi forniti da TDOMDocument, quindi utilizzare altri metodi per posizionarli nella posizione corretta nell'albero. Questo accade perché in DOM i nodi devono "appartenere" ad un documento specifico.
Qui di seguito sono riportati alcuni metodi comuni di 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>
E qui un metodo di esempio che localizza l'elemento selezionato in un TTreeView e inserisce un nodo figlio nel documento XML che rappresenta. Il TreeView deve essere preventivamente riempito con il contenuto di un file XML utilizzando la funzione XML2Tree.
<delphi> procedure TForm1.actAddChildNode(Sender: TObject); var
position: Integer; NovoNo: TDomNode;
begin
{******************************************************************* * Detects the selected element *******************************************************************} if TreeView1.Selected = nil then Exit;
if TreeView1.Selected.Level = 0 then begin position := TreeView1.Selected.Index;
NovoNo := XMLDoc.CreateElement('item'); TDOMElement(NovoNo).SetAttribute('nome', 'Item'); TDOMElement(NovoNo).SetAttribute('arquivo', 'Arquivo'); with XMLDoc.DocumentElement.ChildNodes do begin Item[position].AppendChild(NovoNo); Free; end;
{******************************************************************* * Updates the TreeView *******************************************************************} TreeView1.Items.Clear; XML2Tree(TreeView1, XMLDoc); end else if TreeView1.Selected.Level >= 1 then begin {******************************************************************* * This function only works on the first level of the tree, * but can easely modifyed to work for any number of levels *******************************************************************} end;
end; </delphi>
Creare un TXMLDocument da una stringa
Dato un file XML in MyXmlString, il seguente codice creerà il corrispondente DOM:
<delphi> Var
S : TStringStream; XML : TXMLDocument;
begin
S:= TStringStream.Create(MyXMLString); Try S.Position:=0; XML:=Nil; ReadXMLFile(XML,S); // Complete XML document // Alternatively: ReadXMLFragment(AParentNode,S); // Read only XML fragment. Finally S.Free; end;
end; </delphi>
Validare un documento
A partire da Marzo 2007, al parser XML della FCL è stata aggiunta la capacità di validare i DTD. La validazione consiste nel controllare che la struttura logica del documento sia conforme a regole prestabilite, chiamate Document Type Definition (DTD).
Ecco un esempio di un documento XML con un 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>
Questo DTD specifica che l'elemento 'root' deve avere uno o più elementi 'child', e che gli elementi 'child' possono avere al loro interno soltanto caratteri. Se il parser individua una violazione di queste regole, le riporterà.
Caricare un documento di questo tipo è leggermente più complicato. Assumiamo di avere dei dati XML in un oggetto TStream:
<delphi> procedure TMyObject.DOMFromStream(AStream: TStream); var
Parser: TDOMParser; Src: TXMLInputSource; TheDoc: TXMLDocument;
begin
// create a parser object Parser := TDOMParser.Create; // and the input source Src := TXMLInputSource.Create(AStream); // we want validation Parser.Options.Validate := True; // assign a error handler which will receive notifications Parser.OnError := @ErrorHandler; // now do the job Parser.Parse(Src, TheDoc); // ...and cleanup Src.Free; Parser.Free;
end;
procedure TMyObject.ErrorHandler(E: EXMLReadError); begin
if E.Severity = esError then // we are interested in validation errors only writeln(E.Message);
end; </delphi>
Generare un file XML
Di seguito c'è il codice completo per scrivere su un file XML. (E' stato preso da un tutorial sul blog DeveLazarus) Ricordate di aggiungere le librerie DOM e XMLWrite sotto la clausola uses
<delphi> unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls, DOM, XMLWrite;
type
{ TForm1 } TForm1 = class(TForm) Button1: TButton; Label1: TLabel; Label2: TLabel; procedure Button1Click(Sender: TObject); private { private declarations } public { public declarations } end;
var
Form1: TForm1;
implementation
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject); var
xdoc: TXMLDocument; // variable to document RootNode, parentNode, nofilho: TDOMNode; // variable to nodes
begin
//create a document xdoc := TXMLDocument.create;
//create a root node RootNode := xdoc.CreateElement('register'); Xdoc.Appendchild(RootNode); // save root node
//create a parent node RootNode:= xdoc.DocumentElement; parentNode := xdoc.CreateElement('usuario'); TDOMElement(parentNode).SetAttribute('id', '001'); // create atributes to parent node RootNode.Appendchild(parentNode); // save parent node
//create a child node parentNode := xdoc.CreateElement('nome'); // create a child node //TDOMElement(parentNode).SetAttribute('sexo', 'M'); // create atributes nofilho := xdoc.CreateTextNode('Fernando'); // insert a value to node parentNode.Appendchild(nofilho); // save node RootNode.ChildNodes.Item[0].AppendChild(parentNode); // insert child node in respective parent node
//create a child node parentNode := xdoc.CreateElement('idade'); // create a child node //TDOMElement(parentNode).SetAttribute('ano', '1976'); // create atributes nofilho := xdoc.CreateTextNode('32'); // insert a value to node parentNode.Appendchild(nofilho); // save node .ChildNodes.Item[0].AppendChild(parentNode); // insert a childnode in respective parent node
writeXMLFile(xDoc,'teste.xml'); // write to XML Xdoc.free; // free memory
end;
initialization
{$I unit1.lrs}
end. </delphi>
Il risultato sarà il file XML seguente: <xml> <?xml version="1.0"?> <register>
<usuario id="001"> <nome>Fernando</nome> <idade>32</idade> </usuario>
</register> </xml>
--Fernandosinesio 22:28, 24 April 2008 (CEST)fernandosinesio@gmail.com
Codifica
A partire dalla revisione SVN 12582, il lettore XML è capace di processare i dati in qualsiasi codifica attraverso l'uso di decodificatori esterni. Vedere XML_Decoders per maggiori dettagli.
Secondo lo standard XML, l'attributo encoding nella prima linea del file XML è opzionale nel caso in cui l'effettiva codifica sia UTF-8 o UTF-16 (che viene individuata dalla presenza di BOM). Dalla versione 0.9.26 di Lazarus, c'è una proprietà encoding in TXMLDocument, ma è ignorata. writeXMLFile utilizza in ogni caso UTF-8 e non genera un attributo encoding nella prima linea del file XML.
Link Esterni
- W3Schools Xml Tutorial
Thomas Zastrow article FPC and XML