JAVA parsing di documenti XML

Un parser XML è un modulo software che si colloca tra l'applicazione e il documento XML. Esso permette all'applicazione di accedere al contenuto e alla struttura del documento XML. Esistono due tipi di parser: validanti e non validanti. I primi, oltre a controllare se un documento è ben-formato, cioè che ogni elemento sia racchiuso tra due tag (uno di apertura e uno di chiusura), controlla pure se esso è un documento XML valido, cioè se è fedele alle regole definite nella sua DTD. I parser non validanti, invece, si preoccupano solo di vedere se un documento è ben formato. Negli esempi di questo articolo useremo Xerces, un parser validante free tra i più robusti e affidabili, scaricabile dal sito della Apache all'indirizzo http://xml.apache.org/dist/xerces-j/.
Ci sono due modi per interfacciare un parser con una applicazione: usando un'interfaccia object-based oppure usando un interfaccia event-based. Con l'approccio object-based, il parser costruisce esplicitamente in memoria un albero che contiene tutti gli elementi del documento XML. Con l'approccio event-based, invece, il parser genera un evento ogni qual volta incontra, durante la lettura del documento XML, un elemento, un attributo, o del testo; ci sono eventi per i tag di apertura e di chiusura, per gli attributi, per il testo, per le entità e così via. Xerces implementa entrambe i tipi di parser mediante le classi DOMParser e SAXParser entrambi contenute nel package org.apache.xerces.parsers. Vediamo adesso come si costruiscono questi due tipi di parser e come si fa il parsing di un documento XML. Consideriamo un semplice documento XML, ad esempio per rappresentare l'insieme degli impiegati di una ditta. Chiamiamo questo documento impiegati.xml:

<?xml version="1.0"?> <!DOCTYPE impiegati SYSTEM impiegati.dtd>         <impiegati>                 <impiegato id="M.R">                         <nome>Mario Rossi</nome>                         <email>mrossi@foo.com</email>                 </impiegato>                 <impiegato id="F.B">                         <nome>Filippo Bianchi</nome>                         <email>fbaldi@foo.com</email>                 </impiegato>                 <impiegato id="A.V">                         <nome>Alice Verdi</nome>                         <email>averdi@foo.com</email>                         <url href="http://www.foo.com/~averdi/" />                 </impiegato>         </impiegati>

Il relativo DTD è il seguente:

<!ELEMENT impiegati (impiegato)*> <!ELEMENT impiegato (nome, email, url?)> <!ATTLIST impiegato id CDATA #REQUIRED> <!ELEMENT nome (#PCDATA)> <!ELEMENT email (#PCDATA)> <!ELEMENT url EMPTY> <!ATTLIST url href CDATA #REQUIRED>

I due listati sotto mostrano come si creano i parser per leggere il documento XML descritto in precedenza.

Creazione di un parser DOM

import org.apache.xerces.parsers.DOMParser; import org.w3c.dom.Document; import org.xml.sax.SAXException; import java.io.IOException; ... String xmlFile = "file:///impiegati.xml"; DOMParser parser = new DOMParser(); try {         parser.parse(xmlFile); } catch (SAXException se) { se.printStackTrace(); } catch (IOException ioe) { ioe.printStackTrace(); } Document document = parser.getDocument();

Le righe più interessanti di questo frammento di codice sono:
DOMParser parser = new DOMParser();
dove viene creata un'istanza della classe DOMParser.
parser.parse(xmlFile);
dove avviene il parsing del documento XML.
Questa istruzione è all'interno di un blocco try-catch per catturare le eccezioni che il parser potrebbe generarare. Un caso potrebbe essere, ad esempio, la lettura di un documento XML non ben formato.
Document document = parser.getDocument();
Infine viene creata un'istanza di Document che è un'interfaccia che permette la rappresentazione in memoria dell'intero documento XML.

Creazione di un parser SAX
Vediamo adesso come si costruisce un parser di tipo SAX.

import org.apache.xerces.parsers.SAXParser; import org.xml.sax.Parser; import org.xml.sax.ParserFactory; import org.xml.sax.SAXException; import java.io.IOException; ... String xmlFile = "file:///impiegati.xml"; String parserClass = "org.apache.xerces.parsers.SAXParser"; Parser parser = ParserFactory.makeParser(parserClass); try {         parser.parse(xmlFile); } catch(SAXException se) { se.printStackTrace(); } catch (IOException ioe) { ioe.printStackTrace(); }

Qui il meccanismo è simile all'esempio precedente, notiamo però alcune differenze:
Parser parser = ParserFactory.makeParser(parserClass);
Qui il parser viene creato tramite il metodo makeParser della classe ParserFactory, al quale viene passato come argomento il nome della classe parser che si vuole utilizzare, nel nostro caso appunto org.apache.xerces.parsers.SAXParser.
La scelta di usare la classe DOMParser anziché SAXParser dipende dal tipo di applicazione che lo utilizza. Normalmente l'utilizzo di un DOMParser, e più in generale di un parser object-based, è più appropriato in applicazioni dove è richiesta una manipolazione di documenti XML, come ad esempio browser, editor, processori XSL e così via. Mentre l'utilizzo della classe SAXParser o di altri parser event-based, è ideale nei casi in cui l'applicazione non richiede la memorizzazione dei dati in XML ma in un altro formato, come ad esempio un'applicazione per importare documenti XML in un database; qui il formato dell'applicazione è la struttura del database e non quella del documento XML.