Oggi ho deciso di continuare un po 'l'argomento di lavorare con XML-RPC in WordPress. Come di solito mi capita, l'idea è nata nel momento di leggere un blog a caso, mi è venuto in mente di guardare a lavorare con i post del blog e, allo stesso tempo, provare a scrivere qualcosa che si adattasse alle mie esigenze.
Naturalmente oggi non posterò il programma, ma nel post saranno presenti alcuni calcoli, elenchi e idee.
Ho brevemente esaminato il lavoro con XML-RPC nel post “” Oggi proveremo ad andare avanti nel nostro lavoro e utilizzeremo diversi metodi correlati per ottenere determinate informazioni dal blog.
Ci concretizziamo obiettivo per oggi: è necessario ottenere dati sui post del blog utilizzando i metodi disponibili dall'API di WordPress.
Per raggiungere questo obiettivo, abbiamo bisogno dei seguenti moduli Delphi: XMLIntf , xmldom , XMLDoc e biblioteca sinapce o componente Indy idHTTP (a chiunque voglia).
1. Testare la connessione al blog.
Credo che la prima cosa da fare sia controllare che il blog funzioni correttamente per i seguenti possibili errori:
- Il blog ha disabilitato la possibilità di utilizzare XML-RPC
- L'utente ha fornito dati errati (url, nome utente o password).
Per testare la possibilità di lavorare con XML-RPC in un blog, basta usare il metodo demo.sayHello... Se la risposta è la linea "Ciao", quindi tutto è in ordine e puoi procedere alla fase successiva del controllo. Per eseguire questo controllo, dobbiamo completare tre semplici attività:
- generare un documento XML valido
- invia una richiesta al server e ottieni una risposta
- analizzare la risposta
Formiamo un documento XML che dovrebbe assomigliare a questo:
Per fare ciò, useremo l'interfaccia IXMLDocument:
[...] var doc: IXMLDocument; // root del documento: IXMLNode; // il nodo radice inizia ereditato Crea; doc: \u003d NewXMLDocument (); // crea un documento vuoto Radice: \u003d Doc. CreateElement ("methodCall", ""); // aggiunge il nodo radice Doc. DocumentElement: \u003d Root; Radice. AddChild ("methodName"). NodeValue: \u003d "demo.sayHello"; // aggiunge il nome del metodo Radice. AddChild ("params"). AddChild ("param"). AddChild ("valore"). AddChild ("string"). NodeValue: \u003d "test"; // scrive i parametri del metodo [ ... ]
Poiché il documento XML in sé è abbastanza semplice, mi sono preso la libertà di un po 'di "congelamento" e con l'ultima riga di codice ho annotato tutti i nodi e il valore dell'unico parametro per il nostro metodo contemporaneamente.
Ora puoi inviare il documento al server e ottenere una risposta:
[...] con THTTPSend. Crea inizia Doc. SaveToStream (documento); // scrive il documento nel corpo della richiesta se HTTPMethod ("POST", aURL) inizia // richiesta inviata con successo e ha ricevuto una risposta fine altrimenti inizio // richiesta fallita fine; fine; [...]
Quello che mi piace di Synapce, quindi questo è che "movimenti del corpo" non necessari non sono richiesti in termini di riempimento delle intestazioni Lunghezza del contenuto, Tipo di contenuto e così via. Ovviamente nessuno si preoccupa di riempire da soli tutti i titoli possibili, ma puoi farlo come ho mostrato sopra - tutto è automatico.
Andando avanti, analizzando la risposta.
Lascia che te lo ricordi l'invio riuscito di una richiesta al server non significa che abbiamo avuto accesso con successo all'XML-RPC del blog. L'invio corretto di una richiesta indica solo che abbiamo inviato una richiesta e ricevuto una risposta, ma non sappiamo cosa sia o meno nella risposta..
Per non preoccuparmi di metodi e metodi non necessari per analizzare la risposta dal server, propongo in questo caso di smetterla con un semplice controllo:
[...] Doc. LoadFromStream (Document, xetUTF_8); // ha scritto un documento XML se Doc. DocumentElement. ChildNodes. FindNode ("fault") \u003d nil quindi ShowMessage ( "XML-RPC funziona correttamente") [ ... ]
Secondo la specifica XML-RPC, i messaggi di errore sono contenuti in un nodo denominato fault. Pertanto, nel nostro caso, è sufficiente verificare la presenza di un tale nodo nel documento XML di risposta: se non è presente, la verifica è andata a buon fine, è stata generata una richiesta corretta e XML-RPC funziona correttamente.
Passando al passaggio successivo: verificare la correttezza dei dati forniti dall'utente e la capacità dell'utente di lavorare con l'XML-RPC del blog.
Solo l'amministratore può lavorare con l'XML-RPC del blog, quindi è necessario scoprire chi sta tentando di accedere. Per questo usiamo il metodo wp.getUsersBlogs... I parametri del metodo sono login e password.
Ma prima di iniziare a inviare una richiesta e ricevere una risposta, penso che valga la pena pensare un po 'al futuro e provvedere a lavorare con errori, generare documenti, ecc.
Nel controllo precedente, si potrebbe dire, c'erano coccole - la versione più semplice del lavoro del tipo:
inviato / ricevuto / qui_zhe_disassemblato / dimenticato / andato_further.
Dal momento che ho intenzione di sviluppare il modulo per lavorare con l'API di WordPress in futuro, ha senso decidere i seguenti punti del lavoro:
- Forma uno "scheletro" del documento
- Scrivi tutti i parametri necessari nel documento, tenendo conto dei tipi di dati
- Invia una richiesta e ricevi una risposta dal server
- Analizza la risposta e, se la risposta contiene un messaggio di errore, leggila correttamente
Ho eseguito tutti questi quattro passaggi come metodi di classe separati. Per "scheletro" del documento, intendo il seguente contenuto:
Ovvero, la parte del documento contenente il nome del metodo e il nodo params nessun contenuto. Inoltre, resta solo da compilare correttamente l'elenco dei parametri. Cosa faremo adesso.
In totale, XML-RPC prevede l'utilizzo di sei semplici tipi di dati:
- int e i4 sono numeri interi)
- numeri doppi frazionari
- string - stringhe
- base64 - stringa codificata
- dateTime.iso8601 - data / ora
- booleano
Iniziamo un nuovo tipo di dati:
TSimpleType \u003d (tsInt, tsI4, tsString, tsDouble, tsDateTime, tsBase64, tsBoolean);
Utilizzando i valori di questo tipo, definiremo il tag per il valore del parametro.
Poiché le operazioni di creazione di uno "scheletro" di un documento e l'aggiunta di parametri di metodo sono separate da funzioni diverse, creeremo un altro tipo di dati ausiliario:
PXMLDocument \u003d ^ IXMLDocument;
Ora il metodo per aggiungere un parametro al documento stesso:
procedura TBlog. SetParam (SimpleType: TSimpleType; Valore: stringa; Documento: PXMLDocument); var Root: IXMLNode; inizia se Documento ^. IsEmptyDoc quindi Exit; // il documento è vuoto Root: \u003d Document ^. DocumentElement. ChildNodes. FindNode ("params"); se Root \u003d nil allora Exit; // nodo non trovato caso SimpleType di tsInt: Root. AddChild ("param"). AddChild ("valore"). AddChild ("int"). NodeValue: \u003d Value; tsI4: radice. AddChild ("param"). AddChild ("valore"). AddChild ("i4"). NodeValue: \u003d Value; tsString: Root. AddChild ("param"). AddChild ("valore"). AddChild ("string"). NodeValue: \u003d Value; tsDouble: Root. AddChild ("param"). AddChild ("valore"). AddChild ("double"). NodeValue: \u003d Value; tsDateTime: Root. AddChild ("param"). AddChild ("valore"). AddChild ("dateTime.iso8601"). NodeValue: \u003d Value; tsBase64: radice. AddChild ("param"). AddChild ("valore"). AddChild ("base64"). NodeValue: \u003d Value; tsBoolean: radice. AddChild ("param"). AddChild ("valore"). AddChild ("boolean"). NodeValue: \u003d Value; fine; fine;
Questo metodo funziona solo per un record di tipo semplice. Quando si lavora con le strutture, è necessario perfezionare l'algoritmo.
Ora sull'analisi dei messaggi di errore. Diamo un'occhiata a un esempio di come appare un messaggio di errore in XML-RPC:
Il messaggio di errore ci arriva nella struttura. Inoltre, se assumiamo che i tag membrosono numerati da zero, quindi ogni elemento della struttura pari è un codice di errore e uno dispari è un testo di errore. Pertanto, il metodo per la gestione dei messaggi di errore potrebbe essere simile al seguente:
funzione TBlog. ParseErrors (aDocument: PXMLDocument): TStringList; var i: intero; Elenco: IDOMNodeList; codice: stringa; elenco di inizio: \u003d aDocument ^. DOMDocument. getElementsByTagName ("membro"); Risultato: \u003d TStringList. Creare; per i: \u003d 0 alla lista. length - 1 do begin case i mod 2 of 0: code: \u003d (List. item [i]. lastChild. firstChild as IDOMNodeEx). testo; // even element - leggi il codice di errore 1 : // elemento dispari: leggi il testo dell'errore e scrivi il risultato Risultato. Aggiungi (codice + "" + (List. Item [i]. LastChild. FirstChild as IDOMNodeEx). Text); fine; fine; fine;
Qui il codice di errore e il testo vengono scritti in TStringList. Penso che se necessario, puoi facilmente leggere il codice e il testo in elenchi o array diversi. Non ne abbiamo ancora bisogno.
Abbiamo già considerato l'invio di un documento, quindi presento immediatamente un metodo per verificare la correttezza dei dati:
funzione TBlog. CheckUserAccess (const aURL, aUser, aPassword: string; var Error: string): boolean; var Doc: IXMLDocument; iniziare Doc: \u003d GetDocument ("wp.getUsersBlogs"); // ha creato uno "scheletro" // aggiungi parametri SetParam (tsString, aUser, @ Doc); SetParam (tsString, aPassword, @ Doc); SendQuery (@ Doc, aURL); // invia una richiesta se non doc. IsEmptyDoc quindi // se il documento è stato scritto correttamente iniziare se Doc. DocumentElement. ChildNodes. FindNode ("fault") ‹› nil then // c'è un messaggio di errore inizio Risultato: \u003d falso; Errore: \u003d ParseErrors (@ Doc). Stringhe [0]; end else Risultato: \u003d true; end else Risultato: \u003d false; fine;
Se viene ricevuto un messaggio di errore, scrivere il messaggio nella variabile Error. In questo caso, la struttura contiene solo un messaggio di errore, ecco perché l'ho scritto così facilmente:
Errore: \u003d ParseErrors (@ Doc). Stringhe [0];
Quindi, sono stati effettuati due controlli e abbiamo stabilito che XML-RPC è abilitato e funziona correttamente e che l'utente ha inserito le informazioni di login e password corrette e può lavorare con l'API di WordPress. Qual è il prossimo? E poi iniziamo il lavoro principale: otteniamo dati sui commenti nel blog.
2. Ottenere dati sui post del blog.
Allora, cos'è WordPress a nostra disposizione. Innanzitutto, esaminiamo brevemente i metodi da xmlrpc.php.
wp.getPostStatusList - visualizza i valori per lo stato del post. Infatti, l'output avrà quattro righe: "bozza", "in sospeso", "privato", "pubblica".
Anche se questo metodo è inutile per noi.
blogger.getRecentPosts - Questa funzionalità è già dell'API di Blogger, ma è supportata in WordPress. L'output sarà l'ultimo post del blog, incluso tutto il contenuto del post.
Puoi usare il metodo, MA il lavoro del programma sarà rallentato in quanto dovrai “trascinare” l'intero post sul Web. E se proviamo a ottenere un elenco completo dei post del blog, allora, a quanto pare, dobbiamo andare a letto senza aspettare il risultato. Pertanto, per ora lasciamo da parte il metodo.
metaWeblog.getRecentPosts - simile al metodo precedente.
mt.getRecentPostTitles - metodo dall'API MovableType. A giudicare dal nome, di cosa abbiamo bisogno. Vedere la descrizione del metodo.
Il metodo restituisce un elenco contenente i titoli dei post del blog. In questo caso, il contenuto non viene scritto nell'elenco.
Parametri di input:
- Stringa blogid
- Nome utente stringa
- Password stringa
- int numberOfPosts
blogid sempre 1 (vedi descrizione in xmlrpc.php)
numberOfPosts - il numero di posti da elencare. Se il parametro ha un valore maggiore del numero di post del blog, il metodo restituisce un elenco di tutti i post.
Resta da scoprire qual è questa lista. E in uscita avremo una serie di strutture, che include:
- data di creazione dell'articolo
- iD utente
- postid
- titolo.
Meraviglioso. Useremo questo metodo e allo stesso tempo impareremo come analizzare strutture di risposta complesse.
Non credo valga la pena scrivere sulla creazione di una richiesta. La procedura è la stessa descritta sopra. Soffermiamoci sull'analisi della risposta del server in dettaglio. Abbiamo scoperto come appare il tipo di struttura durante l'analisi di una risposta contenente un errore di autorizzazione. Vediamo cos'è un array.
Gli array non hanno nome e sono descritti da un tag
Alla nostra uscita dal metodo mt.getRecentPostTitles
conterrà matrice di strutturee una struttura è costituita dalle informazioni su un post del blog. Pertanto, la lettura dei dati sui post del blog può essere suddivisa approssimativamente nei seguenti passaggi:
- Estrai tutti gli elementi dal documento XML ... Primogenito. childNodes; // ha ottenuto tutti i membri per 1 valore per j: \u003d 0 ai membri. length - 1 inizia con Result [i] do case j di 0: dateCreated: \u003d (Members [j]. lastChild. firstChild as IDOMNodeEx). testo; 1: user_id: \u003d StrToInt ((Members [j]. LastChild. FirstChild as IDOMNodeEx). Text); 2: id: \u003d StrToInt ((Members [j]. LastChild. FirstChild as IDOMNodeEx). Text); 3: title: \u003d (Members [j]. LastChild. FirstChild come IDOMNodeEx). testo; fine; fine; fine; [...]
Di conseguenza, se viene ricevuto un messaggio di errore, è possibile utilizzare la funzione discussa in precedenza.
È tutto per oggi. La prossima volta continueremo a lavorare con l'API e proveremo a ottenere tutti i commenti dal blog.
XML è sempre più utilizzato per memorizzare informazioni e scambiarle tra applicazioni e siti Web. Molte applicazioni utilizzano questo linguaggio come lingua di base per la memorizzazione dei dati, mentre altre lo utilizzano per esportare e importare dati XML. Quindi è tempo che gli sviluppatori pensino a come utilizzare i dati XML nelle proprie applicazioni.
In questo articolo, esamineremo il DOM (Document Object Model) XML e l'implementazione di XML DOM da parte di Microsoft.
XML DOM è un modello a oggetti che fornisce allo sviluppatore oggetti per il caricamento e l'elaborazione di file XML. Il modello a oggetti è costituito dai seguenti oggetti principali: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap e XMLDOMParseError. Ciascuno di questi oggetti (eccetto XMLDOMParseError) contiene proprietà e metodi che consentono di ottenere informazioni sull'oggetto, manipolare i valori e la struttura dell'oggetto e navigare nella struttura di un documento XML.
Diamo un'occhiata ai principali oggetti XML DOM e mostriamo alcuni esempi del loro utilizzo in Borland Delphi.
Utilizzo di XML DOM in Borland Delphi
Per utilizzare Microsoft XML DOM nelle applicazioni Delphi, è necessario collegare la libreria dei tipi appropriata al progetto. Per fare ciò, eseguiamo il comando Project | Importa libreria dei tipi e nella finestra di dialogo Importa libreria dei tipi, seleziona la libreria Microsoft XML versione 2.0 (Versione 2.0), che di solito si trova nel file Windows \\ System \\ MSXML.DLL
Dopo aver fatto clic sul pulsante Crea unità, verrà creato il modulo di interfaccia MSXML_TLB, che ci permetterà di utilizzare gli oggetti XML DOM: DOMDocument, XMLDocument, XMLHTTPRequest e numerosi altri, implementati nella libreria MSXML.DLL. Il riferimento al modulo MSXML_TLB deve essere nell'elenco Uses.
Dispositivo XML DOM
Il Document Object Model rappresenta un documento XML come una struttura ad albero di rami. Le API XML DOM consentono alle applicazioni di navigare nell'albero del documento e manipolarne i rami. Ogni ramo può avere un tipo specifico (DOMNodeType), in base al quale vengono determinati i rami padre e figlio. La maggior parte dei documenti XML contiene rami di tipo elemento, attributo e testo. Gli attributi sono un tipo speciale di ramo e non sono rami figlio. Gli attributi vengono manipolati utilizzando metodi speciali forniti dagli oggetti XML DOM.
Oltre a implementare le interfacce consigliate dal World Wide Web Consortium (W3C), Microsoft XML DOM contiene metodi che supportano XSL, modelli XSL, spazi dei nomi e tipi di dati. Ad esempio, il metodo SelectNodes consente di utilizzare la sintassi del pattern XSL per trovare rami in un contesto specifico e il metodo TransformNode supporta l'utilizzo di XSL per eseguire le trasformazioni.
Prova documento XML
Come documento XML di esempio, prendi una directory di CD-ROM musicale, che ha la seguente struttura:
Siamo ora pronti per iniziare a guardare il modello a oggetti XML DOM, iniziando con l'oggetto XMLDOMDocument.
Documento XML - Oggetto XMLDOMDocument
Lavorare con un documento XML inizia con il suo caricamento. Per fare ciò, utilizziamo il metodo Load, che ha un solo parametro che specifica l'URL del documento caricato. Quando si caricano file da un disco locale, viene specificato solo il nome file completo (in questo caso il protocollo file: /// può essere omesso). Se il documento XML è archiviato come stringa, utilizzare il metodo LoadXML per caricare quel documento.
La proprietà Async viene utilizzata per controllare la modalità di caricamento del documento (sincrono o asincrono). Per impostazione predefinita, questa proprietà è True, a indicare che il documento viene caricato in modo asincrono e il controllo viene restituito all'applicazione prima che il documento sia completamente caricato. In caso contrario, il documento viene caricato in modo sincrono e quindi è necessario controllare il valore della proprietà ReadyState per vedere se il documento è stato caricato o meno. È inoltre possibile creare un gestore eventi per l'evento OnReadyStateChange che assumerà il controllo quando il valore della proprietà ReadyState cambia.
Di seguito viene mostrato come caricare un documento XML utilizzando il metodo Load:
Utilizza ... MSXML_TLB ... procedura TForm1.Button1Click (Sender: TObject); var XMLDoc: IXMLDOMDocument; iniziare XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // // Qui è dove il codice // manipola il documento XML e le sue diramazioni // XMLDoc: \u003d Nil; fine;
Dopo che il documento è stato caricato, possiamo accedere alle sue proprietà. Pertanto, la proprietà NodeName conterrà il valore #document, la proprietà NodeTypeString conterrà il valore del documento e la proprietà URL conterrà il valore file: /// C: /DATA/DATA.xml.
Gestione degli errori
Di particolare interesse sono le proprietà associate all'elaborazione del documento durante il caricamento. Ad esempio, la proprietà ParseError restituisce un oggetto XMLDOMParseError contenente informazioni su un errore che si è verificato durante l'elaborazione del documento.
Per scrivere un gestore degli errori, puoi aggiungere il codice seguente:
Var XMLError: IXMLDOMParseError; ... XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); XMLError: \u003d XMLDoc.ParseError; Se XMLError.ErrorCode<> 0 Allora // // Qui gestiamo l'errore // Else Memo1.Lines.Add (XMLDoc.XML); ... XMLDoc: \u003d Nil;
Per vedere quali informazioni vengono restituite in caso di errore, modificare la seguente voce di directory:
rimuovere l'elemento di chiusura
Ora scriviamo il codice che restituisce i valori delle proprietà dell'oggetto XMLDOMParseError:
XMLError: \u003d XMLDoc.ParseError; Se XMLError.ErrorCode<> 0 Quindi con XMLError, Memo1.Lines inizia con Add ("File:" + URL); Aggiungi ("Codice:" + IntToStr (ErrorCode)); Aggiungi ("Errore:" + motivo); Aggiungi ("Testo:" + SrcText); Aggiungi ("Riga:" + IntToStr (Riga)); Aggiungi ("Posizione:" + IntToStr (LinePos)); end Else Memo1.Lines.Add (XMLDoc.XML); Fine;
ed eseguire la nostra applicazione. Di conseguenza, otteniamo le seguenti informazioni sull'errore.
Come puoi vedere dall'esempio precedente, le informazioni restituite dall'oggetto XMLDOMParseError sono sufficienti per localizzare l'errore e comprendere la causa del suo verificarsi.
Ora ripristineremo l'elemento di chiusura
Accesso all'albero dei documenti
Per accedere all'albero del documento, puoi ottenere l'elemento radice e quindi iterare sui suoi rami figli o trovare un ramo specifico. Nel primo caso, otteniamo l'elemento root tramite la proprietà DocumentElement, che restituisce un oggetto di tipo XMLDOMNode. Ecco come utilizzare la proprietà DocumentElement per ottenere il contenuto di ogni elemento figlio:
Nodo Var: IXMLDOMNode; Radice: IXMLDOMElement; I: numero intero; ... Root: \u003d XMLDoc.DocumentElement; Per I: \u003d 0 a Root.ChildNodes.Length-1 do Begin Node: \u003d Root.ChildNodes.Item [I]; Memo1.Lines.Add (Node.Text); Fine;
Per il nostro documento XML, otteniamo il testo seguente.
Se siamo interessati a un ramo specifico o un ramo sotto il primo ramo figlio, possiamo utilizzare il metodo NodeFromID o il metodo GetElementByTagName dell'oggetto XMLDOMDocument.
Il metodo NodeFromID richiede un identificatore univoco come definito nello schema XML o nella DTD (Document Type Definition) e restituisce un ramo con tale identificatore.
Il metodo GetElementByTagName richiede una stringa con un elemento specifico (tag) e restituisce tutti i rami con questo elemento. Ecco come utilizzare questo metodo per trovare tutti gli artisti nella nostra directory CD-ROM:
Nodi: IXMLDOMNodeList; Nodo: IXMLDOMNode; ... Nodi: \u003d XMLDoc.GetElementsByTagName ("ARTIST"); Per I: \u003d 0 a Nodes.Length-1 do Begin Node: \u003d Nodes.Item [I]; Memo1.Lines.Add (Node.Text); Fine;
Per il nostro documento XML, otterremo il testo seguente
Si noti che il metodo SelectNodes dell'oggetto XMLDOMNode fornisce un modo più flessibile per accedere ai rami del documento. Ma ne parleremo più avanti.
Ramo documento - Oggetto XMLDOMNode
L'oggetto XMLDOMNode rappresenta un ramo del documento. Abbiamo già riscontrato questo oggetto durante il recupero dell'elemento radice del documento:
Radice: \u003d XMLDoc.DocumentElement;
Per ottenere informazioni su un ramo di un documento XML, è possibile utilizzare le proprietà dell'oggetto XMLDOMNode (Tabella 1).
Per accedere ai dati archiviati in un ramo, è comune utilizzare la proprietà NodeValue (disponibile per attributi, rami di testo, commenti, istruzioni di elaborazione e sezioni CDATA) o la proprietà Text, che restituisce il contenuto di testo del ramo o la proprietà NodeTypedValue. Quest'ultimo, tuttavia, può essere utilizzato solo per rami con elementi dattiloscritti.
Navigazione nella struttura ad albero del documento
L'oggetto XMLDOMNode fornisce molti modi per navigare nella struttura ad albero del documento. Ad esempio, per accedere al ramo padre, utilizzare la proprietà ParentNode (tipo XMLDOMNode), accedere ai rami figlio tramite le proprietà ChildNodes (tipo XMLDOMNodeList), FirstChild e LastChild (tipo XMLDOMNode), ecc. La proprietà OwnerDocument restituisce un oggetto XMLDOMDocument che identifica il documento XML stesso. Le proprietà elencate sopra facilitano la navigazione nell'albero del documento.
Ora iteriamo su tutti i rami del documento XML:
Radice: \u003d XMLDoc.DocumentElement; Per I: \u003d 0 a Root.ChildNodes.Length-1 do Begin Node: \u003d Root.ChildNodes.Item [I]; If Node.HasChildNodes Then GetChilds (Node, 0); Fine;
Come notato sopra, i SelectNodes dell'oggetto XMLDOMNode forniscono un modo più flessibile per accedere ai rami del documento. Inoltre, esiste un metodo SelectSingleNode che restituisce solo il primo ramo del documento. Entrambi questi metodi consentono di definire modelli XSL per le ricerche nei rami.
Diamo un'occhiata al processo di utilizzo del metodo SelectNodes per recuperare tutti i rami che hanno un ramo CD e un ramo secondario PRICE:
Radice: \u003d XMLDoc.DocumentElement; Nodi: \u003d Root.SelectNodes ("CD / PRICE");
Tutti i rami secondari PRICE del ramo CD verranno inseriti nella raccolta Nodes. Torneremo un po 'più tardi a discutere dei modelli XSL.
Manipolazione dei rami figli
Per manipolare i rami figli, possiamo usare i metodi dell'oggetto XMLDOMNode (Tabella 2).
Per eliminare completamente il record relativo al primo disco, è necessario eseguire il codice seguente:
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // Recupera l'elemento radice Root: \u003d XMLDoc.DocumentElement; Nodo: \u003d Root; // Rimuove il primo ramo figlio Node.RemoveChild (Node.FirstChild);
Nota che in questo esempio stiamo eliminando il primo ramo figlio. Di seguito viene mostrato come rimuovere il primo elemento del primo ramo figlio:
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // Recupera l'elemento radice Root: \u003d XMLDoc.DocumentElement; // e il primo ramo figlio Node: \u003d Root.FirstChild; // Rimuove il primo ramo figlio Node.RemoveChild (Node.FirstChild);
Nell'esempio precedente, non abbiamo eliminato il primo ramo
Ora aggiungiamo un nuovo ramo. Di seguito è riportato il codice che mostra come aggiungere una nuova voce CD-ROM musicale:
Var NewNode: IXMLDOMNode; Figlio: IXMLDOMNode; ... // Crea un nuovo ramo -
Il codice sopra mostra i seguenti passaggi per l'aggiunta di un nuovo ramo:
- Creazione di un nuovo ramo utilizzando il metodo CreateNode:
- creazione di un elemento utilizzando il metodo CreateNode;
- aggiunta di un elemento a un ramo utilizzando il metodo AppendChild;
- impostare il valore di un elemento tramite la proprietà Text;
- … Ripeti per tutti gli elementi.
- Aggiunta di un nuovo ramo al documento utilizzando il metodo AppendChild.
Ricorda che il metodo AppendChild aggiunge un ramo alla fine dell'albero. Per aggiungere un ramo a un punto specifico dell'albero, è necessario utilizzare il metodo InsertBefore.
Set di diramazioni: oggetto XMLDOMNodeList
L'oggetto XMLNodeList contiene un elenco di rami, che possono essere creati utilizzando i metodi SelectNodes o GetElementsByTagName e ottenuti anche dalla proprietà ChildNodes.
Abbiamo già discusso l'uso di questo oggetto nell'esempio fornito nella sezione "Navigazione nell'albero del documento". Qui forniremo anche alcuni commenti teorici.
Il numero di rami nell'elenco può essere ottenuto come valore della proprietà Length. I rami sono indicizzati da 0 a Lunghezza-1 e ogni singolo ramo è accessibile tramite l'elemento indicizzato corrispondente nell'array Item.
La navigazione nell'elenco dei rami può essere eseguita anche con il metodo NextNode, che restituisce il ramo successivo nell'elenco, o Nil se il ramo corrente è l'ultimo. Per tornare all'inizio dell'elenco, chiama il metodo Reset.
Crea e salva documenti
Quindi, abbiamo spiegato come aggiungere rami ed elementi a documenti XML esistenti. Ora creiamo un documento XML al volo. Prima di tutto, ricorda che un documento può essere caricato non solo da un URL, ma anche da una stringa normale. Di seguito viene mostrato come creare un elemento radice, che può quindi essere utilizzato per costruire dinamicamente il resto degli elementi (di cui abbiamo già parlato nella sezione "Manipolazione dei rami figli"):
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; S: WideString; ... S: \u003d '
Dopo aver creato il documento XML, salvalo in un file utilizzando il metodo Save. Per esempio:
XMLDoc.Save ('C: \\ DATA \\ NEWCD.XML');
Oltre a salvare in un file, il metodo Save consente di salvare un documento XML in un nuovo oggetto XMLDOMDocument. In questo caso, il documento viene completamente elaborato e, di conseguenza, vengono verificate la sua struttura e sintassi. Ecco come salvare un documento su un altro oggetto:
Procedura TForm1.Button2Click (Sender: TObject); var XMLDoc2: IXMLDOMDocument; iniziare XMLDoc2: \u003d CoDOMDocument.Create; XMLDoc.Save (XMLDoc2); Memo2.Lines.Add (XMLDoc2.XML); ... XMLDoc2: \u003d Nil; fine;
In conclusione, il metodo Save consente anche di salvare il documento XML su altri oggetti COM che supportano le interfacce IStream, IPersistStream o IPersistStreamInit.
Utilizzo di modelli XSL
Discutendo il metodo SelectNodes dell'oggetto XMLDOMNode, abbiamo detto che fornisce un modo più flessibile per accedere ai rami del documento. La flessibilità è data dalla possibilità di specificare un modello XSL come criterio per la selezione dei rami. Tali modelli forniscono un potente meccanismo per trovare informazioni nei documenti XML. Ad esempio, per ottenere un elenco di tutti i titoli di CD-ROM musicali nella nostra directory, è possibile eseguire la seguente query:
Per scoprire quali dischi d'artista sono stati rilasciati negli USA, la richiesta è formata come segue:
Nodi: \u003d Root.SelectNodes ("CD / ARTIST");
Ecco come trovare la prima unità in una directory:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
e ultimo:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
Per trovare i dischi di Bob Dylan, puoi eseguire la seguente query:
Nodi: \u003d Root.SelectNodes ("CD [$ any $ ARTIST \u003d" Bob Dylan "] / TITLE");
e per ottenere un elenco di dischi creati dopo il 1985, eseguiamo la seguente query:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
Una discussione più dettagliata della sintassi XSL richiede una pubblicazione separata. Per incuriosire i lettori e incoraggiare ulteriori ricerche, fornirò solo un piccolo esempio del possibile utilizzo di XSL. Diciamo che dobbiamo convertire il nostro catalogo in una normale tabella HTML. Utilizzando i metodi tradizionali, dobbiamo iterare su tutti i rami dell'albero e per ogni elemento ricevuto formare i tag corrispondenti
Usando XSL, creiamo semplicemente un modello (o foglio di stile) che specifica cosa e come trasformare. Quindi inseriamo questo modello nel nostro catalogo e il gioco è fatto: abbiamo il testo del modello XSL che trasforma il catalogo in una tabella (Listato 2).
Il codice per sovrapporre un modello XSL sulla nostra directory è simile a questo:
Procedura TForm1.Button2Click (Sender: TObject); var XSLDoc: IXMLDOMDocument; iniziare XSLDoc: \u003d CoDOMDocument.Create; XSLDoc.Load ("C: \\ DATA \\ DATA.xsl"); Memo2.Text: \u003d XMLDoc.TransformNode (XSLDoc); XSLDoc: \u003d Nil; fine;
Concludendo la nostra discussione su XSL, va detto che attualmente questo linguaggio è attivamente utilizzato per la trasformazione tra vari documenti XML, così come per la formattazione dei documenti.
Conclusione
Per ovvie ragioni, è impossibile coprire tutti gli oggetti Microsoft XML DOM e fornire esempi del loro utilizzo in un articolo. Qui abbiamo appena toccato i problemi di base dell'utilizzo di XML DOM nelle applicazioni. tavolo 3 mostra tutti gli oggetti implementati nel Microsoft XML DOM.
ComputerPress 12 "2000
Nonostante il fatto che l'argomento del lavoro con XML in Delphi sia stato ampiamente discusso su Internet, le domande su questo argomento spesso sorgono in tutti i tipi di forum.
Ho scritto anche questo, ma vorrei tornare al caso reale di analizzare rapidamente un file XML e recuperare i dati che ho fatto al lavoro oggi. Non ho impiegato più di 5 minuti per ottenere i dati necessari.
Sfondo. Oggi era necessario elaborare i dati sui programmi installati sui computer degli utenti (sì, sì, identifichiamo i pirati :)). Il dipartimento tecnico mi ha fornito queste informazioni strappate da utenti ignari su una rete utilizzando WMI. Il programma utilizzato produce report in formato XML. Di conseguenza, mi hanno portato una montagna di file XML con una struttura piuttosto complessa, da cui ho dovuto solo estrarre il nome dei prodotti software installati. Trattamento. Dopo aver esaminato manualmente un paio di file, mi sono reso conto che non ci sarebbe voluto molto per invecchiare e ho deciso di scrivere un piccolo convertitore. Dopo aver avviato Delphi, ho selezionato l'oggetto XML DataBinding dal repository e gli ho fornito uno dei file. Ho lasciato tutte le impostazioni ei parametri per impostazione predefinita e, di conseguenza, ho ottenuto un modulo con un gran numero di classi e interfacce per accedere agli elementi di questo file XML. Non mi sono preoccupato per molto tempo di occuparmi della struttura delle classi, sono passato subito alla scrittura di un convertitore. In una nuova applicazione console, ho scritto un codice piuttosto semplice:
programma XML2TXT;
usi
Forme,
Classi, SysUtils,
SoftwareXML in "SoftwareXML.pas";
procedura CovertXML2Text;
var
softbase: IXMLSTDSoftwareType;
i: intero;
sr: TSearchRec;
CurDir: stringa;
ExportFile: TStringList;
inizio
CurDir: \u003d IncludeTrailingPathDelimiter (ExtractFilePath (Application.ExeName));
se FindFirst (CurDir + "*. xml", faAnyFile, sr) \u003d 0 allora
ripetere
ExportFile: \u003d TStringList.Create;
softbase: \u003d LoadSTDSoftware (Pchar (CurDir + sr.Name));
per i: \u003d 0 a softbase.InstalledSoftware.source.software.Count - 1 do
ExportFile.Add (softbase.InstalledSoftware.source.software [i] .DisplayName);
ExportFile.Sort;
ExportFile.SaveToFile (CurDir + softbase.InstalledSoftware.Source.servername + ". Txt");
ExportFile.Free;
fino a FindNext (sr) 0;
fine;
inizio
Application.Initialize;
CovertXML2Text;
fine.
Di conseguenza, ho ottenuto un editor di testo per ogni computer nella griglia, contenente un elenco di software installato.
Ritengo che questo codice richiederà alcune spiegazioni. Ad esempio, perché ho utilizzato il modulo Forms in un'applicazione console e ho chiamato la procedura Application.Initialize;?
In realtà è semplice: questo è un piccolo trucco che ti consente di utilizzare XML Data Binding in un'applicazione console. Perché si rifiutava ostinatamente di inizializzare la classe per lavorare con XML. Non ho ancora capito le vere ragioni - oggi il tempo era importante, ho già passato 4 minuti su 5 a combattere questo errore. :) Penso di affrontare questo problema più tardi e scrivere qual è il vero motivo.
La strana classe softbase è stata creata da un file XML, che era il nome dell'elemento radice, e softbase.InstalledSoftware.source.software [i] .DisplayName è solo la navigazione tra gli elementi nidificati fino a quello desiderato e ottenere il suo valore.
Ecco come appare uno dei modi più veloci per lavorare con XML in Delphi.
Recentemente, molta attenzione è stata dedicata alla creazione di sistemi di e-business, o come vengono anche chiamati - B2B (business to business). Tenendo conto delle raccomandazioni per la costruzione di sistemi di scambio streaming dell'ente di coordinamento delle tecnologie Internet - Consorzio WWW: l'accento è posto sulle tecnologie XML e sulla costruzione di sistemi per lo scambio di documenti XML.
Il vantaggio dell'utilizzo di XML nell'e-business è l'elevata efficienza dei sistemi B2B a bassi costi per la sua creazione grazie a una presentazione chiara e visiva delle informazioni strutturate, la capacità di utilizzare i moderni protocolli di rete e creare sistemi aziendali in tempo reale.
L'indipendenza della presentazione delle informazioni sotto forma di documenti XML consente alle diverse società coinvolte nell'e-business di produrre software indipendenti l'una dall'altra.
In tutti i sistemi, lo scambio, di regola, è costruito secondo lo stesso schema, utilizzando richieste HTTP. SSL viene utilizzato come protocollo di sicurezza delle informazioni (ma questo è un argomento separato).
Una delle possibili opzioni per l'elaborazione dei messaggi XML consiste nel creare applicazioni BIN / CGI (ISAPI) o componenti COM (server) che generano o elaborano documenti XML.
Da un lato l'applicazione funge da client, che emette una richiesta HTTP in modalità POST, dall'altro lato c'è un WEB server sul lato del quale viene elaborata la richiesta e viene emessa una risposta. I documenti XML vengono utilizzati nello scambio di informazioni.
Una delle opzioni di implementazione più efficienti consiste nell'usare un parser XML esistente che supporti il \u200b\u200bmodello DOM. Tale parser è un pacchetto di distribuzione di Win'98 o parte integrante di IE 4.7 e versioni successive (per Win'95) e rappresenta un server COM situato nella libreria msxml.dll.
Component Object Model (COM): rappresenta dati e metodi incapsulati in una singola entità e un modo per accedervi tramite un sistema di interfacce. Utilizzando gli strumenti Delphi, è abbastanza facile accedere alle classi di un oggetto COM (diverse classi possono essere incluse in un server COM). Si accede agli oggetti inizializzando un'istanza di classe tramite il sistema di interfaccia. La descrizione delle interfacce viene effettuata dal linguaggio di definizione dell'interfaccia (IDL), che può essere eseguito automaticamente tramite l'ambiente.
Gli strumenti Delphi vengono utilizzati per importare da un server COM msxml.dll, vengono creati i file di descrizione dell'interfaccia IDL e il file della descrizione binaria dei tipi di libreria - TLB. Questa operazione viene eseguita tramite il menu di sistema: Progetto | Tipo di importazione della libreria:(immagine 1). Successivamente, viene visualizzata una finestra di dialogo (Figura 2), in cui è necessario selezionare un oggetto COM (nel nostro caso, l'oggetto è registrato con il nome "Microsoft.XMLDom (Versione 2.0)") e creare un file TLB (pulsante Crea unità). Utilizzando il file TLB, il framework genera un file di descrizione del server COM Pascal - MSXML_TLB.pas
Il file MSXML_TLB.pas descrive tutte le interfacce, le costanti e la classe del server COM.
Per accedere agli oggetti di un elemento COM, è necessario nella direttiva USIaggiungere il nome del file di descrizione della libreria (MSXML_TLB.pas). Di seguito è riportato un semplice programma che utilizza il parser DOM standard msxml.dll, che carica un documento XML e lo visualizza in un elemento del campo di testo Memo1.
usi Windows, messaggi, SysUtils, classi, grafica, controlli, moduli, finestre di dialogo, OleServer, MSXML_TLB, StdCtrls; genere TForm1 \u003d classe(TForm) Button1: TButton; Memo1: TMemo; procedura Button1Click (Sender: TObject); fine; var Form1: TForm1; implementazione ($ R * .DFM) ProceduraTForm1.Button1Click (Sender: Tobject); // dichiarazione della soclass dell'oggetto DOMDocument; varcoDoc: CoDOMDocument; // classe coerente con l'interfaccia IDOMDocument; varDoc: IXMLDOMDocument; inizio // crea un'istanza dell'oggetto DOMDocument; Doc: \u003d coDoc.Create; // chiama il metodo Load di un'istanza dell'oggetto DOMDocument; Doc.load ("data.xml"); // accesso alla proprietà xml dell'istanza DOMDocument; Memo1.Text: \u003d Doc.xml; fine; fine.Concetto DOM - Document Object Model
Ogni documento XML è rappresentato come un insieme di più oggetti (classi), con l'aiuto dei quali è possibile accedere a singoli elementi (campi oggetto). DOM: l'interfaccia descrive l'accesso sia a oggetti semplici di tipo DOMString o CharacterData, sia a parti o singoli elementi di un documento XML: DOMFragmentElement, DOMNode, DOMElement.
Di seguito sono riportate le proprietà e i metodi più importanti degli oggetti XMLDOMDocument, XMLDOMNode, XMLDOMNodeList. Va notato che i metodi e le funzioni degli oggetti DOM presentati di seguito (Document Object Model) sono utilizzati dal parser Microsoft XML msxml.dll e sono un po 'più ampi del modello approvato dal W3C DOM Consortium.
Una descrizione più completa dell'interfaccia dell'oggetto DOM può essere trovata su
Oggetto XMLDOMDocument | |
Rappresenta il livello più alto della gerarchia degli oggetti e contiene metodi per lavorare con un documento: caricarlo, analizzarlo, creare elementi, attributi, commenti, ecc. ... | |
Proprietà | |
Async | Proprietà che identifica la modalità di elaborazione corrente |
ParseError | Restituisce un riferimento all'oggetto di gestione degli errori XMLDOMParseError |
Abilita: disabilita la verifica del documento. | |
url | Restituisce l'URL del documento |
documentElement | Contiene un riferimento all'elemento radice del documento come oggetto XMLDOMElement. |
Metodi | |
caricare (url) loadXML (xmlString) |
Carica un documento XML, |
salva (objTarget) | Salva il documento XML su file |
abortire | Interruzione del processo di caricamento ed elaborazione del documento. |
createAttribute (nome) | Crea un nuovo attributo con il nome specificato per l'elemento corrente. |
createNode (Type, name, nameSpaceURI) | Crea un nodo del tipo e del nome specificati |
createElement (tagName) | Crea un elemento del documento con il nome specificato. |
createTextNode (dati) | Crea testo all'interno di un documento |
getElementsByTagName (tagname) | Restituisce un riferimento alla raccolta di elementi del documento con il nome specificato |
nodeFromID (idString) | Trovare un articolo per ID |
Oggetto XMLDOMNode | |
Oggetto XMLDOMNode che implementa l'interfaccia DOM sottostante Nodo, è inteso per manipolare un nodo separato dell'albero del documento. Le sue proprietà e metodi consentono di ottenere e modificare le informazioni complete sul nodo corrente: tipo, nome, nome completo, contenuto, elenco di elementi figlio, ecc. | |
Proprietà | |
nodeName, baseName | Restituisce il nome del nodo corrente. |
prefisso | Restituisce il prefisso dello spazio dei nomi. |
tipo di dati | Specifica il tipo di contenuto del nodo corrente |
nodeType, nodeTypeString | Restituisce il tipo del nodo corrente: |
attributi | Ottiene un elenco degli attributi del nodo corrente come raccolta XMLDOMNamedNodeMap. |
testo | Restituisce il contenuto della sottostruttura corrente come testo |
xml | Restituisce una rappresentazione XML della sottostruttura corrente. |
nodeValue | Restituisce il contenuto del nodo corrente. |
childNodes | Restituisce un elenco di elementi figlio come XMLDOMNodeList. |
firstChild, lastChild | Restituisce il primo / ultimo figlio |
previousSibling, nextSibling | Restituisce l'elemento di pari livello precedente / successivo. |
parentNode | Contiene un collegamento all'elemento padre. |
ownerDocument | Restituisce un puntatore al documento contenente il nodo corrente. |
Metodi | |
appendChild (newChild) | Aggiunge un nuovo figlio al nodo corrente. |
insertBefore (newChild, refChild) | Inserisce un nodo figlio, posizionandolo nel sottoalbero corrente "a sinistra" del nodo specificato dal parametro refChild. |
cloneNode (profondo) | Crea una copia dell'elemento corrente. |
getAttribute(nome) getAttributeNode (nome) setAttribute (nome, valore) setAttributeNode (XMLDOMAttribute) |
Accesso agli attributi (creazione, lettura, scrittura) dell'oggetto. Il nome è il nome dell'attributo, il valore è il suo valore. Restituisce un oggetto XMLDOMAttribute. |
replaceChild (newChild, oldChild) removeChild (oldChild) | Sostituzione dell'oggetto oldChild dell'elenco corrente di oggetti figlio con newChild. Eliminazione dell'oggetto oldChild |
selectNodes (patternString) selectSingleNode (patternString) | Restituisce un oggetto XMLDOMNodeList selezionato dal modello di ricerca o dal primo nodo |
transformNode (foglio di stile) transformNodeToObject (stylesheet, outputObject) |
Assegna un foglio di stile alla sottostruttura del nodo corrente e restituisce una stringa che è il risultato dell'elaborazione. Il parametro è un riferimento all'oggetto DOMDocument che contiene le istruzioni XSL. |
Utilizzo di XML negli affari.
Per un'immagine più chiara è necessaria una spiegazione e perché tutto ciò è necessario per capire come funziona:
Quando si costruisce un sistema ERP B2B o aziendale, quando si organizza lo scambio di informazioni di documenti XML tra aziende o filiali di pr-I, viene utilizzato un sistema di trasferimento di informazioni efficiente e collaudato basato su server WEB esistenti su protocolli HTTP.
Da un lato l'applicazione funge da client, che emette una richiesta HTTP in modalità POST, dall'altro c'è un server WEB, sul lato del quale viene elaborata la richiesta e viene emessa una risposta. I documenti XML vengono utilizzati come scambio.
Ad esempio, in un semplice sistema ERP aziendale, un programma di contabilità (ACS Accounting), è necessario formare una richiesta di fattura e inviarla a una filiale che dispone di un magazzino (ACS Warehouse). AWP Una dichiarazione di problema simile durante la creazione di un sistema B2B, quando l'impresa A richiede la disponibilità dei prodotti (effettua un ordine per l'acquisto) dal fornitore B.
Enterprise A e il suo programma agiscono come client. Il magazzino è servito dal Fornitore B, che dispone di un complesso di magazzino con un database su un server SQL. Lo scambio viene effettuato tramite il server WEB aziendale del Fornitore V.
Di seguito è riportato il seguente algoritmo di scambio tipico:
Figura 3.
- Enterprise Ainizia processo A(ordine del prodotto), che funge da client WEB.
- Processo Agenera un documento XML (ad esempio, una richiesta di fattura) e lo trasmette come richiesta HTTP POST al server WEB del Provider B. L'identificativo della risorsa dell'applicazione di elaborazione viene utilizzato come URI. L'URI può essere lo stesso per tutti i tipi di documenti o individuale per ogni tipo. Tutto dipende dalla struttura del server B2B (WEB).
- Il server WEB analizza la richiesta e genera un server Processo Bpassando il corpo del documento XML come parametro.
Il processo B viene avviato da un server WEB e viene elaborato come pagina ASP, applicazione CGI (ISAPI) o server JAVA (applicazione server) - Processo B- genera una query al server di database SQL.
- Il server SQL esegue le operazioni necessarie nel database, genera una risposta e la restituisce Processo B.
- Secondo la risposta del server SQL Processo B genera un documento XML (risposta) e lo restituisce come risposta a una richiesta http all'applicazione client.
- Inoltre, a seconda della situazione sul lato client, viene formata una nuova richiesta http o la sessione termina.
Qualche parola sull'organizzazione del flusso di documenti.
La regola generale per sviluppare un sistema per lo scambio di documenti XML è:
- in primo luogo- sviluppo di un diagramma di flusso dei documenti elettronici e della loro struttura;
- in secondo luogo- sviluppo di tabelle di funzioni di processo (sottoprocessi), ad es. quale funzione rispetto a quale documento XML ogni processo implementerà.
Ogni documento XML, come un documento HTML, deve essere costituito da un'intestazione del messaggio (informazioni racchiuse da tag) e dal corpo del messaggio (per una richiesta, queste informazioni sono racchiuse in tag per rispondere a una richiesta). Affinché il documento XML sia ben formato, è necessario inquadrare le sue due parti componenti "Titolo" e "Richiesta" con tag, ad esempio. Di seguito viene presentato il tipo di documento tipico:
L'intestazione (Figura 4), a differenza di un documento HTML, deve contenere vari tipi di informazioni di servizio, comprese le informazioni sul tipo di documento trasmesso e il processo della sua elaborazione. Il corpo del documento entra nell'elaborazione delle informazioni, ad es. contenuto incorniciato da tag. Va notato che la struttura delle intestazioni dovrebbe essere la stessa per tutti i tipi di documenti.
Per il Processo avviato dal server, è preferibile (ma non necessario) costruire l'algoritmo di elaborazione come segue:
Figura 6.
Alcuni punti fondamentali nella creazione del lato client
Come già spiegato, quando si crea un documento XML, viene utilizzata la sua rappresentazione sotto forma di un modello DOM. Di seguito è riportato un esempio di una porzione di testo Delphi di un programma di generazione di intestazioni xml di messaggi.
proceduraTThread1.HeaderCreate (Sender: Tobject); var // dichiarazione di classe, necessaria per creare coDoc: CoDomDocument; // Oggetto XMLDomDocument Doc: DomDocument; r: IXMLDOMElement; Nodo: IXMLDOMElement; // DOMText txt: IXMLDOMText; // DOMAttribute attr: IXMLDOMAttribute; inizio // crea un documento DOM Doc: \u003d coDoc.Create; Doc.Set_async (false); // avvio iniziale del documento DOM Doc.LoadXML ("Si noti che la dichiarazione della variabile coDoc: CoDomDocument e Doc: DomDocument, così come la sua creazione con il metodo Create (Doc: \u003d coDoc.Create;) viene eseguita una volta. La dichiarazione di variabile si trova nella sezione che descrive le variabili globali e non nella procedura locale, come è stato dimostrato per chiarezza in questo esempio (cioè una variabile globale di tipo DomDocument per un modulo di programma).
Il risultato del lavoro del programma precedente sarà l'intestazione creata, applicata al nostro documento xml di esempio: mostrato nella Figura 5.
Figura 5.
Figura 6.
Il vantaggio principale del trasferimento di informazioni sotto forma di documenti XML è che è possibile formare un messaggio utilizzando strutture di tabelle indipendenti nel DBMS sia sul lato di ricezione che di trasmissione. Utilizzando il nostro esempio, supponiamo che sia necessario trasferire le informazioni sulle fatture dell'Impresa A, dal DBMS avente la struttura mostrata in Figura 6
Per generare un documento xml contenente una fattura, viene inizialmente creata una query SQL (query A) con le informazioni sulla fattura stessa:
SELEZIONARE * FROM Invoice_General DOVE InvoiceNum \u003d: num SELEZIONAREMerce, qualità, prezzo, HZ_cod A PARTIRE DALMerce DOVE InvoiceNum \u003d: num //: num - un parametro che specifica il numero di fattura.Di seguito una parte del programma che genera il corpo del documento xml:
procedura TThread1.DataBodyCreate (Sender: Tobject); var // dichiarazione della classe e dell'oggetto XMLDomDocument // coDoc: CoDomDocument; // deve essere globale per l'intero modulo. // Doc: DomDocument; // dichiara gli oggetti DOMElement r: IXMLDOMElement; // DOMElement; Nodo, Nodo2: IXMLDOMElement; Nodo3, Nodo4: IXMLDOMElement; // DOMText txt: IXMLDOMText; str: String; // Numero di fattura: numero intero; - variabile globale - // ha il valore 987654 // queryA, queryB: Corda; - variabile globale, // ha un valore corrispondente alla query // queryA - query A con informazioni generali sulla fattura // queryB - query B informazioni sulle merci descritte in // fattura (vedi testo) inizio Query.Close; // vedi il testo "richiesta A" Query.Text: \u003d queryA; // esegue la richiesta Query.ExecSQL; Query.Open; // ottiene l'indirizzo dell'elemento radice r: \u003d Doc.Get_documentElement; Node2: \u003d Doc.createElement ("Request"); // crea DOMElement (tag) Nodo: \u003d Doc.createElement ("Invoice"); // aggiunge un elemento alla radice r.appendChild (Node2); // aggiungi un elemento a Node2. appendChild (Node); // crea DOMElement (tag) Nodo3: \u003d Doc.createElement ("Depurture"); // aggiungi un elemento a Nodo. appendChild (Node3); // chiamata al campo "Depurture" della richiesta str: \u003d Query.FieldByName ("Depurture"). AsString; // crea nodo di testo \u003d valore del campo // assegna un valore al nodo // nodo di testo, variabile str Node.appendChild (txt); // operazioni simili per il tagCome risultato di questa procedura, viene generato il seguente testo del documento XML:
Per formare una richiesta, utilizzare il metodo Open dell'oggetto IXMLHttpRequest:
procedura Open (const bstrMethod, - method type \u003d "POST" bstrUrl, - Server url varAsync, - communication mode asynchronous / synchronous \u003d true bstrUser, - username for authentication bstrPassword) - passwordCreazione del lato server dell'elaborazione dei documenti
Come notato in precedenza, l'elaborazione di una richiesta HTTP può essere gestita da applicazioni CGI o servlet Java. È anche possibile scrivere pagine ASP. Ma in questo caso, il trasferimento dei dati è possibile solo con il metodo "GET" tramite la stringa di query. Tuttavia, la gestione di una richiesta HTTP per le pagine ASP è più efficiente di un'applicazione CGI. Tuttavia, a mio parere, non importa come elaborarlo, ma è più importante decidere come costruire un programma di elaborazione e non con quali mezzi.
Se dal capitolo precedente abbiamo esaminato le opzioni per formare un documento XML, il compito dell'applicazione server è l'opposto: analizzare i documenti XML. Di seguito è una parte del programma che analizza un documento xml:
proceduraTthread1.DataParser (Sender: Tobject); var // dichiara gli oggetti DOMElement r, FNode: IXMLDOMElement; Str, nome file: String; parm: String; // dichiarazione di soclass e CoDocXML, CoDocXSL, CoDocResult: CoDomDocument; // Oggetto XMLDomDocument XMLDoc, XSLDoc, ResultDoc: DomDocument; // HttpStr: String; - una variabile globale contenente la stringa di richiesta HTTP Inizio XMLDoc: \u003d coDocXML.Create; XMLDoc.LoadXML (HttpStr); // ottiene l'indirizzo dell'elemento radice r: \u003d Doc.Get_documentElement; // ottiene il valore dell'elemento FNode: \u003d r.SelectSingleNode ("// TypeDocument"); // ottieni il valore dell'attributo id \u003d "Order" FileName: \u003d FNode.GetAttibute ("id"); // e formando il nome file Order.xsl FileName: \u003d FileName + ". Xsl"; // crea il documento XSLDoc XSLDoc: \u003d coDocXSL.Create; XSLDoc.LoadXML (FileName); // crea il documento XMLDoc ResultDoc: \u003d coDocResult.Create; // imposta la modalità di elaborazione sincrona ResultDoc.Set_async (false); // imposta il controllo di analisi ResultDoc.validateOnParse: \u003d true; // parsing XMLDoc using XSL template XMLDoc.transformNodeToObject (XSLDoc, ResultDoc); // alla variabile Str viene assegnato un valore di testo // del documento risultante. Str: \u003d ResultDoc.text; // trova elemento FNode: \u003d r.SelectSingleNode ("// InvoiceNumber"); // e ottieni il valore dell'elemento parm: \u003d FNode.text; // chiude la richiesta di accesso Query.Close; Query.Text: \u003d Str; // assegnazione del valore del parametro Query.Params.AsString: \u003d parm; // esegue la richiesta Query.ExecSQL; fine;Il punto culminante dell'analisi risiede nell'uso di un modello XSL, formato individualmente per ogni tipo di documento. Il risultato dell'analisi è una stringa di query SQL. Successivamente, l'esecuzione della stringa di query SQL generata apporterà le necessarie modifiche ai dati nel DBMS.
Il vantaggio dell'utilizzo dell'analisi attraverso un modello è anche che si ottiene una sorta di flessibilità dei dati e si ottiene la completa indipendenza dell'algoritmo dal codice del programma. Di seguito è riportato il testo del modello XSL utilizzato per elaborare un documento ORDER:
Spiegando l'esempio sopra, va notato che l'uso di una coppia di tag è di natura formale, dal momento che dopo l'analisi, il documento XML risultante deve contenere formalmente almeno un nodo. Il metodo ResultDoc.text assegna il valore di testo del ResultDoc ottenuto durante l'analisi del documento XML. In questo caso, il valore è tutto ciò che è circondato da una coppia di tag e, ad es. la query SQL che abbiamo generato.
Un'altra caratteristica della scrittura del programma dovrebbe essere notato la possibilità di utilizzare il parametro SQL : num. L'utilizzo del parametro semplifica il testo del modello xsl. La definizione del valore degli elementi corrispondenti dei nodi del documento XML è determinata inizialmente dalla selezione con il nome del nodo corrispondente, ad esempio:
XSL in breve
XSL è un acronimo derivato da eXtensible Stylesheet Language, un linguaggio di formattazione per fogli di stile (dati XML). Come puoi vedere dall'intestazione, eXtensible Stylesheet Language (XSL) viene utilizzato per formattare i dati XML. Per definizione, il W3C XSL è composto da due parti:
- XSLT - Trasformazione XSL. Il linguaggio utilizzato per trasformare o formattare (trasformare) i documenti XML. Pertanto, con l'aiuto di XSLT, possiamo ottenere diversi tagli di un insieme di dati e forme di presentazione dei dati.
- Elementi di formattazione. Questi elementi includono tutti gli elementi tipografici dei dati, dopo averli elaborati con XSL. Utilizzato solo per generare pagine HTML.
Con l'aiuto di XSLT, possiamo selezionare i dati di cui abbiamo bisogno da un file XML e disporli in una forma per la presentazione all'utente. Ad esempio, nel nostro caso, abbiamo trasformato i dati XML sotto forma di una query SQL. L'utilizzo classico di XSL è solitamente la formattazione dei dati sotto forma di pagine HTML o, più raramente, sotto forma di file RTF.
Il file XSL descrive un modello, in base al quale verrà eseguita la trasformazione dei dati XML. Ritornando ai template xsl, si possono distinguere in XSLT i seguenti elementi (direttive):
Direttive XSL | descrizione |
---|---|
xsl: apply-templates | Una direttiva che indica l'uso di modelli corrispondenti per l'attributo select \u003d "nome modello" |
xsl: attributo | crea un albero degli attributi e lo aggiunge all'elemento di output, nome parametro \u003d "nome attributo", lo spazio dei nomi è un URI dello spazio dei nomi (prefisso dello spazio dei nomi) |
xsl: call-template | chiama un modello, nome attributo \u003d "URI al modello" |
xsl: scegli xsl: quando xsl: altrimenti |
selezione per condizione xsl: quando expr \u003d "valutazione dell'espressione sullo script", language \u003d "language-name" test \u003d "espressione valutata" |
xsl: comment | genera un commento nel documento di output |
xsl: copia xsl: copia di |
copia il nodo corrente nell'origine di output o inserisce un frammento di documento nel nodo dove l'attributo di selezione \u003d "nome nodo di origine" |
xsl: elemento | crea un elemento di output per nome, nome attributo \u003d "nome elemento", spazio dei nomi \u003d "riferimento allo spazio dei nomi uri" |
xsl: per-ciascuno | riapplica il modello a tutti i nodi dell'elenco dei nodi, l'attributo select specifica l'elenco dei nodi |
xsl: if | controllo delle condizioni, impostato dall'attributo test come espressione |
xsl: include | include modello esterno, attributo href \u003d "riferimento URI" |
xsl: output | specifica l'output, l'attributo del metodo può essere "xml", "html" o "text" |
xsl: param | specifica il valore dei parametri, nome attributo \u003d "nome parametro", seleziona \u003d "valore" |
xsl: elaborazione-istruzione | crea un'istruzione di elaborazione, nome attributo \u003d "nome istruzione di processo" |
xsl: sort | ordina set di nodi, attributi select \u003d "nome nodo", tipo di dati \u003d tipo di dati ("testo" | "numero" | Qname), ordine \u003d direzione ordinamento ("ascendente" | "discendente") |
xsl: foglio di stile | definisce un documento modello xsl, è l'elemento radice per XSLT |
xsl: template | definisce xsl-template, nome dell'attributo \u003d "prefisso URI al nome del modello", match \u003d "un'indicazione del nodo a cui è applicato il modello" |
xsl: testo | genera testo nel flusso di output, attributo disable-output-escaping \u003d "yes" o "no", indica la capacità di generare caratteri ESC |
xsl: valore di | inserisce il valore del nodo selezionato come testo, attributo select \u003d "pointer to node" da cui viene preso il valore |
xsl: variabile | specifica il valore dei limiti delle variabili, nome attributo \u003d "nome variabile", seleziona \u003d "calcolo del valore variabile" |
xsl: con-param | applica un parametro al modello, nome attributo \u003d "nome parametro", seleziona \u003d espressione per valutare il contesto corrente, valore predefinito "." |
Conclusione
Infine, va notato che l'utilizzo del parser XML standard msxml.dllnon è l'unico modo per analizzare e creare documenti XML. Ad esempio, per creare documenti XML in modo efficace, utilizzare i componenti TPageProdusere TableProduser... Tuttavia, questo articolo sottolinea solo l'ampiezza e l'applicabilità del modello DOM nella pratica.
L'autore ti sarà molto grato per il tuo feedback sulla pertinenza dell'argomento, del contenuto generale, dello stile di presentazione, nonché di tutti gli altri commenti che aiuteranno a migliorare ulteriormente la qualità della scrittura di una raccolta di articoli e del rilascio di un libro che tratta l'argomento del lato pratico dell'uso di documenti XML nell'e-commerce. Informazioni più dettagliate sul lato pratico dell'uso di documenti elettronici possono essere trovate sul sito dell'autore www.eDocs.al.ru Anche sul sito dell'autore si prevede di inserire i testi di partenza e gli esempi.
XML è sempre più utilizzato per memorizzare informazioni e scambiarle tra applicazioni e siti Web. Molte applicazioni utilizzano questo linguaggio come lingua di base per la memorizzazione dei dati, mentre altre lo utilizzano per esportare e importare dati XML. Quindi è tempo che gli sviluppatori pensino a come utilizzare i dati XML nelle proprie applicazioni.
In questo articolo, esamineremo il DOM (Document Object Model) XML e l'implementazione di XML DOM da parte di Microsoft.
XML DOM è un modello a oggetti che fornisce allo sviluppatore oggetti per il caricamento e l'elaborazione di file XML. Il modello a oggetti è costituito dai seguenti oggetti principali: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap e XMLDOMParseError. Ciascuno di questi oggetti (eccetto XMLDOMParseError) contiene proprietà e metodi che consentono di ottenere informazioni sull'oggetto, manipolare i valori e la struttura dell'oggetto e navigare nella struttura di un documento XML.
Diamo un'occhiata ai principali oggetti XML DOM e mostriamo alcuni esempi del loro utilizzo in Borland Delphi.
Utilizzo di XML DOM in Borland Delphi
Per utilizzare Microsoft XML DOM nelle applicazioni Delphi, è necessario collegare la libreria dei tipi appropriata al progetto. Per fare ciò, eseguiamo il comando Project | Importa libreria dei tipi e nella finestra di dialogo Importa libreria dei tipi, seleziona la libreria Microsoft XML versione 2.0 (Versione 2.0), che di solito si trova nel file Windows \\ System \\ MSXML.DLL
Dopo aver fatto clic sul pulsante Crea unità, verrà creato il modulo di interfaccia MSXML_TLB, che ci permetterà di utilizzare gli oggetti XML DOM: DOMDocument, XMLDocument, XMLHTTPRequest e numerosi altri, implementati nella libreria MSXML.DLL. Il riferimento al modulo MSXML_TLB deve essere nell'elenco Uses.
Dispositivo XML DOM
Il Document Object Model rappresenta un documento XML come una struttura ad albero di rami. Le API XML DOM consentono alle applicazioni di navigare nell'albero del documento e manipolarne i rami. Ogni ramo può avere un tipo specifico (DOMNodeType), in base al quale vengono determinati i rami padre e figlio. La maggior parte dei documenti XML contiene rami di tipo elemento, attributo e testo. Gli attributi sono un tipo speciale di ramo e non sono rami figlio. Gli attributi vengono manipolati utilizzando metodi speciali forniti dagli oggetti XML DOM.
Oltre a implementare le interfacce consigliate dal World Wide Web Consortium (W3C), Microsoft XML DOM contiene metodi che supportano XSL, modelli XSL, spazi dei nomi e tipi di dati. Ad esempio, il metodo SelectNodes consente di utilizzare la sintassi del pattern XSL per trovare rami in un contesto specifico e il metodo TransformNode supporta l'utilizzo di XSL per eseguire le trasformazioni.
Prova documento XML
Come documento XML di esempio, prendi una directory di CD-ROM musicale, che ha la seguente struttura:
Siamo ora pronti per iniziare a guardare il modello a oggetti XML DOM, iniziando con l'oggetto XMLDOMDocument.
Documento XML - Oggetto XMLDOMDocument
Lavorare con un documento XML inizia con il suo caricamento. Per fare ciò, utilizziamo il metodo Load, che ha un solo parametro che specifica l'URL del documento caricato. Quando si caricano file da un disco locale, viene specificato solo il nome file completo (in questo caso il protocollo file: /// può essere omesso). Se il documento XML è archiviato come stringa, utilizzare il metodo LoadXML per caricare quel documento.
La proprietà Async viene utilizzata per controllare la modalità di caricamento del documento (sincrono o asincrono). Per impostazione predefinita, questa proprietà è True, a indicare che il documento viene caricato in modo asincrono e il controllo viene restituito all'applicazione prima che il documento sia completamente caricato. In caso contrario, il documento viene caricato in modo sincrono e quindi è necessario controllare il valore della proprietà ReadyState per vedere se il documento è stato caricato o meno. È inoltre possibile creare un gestore eventi per l'evento OnReadyStateChange che assumerà il controllo quando il valore della proprietà ReadyState cambia.
Di seguito viene mostrato come caricare un documento XML utilizzando il metodo Load:
Utilizza ... MSXML_TLB ... procedura TForm1.Button1Click (Sender: TObject); var XMLDoc: IXMLDOMDocument; iniziare XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // // Qui è dove il codice // manipola il documento XML e le sue diramazioni // XMLDoc: \u003d Nil; fine;
Dopo che il documento è stato caricato, possiamo accedere alle sue proprietà. Pertanto, la proprietà NodeName conterrà il valore #document, la proprietà NodeTypeString conterrà il valore del documento e la proprietà URL conterrà il valore file: /// C: /DATA/DATA.xml.
Gestione degli errori
Di particolare interesse sono le proprietà associate all'elaborazione del documento durante il caricamento. Ad esempio, la proprietà ParseError restituisce un oggetto XMLDOMParseError contenente informazioni su un errore che si è verificato durante l'elaborazione del documento.
Per scrivere un gestore degli errori, puoi aggiungere il codice seguente:
Var XMLError: IXMLDOMParseError; ... XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); XMLError: \u003d XMLDoc.ParseError; Se XMLError.ErrorCode<> 0 Allora // // Qui gestiamo l'errore // Else Memo1.Lines.Add (XMLDoc.XML); ... XMLDoc: \u003d Nil;
Per vedere quali informazioni vengono restituite in caso di errore, modificare la seguente voce di directory:
rimuovere l'elemento di chiusura
Ora scriviamo il codice che restituisce i valori delle proprietà dell'oggetto XMLDOMParseError:
XMLError: \u003d XMLDoc.ParseError; Se XMLError.ErrorCode<> 0 Quindi con XMLError, Memo1.Lines inizia con Add ("File:" + URL); Aggiungi ("Codice:" + IntToStr (ErrorCode)); Aggiungi ("Errore:" + motivo); Aggiungi ("Testo:" + SrcText); Aggiungi ("Riga:" + IntToStr (Riga)); Aggiungi ("Posizione:" + IntToStr (LinePos)); end Else Memo1.Lines.Add (XMLDoc.XML); Fine;
ed eseguire la nostra applicazione. Di conseguenza, otteniamo le seguenti informazioni sull'errore.
Come puoi vedere dall'esempio precedente, le informazioni restituite dall'oggetto XMLDOMParseError sono sufficienti per localizzare l'errore e comprendere la causa del suo verificarsi.
Ora ripristineremo l'elemento di chiusura
Accesso all'albero dei documenti
Per accedere all'albero del documento, puoi ottenere l'elemento radice e quindi iterare sui suoi rami figli o trovare un ramo specifico. Nel primo caso, otteniamo l'elemento root tramite la proprietà DocumentElement, che restituisce un oggetto di tipo XMLDOMNode. Ecco come utilizzare la proprietà DocumentElement per ottenere il contenuto di ogni elemento figlio:
Nodo Var: IXMLDOMNode; Radice: IXMLDOMElement; I: numero intero; ... Root: \u003d XMLDoc.DocumentElement; Per I: \u003d 0 a Root.ChildNodes.Length-1 do Begin Node: \u003d Root.ChildNodes.Item [I]; Memo1.Lines.Add (Node.Text); Fine;
Per il nostro documento XML, otteniamo il testo seguente.
Se siamo interessati a un ramo specifico o un ramo sotto il primo ramo figlio, possiamo utilizzare il metodo NodeFromID o il metodo GetElementByTagName dell'oggetto XMLDOMDocument.
Il metodo NodeFromID richiede un identificatore univoco come definito nello schema XML o nella DTD (Document Type Definition) e restituisce un ramo con tale identificatore.
Il metodo GetElementByTagName richiede una stringa con un elemento specifico (tag) e restituisce tutti i rami con questo elemento. Ecco come utilizzare questo metodo per trovare tutti gli artisti nella nostra directory CD-ROM:
Nodi: IXMLDOMNodeList; Nodo: IXMLDOMNode; ... Nodi: \u003d XMLDoc.GetElementsByTagName ("ARTIST"); Per I: \u003d 0 a Nodes.Length-1 do Begin Node: \u003d Nodes.Item [I]; Memo1.Lines.Add (Node.Text); Fine;
Per il nostro documento XML, otterremo il testo seguente
Si noti che il metodo SelectNodes dell'oggetto XMLDOMNode fornisce un modo più flessibile per accedere ai rami del documento. Ma ne parleremo più avanti.
Ramo documento - Oggetto XMLDOMNode
L'oggetto XMLDOMNode rappresenta un ramo del documento. Abbiamo già riscontrato questo oggetto durante il recupero dell'elemento radice del documento:
Radice: \u003d XMLDoc.DocumentElement;
Per ottenere informazioni su un ramo di un documento XML, è possibile utilizzare le proprietà dell'oggetto XMLDOMNode (Tabella 1).
Per accedere ai dati archiviati in un ramo, è comune utilizzare la proprietà NodeValue (disponibile per attributi, rami di testo, commenti, istruzioni di elaborazione e sezioni CDATA) o la proprietà Text, che restituisce il contenuto di testo del ramo o la proprietà NodeTypedValue. Quest'ultimo, tuttavia, può essere utilizzato solo per rami con elementi dattiloscritti.
Navigazione nella struttura ad albero del documento
L'oggetto XMLDOMNode fornisce molti modi per navigare nella struttura ad albero del documento. Ad esempio, per accedere al ramo padre, utilizzare la proprietà ParentNode (tipo XMLDOMNode), accedere ai rami figlio tramite le proprietà ChildNodes (tipo XMLDOMNodeList), FirstChild e LastChild (tipo XMLDOMNode), ecc. La proprietà OwnerDocument restituisce un oggetto XMLDOMDocument che identifica il documento XML stesso. Le proprietà elencate sopra facilitano la navigazione nell'albero del documento.
Ora iteriamo su tutti i rami del documento XML:
Radice: \u003d XMLDoc.DocumentElement; Per I: \u003d 0 a Root.ChildNodes.Length-1 do Begin Node: \u003d Root.ChildNodes.Item [I]; If Node.HasChildNodes Then GetChilds (Node, 0); Fine;
Come notato sopra, i SelectNodes dell'oggetto XMLDOMNode forniscono un modo più flessibile per accedere ai rami del documento. Inoltre, esiste un metodo SelectSingleNode che restituisce solo il primo ramo del documento. Entrambi questi metodi consentono di definire modelli XSL per le ricerche nei rami.
Diamo un'occhiata al processo di utilizzo del metodo SelectNodes per recuperare tutti i rami che hanno un ramo CD e un ramo secondario PRICE:
Radice: \u003d XMLDoc.DocumentElement; Nodi: \u003d Root.SelectNodes ("CD / PRICE");
Tutti i rami secondari PRICE del ramo CD verranno inseriti nella raccolta Nodes. Torneremo un po 'più tardi a discutere dei modelli XSL.
Manipolazione dei rami figli
Per manipolare i rami figli, possiamo usare i metodi dell'oggetto XMLDOMNode (Tabella 2).
Per eliminare completamente il record relativo al primo disco, è necessario eseguire il codice seguente:
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // Recupera l'elemento radice Root: \u003d XMLDoc.DocumentElement; Nodo: \u003d Root; // Rimuove il primo ramo figlio Node.RemoveChild (Node.FirstChild);
Nota che in questo esempio stiamo eliminando il primo ramo figlio. Di seguito viene mostrato come rimuovere il primo elemento del primo ramo figlio:
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d False; XMLDoc.Load ("C: \\ DATA \\ DATA.xml"); // Recupera l'elemento radice Root: \u003d XMLDoc.DocumentElement; // e il primo ramo figlio Node: \u003d Root.FirstChild; // Rimuove il primo ramo figlio Node.RemoveChild (Node.FirstChild);
Nell'esempio precedente, non abbiamo eliminato il primo ramo
Ora aggiungiamo un nuovo ramo. Di seguito è riportato il codice che mostra come aggiungere una nuova voce CD-ROM musicale:
Var NewNode: IXMLDOMNode; Figlio: IXMLDOMNode; ... // Crea un nuovo ramo -
Il codice sopra mostra i seguenti passaggi per l'aggiunta di un nuovo ramo:
- Creazione di un nuovo ramo utilizzando il metodo CreateNode:
- creazione di un elemento utilizzando il metodo CreateNode;
- aggiunta di un elemento a un ramo utilizzando il metodo AppendChild;
- impostare il valore di un elemento tramite la proprietà Text;
- … Ripeti per tutti gli elementi.
- Aggiunta di un nuovo ramo al documento utilizzando il metodo AppendChild.
Ricorda che il metodo AppendChild aggiunge un ramo alla fine dell'albero. Per aggiungere un ramo a un punto specifico dell'albero, è necessario utilizzare il metodo InsertBefore.
Set di diramazioni: oggetto XMLDOMNodeList
L'oggetto XMLNodeList contiene un elenco di rami, che possono essere creati utilizzando i metodi SelectNodes o GetElementsByTagName e ottenuti anche dalla proprietà ChildNodes.
Abbiamo già discusso l'uso di questo oggetto nell'esempio fornito nella sezione "Navigazione nell'albero del documento". Qui forniremo anche alcuni commenti teorici.
Il numero di rami nell'elenco può essere ottenuto come valore della proprietà Length. I rami sono indicizzati da 0 a Lunghezza-1 e ogni singolo ramo è accessibile tramite l'elemento indicizzato corrispondente nell'array Item.
La navigazione nell'elenco dei rami può essere eseguita anche con il metodo NextNode, che restituisce il ramo successivo nell'elenco, o Nil se il ramo corrente è l'ultimo. Per tornare all'inizio dell'elenco, chiama il metodo Reset.
Crea e salva documenti
Quindi, abbiamo spiegato come aggiungere rami ed elementi a documenti XML esistenti. Ora creiamo un documento XML al volo. Prima di tutto, ricorda che un documento può essere caricato non solo da un URL, ma anche da una stringa normale. Di seguito viene mostrato come creare un elemento radice, che può quindi essere utilizzato per costruire dinamicamente il resto degli elementi (di cui abbiamo già parlato nella sezione "Manipolazione dei rami figli"):
Var XMLDoc: IXMLDOMDocument; Radice: IXMLDOMNode; Nodo: IXMLDOMNode; S: WideString; ... S: \u003d '
Dopo aver creato il documento XML, salvalo in un file utilizzando il metodo Save. Per esempio:
XMLDoc.Save ('C: \\ DATA \\ NEWCD.XML');
Oltre a salvare in un file, il metodo Save consente di salvare un documento XML in un nuovo oggetto XMLDOMDocument. In questo caso, il documento viene completamente elaborato e, di conseguenza, vengono verificate la sua struttura e sintassi. Ecco come salvare un documento su un altro oggetto:
Procedura TForm1.Button2Click (Sender: TObject); var XMLDoc2: IXMLDOMDocument; iniziare XMLDoc2: \u003d CoDOMDocument.Create; XMLDoc.Save (XMLDoc2); Memo2.Lines.Add (XMLDoc2.XML); ... XMLDoc2: \u003d Nil; fine;
In conclusione, il metodo Save consente anche di salvare il documento XML su altri oggetti COM che supportano le interfacce IStream, IPersistStream o IPersistStreamInit.
Utilizzo di modelli XSL
Discutendo il metodo SelectNodes dell'oggetto XMLDOMNode, abbiamo detto che fornisce un modo più flessibile per accedere ai rami del documento. La flessibilità è data dalla possibilità di specificare un modello XSL come criterio per la selezione dei rami. Tali modelli forniscono un potente meccanismo per trovare informazioni nei documenti XML. Ad esempio, per ottenere un elenco di tutti i titoli di CD-ROM musicali nella nostra directory, è possibile eseguire la seguente query:
Per scoprire quali dischi d'artista sono stati rilasciati negli USA, la richiesta è formata come segue:
Nodi: \u003d Root.SelectNodes ("CD / ARTIST");
Ecco come trovare la prima unità in una directory:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
e ultimo:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
Per trovare i dischi di Bob Dylan, puoi eseguire la seguente query:
Nodi: \u003d Root.SelectNodes ("CD [$ any $ ARTIST \u003d" Bob Dylan "] / TITLE");
e per ottenere un elenco di dischi creati dopo il 1985, eseguiamo la seguente query:
Nodi: \u003d Root.SelectNodes ("CD / TITLE");
Una discussione più dettagliata della sintassi XSL richiede una pubblicazione separata. Per incuriosire i lettori e incoraggiare ulteriori ricerche, fornirò solo un piccolo esempio del possibile utilizzo di XSL. Diciamo che dobbiamo convertire il nostro catalogo in una normale tabella HTML. Utilizzando i metodi tradizionali, dobbiamo iterare su tutti i rami dell'albero e per ogni elemento ricevuto formare i tag corrispondenti
Usando XSL, creiamo semplicemente un modello (o foglio di stile) che specifica cosa e come trasformare. Quindi inseriamo questo modello nel nostro catalogo e il gioco è fatto: abbiamo il testo del modello XSL che trasforma il catalogo in una tabella (Listato 2).
Il codice per sovrapporre un modello XSL sulla nostra directory è simile a questo:
Procedura TForm1.Button2Click (Sender: TObject); var XSLDoc: IXMLDOMDocument; iniziare XSLDoc: \u003d CoDOMDocument.Create; XSLDoc.Load ("C: \\ DATA \\ DATA.xsl"); Memo2.Text: \u003d XMLDoc.TransformNode (XSLDoc); XSLDoc: \u003d Nil; fine;
Concludendo la nostra discussione su XSL, va detto che attualmente questo linguaggio è attivamente utilizzato per la trasformazione tra vari documenti XML, così come per la formattazione dei documenti.
Conclusione
Per ovvie ragioni, è impossibile coprire tutti gli oggetti Microsoft XML DOM e fornire esempi del loro utilizzo in un articolo. Qui abbiamo appena toccato i problemi di base dell'utilizzo di XML DOM nelle applicazioni. tavolo 3 mostra tutti gli oggetti implementati nel Microsoft XML DOM.
ComputerPress 12 "2000