Ispirandomi al W3C (World Wide Web Consortium), che è l’organo internazionale che ha elaborato una serie di nuovi standard (XML, DOM, ecc.), posso affermare che l’XML (eXtensible Markup Language) è un metodo per memorizzare dati strutturati in modalità testuale. Per dati strutturati s’intende ad esempio fogli elettronici, parametri di configurazione, transazioni finanziarie, disegni tecnici, ecc…
XML è un insieme di regole, linee guida e convenzioni utilizzate per disegnare template in formato testuale i quali produrranno files semplici da generare e leggere, che non sono ambigui e che evitano trappole comuni quali mancanza di estensibilità, di supporto per l’internazionalizzazione e dipendenza dalla piattaforma.
In maniera simile all’HTML, l’XML fa uso di tags (parole racchiuse tra parentesi angolari ‘<>’) ed attributi (con la sintassi nome = “valore”), ma mentre l’HTML specifica il significato di ciascun tag o attributo, l’XML utilizza i tag solo per delimitare segmenti di dati, lasciando l’interpretazione degli stessi all’applicazione che li va a leggere. In altre parole, se compare una “<p>” in un file XML, non è detto che essa rappresenti un paragrafo.
Ciò che descrive cosa siano i tag e gli attributi è la specifica ufficiale dell’XML (consultabile all’indirizzo http://www.w3.org/TR/1998/REC-xml-19980210), ma attorno all’XML sta crescendo un insieme di moduli opzionali che forniscono collezioni di tag ed attributi per compiti specifici.
Ad esempio esiste l’XSL (eXtensible Stylesheet Language), linguaggio avanzato per la costruzione di fogli di stile, il DOM (Document Object Model) , un insieme di funzioni per la manipolazione di file XML da un linguaggio di programmazione (ad esempio C++ o Java).
Per quanto riguarda la storia di XML, il suo sviluppo partì nel 1996 divenendo poi uno standard del W3C nel febbraio 1998. L’antenato dell’XML è l’SGML (sviluppato negli anni ’80) che è stato uno standard ISO dal 1986, ed era usato moltissimo per progetti di larga documentazione. I disegnatori di XML presero semplicemente le parti migliori di SGML e produssero qualcosa che era potente quanto l’SGML ma più regolare e semplice da utilizzare.
Per finire, l’XML è freeware, cioè si può creare un pezzo di codice XML senza pagare niente a nessuno.
 

Che cos’è DOM
Il DOM (Document Object Model) è un’interfaccia indipendente dalla piattaforma e dal linguaggio per documenti HTML ed XML (documentazione all’indirizzo http://www.w3.org/DOM). Essa definisce la struttura logica dei documenti e la modalità con cui un documento può essere accesso e manipolato. Con DOM possono essere costruiti documenti, navigarne la struttura, aggiungere o togliere elementi ed il loro contenuto. Tutto ciò che si può trovare in un documento HTML o XML può essere accesso, cambiato, cancellato o aggiunto utilizzando DOM, a parte qualche rara eccezione.
DOM è stato creato per essere utilizzato con qualsiasi linguaggio di programmazione, tanto che la specifica delle interfacce di DOM è stata descritta utilizzando IDL per CORBA 2.2.
In DOM, i documenti hanno una struttura logica che somiglia molto ad un albero; per essere più precisi è una foresta che contiene uno o più alberi. La rappresentazione ad albero non è l’unica possibile, ma la proprietà di isomorfismo strutturale che contraddistingue DOM dice che due implementazioni usate per creare la rappresentazione dello stesso documento portano allo stesso modello di struttura, con gli stessi oggetti e le stesse relazioni.
In un modello ad oggetti, DOM identifica:
 

• le interfacce e gli oggetti usati per rappresentare e manipolare documenti
• la semantica di queste interfacce ed oggetti
• le relazioni tra queste interfacce ed oggetti

Il DOM attualmente è costituito da due parti, il DOM Core ed il DOM HTML. La prima parte fornisce le funzionalità utilizzate per i documenti XML e serve anche da base per la seconda parte. DOM è utilizzato correttamente se vengono implementate tutte le fondamentali interfacce nel Core ed almeno una delle interfacce presenti nell’HTML DOM.

Java to XML
A questo punto resta da descrivere in che modo Java ed XML interagiscono, cioè come posso effettuare il parsing di un documento XML utilizzando classi Java e viceversa come da un insieme di dati posso costruire un file XML sfruttando classi Java.
Partiamo col considerare quest’ultimo caso, ipotizzando di avere un set di dati (magari provenienti da un form HTML) e con questi vogliamo costruire un file XML che li contenga. 
La prima cosa da fare è generare le classi Java che rappresentano gli elementi (quelli racchiusi fra ‘<>’) a partire da una DTD costruita in precedenza. La DTD (Document Type Definition) non è altro che un documento in cui vengono definiti gli elementi e gli attributi del file XML, e soprattutto in che modo devono apparire all’interno del documento stesso. La DTD definisce quindi una grammatica in cui ogni produzione (regola) descrive il comportamento di un singolo elemento. Per definire una DTD è necessaria una sintassi che è contenuta nello stesso documento di specifica dell’XML.
Detto questo, per generare le classi Java di cui sopra, si può utilizzare un tool della Oracle scritto in Java denominato ClassGenerator (http://technet.oracle.com/software/download.htm), il quale prende in input la DTD e restituisce in output un insieme di classi Java, ciascuna rappresentante un’entità (elemento o attributo) della DTD.
Una volta ottenute queste classi, si deve scrivere un applicazione Java che istanzia queste classi nello stesso ordine delle regole grammaticali presenti nella DTD. Cioè, se una produzione della DTD è simile alla seguente:
 

element ::= (el1 | el2)*

basterà creare un pezzo di codice simile a 
 

Element element = new Element(); 
El1 el1 = new El1(); 
element.addNode(el1); 

L’elemento radice della DTD (quello più in alto nella gerarchia), possiede inoltre i metodi per validare il documento appena costruito e scriverlo su uno stream di output (quindi anche un file).
Un documento XML valido è un documento che rispetta le regole sintattiche presenti nella DTD, mentre un documento XML può essere anche ben formato, cioè rispetta una serie di regole lessicali proprie dell’XML (ad esempio ad ogni tag aperto ne deve corrispondere uno chiuso), ma non fa riferimento a nessuna DTD.
La sequenza di operazioni descritta può essere rappresentata graficamente in questo modo:
 
 

Fig. 1: Funzionamento del ClassGenerator per Java

 
 
 
 

XML to Java
Passiamo ora a considerare il procedimento inverso, cioè come è possibile effettuare il parsing di un file XML in modo da estrarre il valore racchiuso tra ciascun tag presente nel documento. L’idea è quella di utilizzare DOM per navigare all’interno del documento, individuando i tag attraverso il loro nome. 
Per far questo proviamo ad analizzare il seguente pezzo di codice:

com.sun.xml.tree.XmlDocument document; 
org.w3c.dom.NamedNodeMap nodeMap = null; 
String name = null; 
 

try{ 
 // Create an XML document from an InputSource 
 // This one is created from the string data representing the XML document 
 // The boolean value is needed to validate the document

InputSource is = new InputSource(); 
 is.setCharacterStream(new StringReader(data)); 
 document = XmlDocument.createXmlDocument(is, false);

 // Creation of a TreeWalker to visit the tree representing the XML document 
 com.sun.xml.tree.TreeWalker tv = new com.sun.xml.tree.TreeWalker(document);

 // A node of this tree 
org.w3c.dom.Node node = null;

 // While the tree is completely visited, take the next node 
 while ((node = tv.getNext()) != null) 
 { 
  /* The name node */ 
  name = node.getNodeName();

  // Retrieve the information from the name node

  if (name.equals("node_name")) 
  { 
     some operations… 
  } 
 } 
} 
catch (Exception e) 
{ 
 System.out.println("Exception while parsing data..."); 
 e.printStackTrace(); 
}

InputSource is = new InputSource(); 
 is.setCharacterStream(new StringReader(data)); 
 document = XmlDocument.createXmlDocument(is, false);

Il metodo statico createXmlDocument della classe XmlDocument prende come parametri un oggetto InputSource, il quale contiene il documento XML in formato testo, e una costante booleana che indica se il documento creato deve essere validato o meno. Se il flag è posto a false non viene effettuata la validazione ma viene comunque controllata la correttezza (cioè se il documento è ben formato).
Il secondo passo dell’elaborazione consiste nel creare un’istanza della classe TreeWalker.
 

// Creation of a TreeWalker to visit the tree representing the XML document 
 com.sun.xml.tree.TreeWalker tv = new com.sun.xml.tree.TreeWalker(document);

 
org.w3c.dom.Node node = null;

 // While the tree is completely visited, take the next node 
 while ((node = tv.getNext()) != null) 
 { 
  /* The name node */ 
  name = node.getNodeName();

  // Retrieve the information from the name node

  if (name.equals("node_name")) 
  { 
     // some operations on data element… 
     operation(node.getNodeValue()); 
  }
}

Conclusioni
XML è uno standard verso il quale si orienteranno sicuramente la maggior parte delle applicazioni future. Per questo motivo anche Java cercherà nel prossimo futuro di fornire strumenti sempre più evoluti per il trattamento delle informazioni in formato XML e nei formati ad esso correlati, quali ad esempio CDF (Channel Definition Format) o RDF (Resource Definition Format). Attualmente sia la SUN Microsystems che la Oracle che l’IBM hanno prodotto una serie di classi Java per poter effettuare il parsing di un documento XML o per poterne costruire la struttura ad albero carratteristica di DOM.