XML correspon a les sigles de “llenguatge de marques extensible”. Té diversos avantatges respecte a altres formes d'emmagatzemar informació.
- És extensible: Després de ser dissenyat i posat en producció, és possible estendre XML amb l'addició de noves etiquetes, de manera que es pugui continuar utilitzant sense cap complicació.
- L'analitzador és un component estàndard, no cal crear un analitzador específic per a cada versió del llenguatge XML. Això possibilita l'ús de qualsevol dels analitzadors disponibles. D'aquesta manera s'eviten bugs i s'accelera el desenvolupament d'aplicacions.
- Si un tercer decideix utilitzar un document creat en XML, és senzill entendre'n l'estructura i processar-la. Millora la compatibilitat entre aplicacions. Podem comunicar aplicacions de diferents plataformes, sense que importi l'origen de les dades; és a dir, podríem tenir una aplicació en Linux amb una base de dades Postgres i comunicar-la amb una altra aplicació en Windows i base de dades MS-SQL Server.
- Transformem dades en informació, ja que se'ls afegeix un significat concret i les associem a un context, amb la qual cosa tenim flexibilitat per estructurar documents.
Lectura de tipus SAX.
public class LecturaXMLSAX {
public static void main(String argv[]) {
try {
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
File stocks = new File("stocks.xml");
DefaultHandler handler = new DefaultHandler() {
boolean bSimbol = false;
boolean bPreu = false;
boolean bQuantitat = false;
@Override
public void startElement(String uri, String nomLocal, String nomElement,Attributes atributs) throws SAXException {
System.out.println("Inici d'element :" + nomElement);
if (nomElement.equalsIgnoreCase("simbol")) {
bSimbol = true;
}
if (nomElement.equalsIgnoreCase("preu")) {
bPreu = true;
}
if (nomElement.equalsIgnoreCase("quantitat")) {
bQuantitat = true;
}
}
@Override
public void endElement(String uri, String localName,
String nomElement) throws SAXException {
System.out.println("Final d'element :" + nomElement);
}
@Override
public void characters(char ch[], int start, int length) throws SAXException {
if (bSimbol) {
System.out.println("Simbol: " + new String(ch, start, length));
bSimbol = false;
}
if (bPreu) {
System.out.println("Preu: " + new String(ch, start, length));
bPreu = false;
}
if (bQuantitat) {
System.out.println("Quantitat: " + new String(ch, start, length));
bQuantitat = false;
}
}
};
saxParser.parse(stocks, handler);
} catch (Exception e) {
e.printStackTrace();
}
}
}
En SAX, els esdeveniments s'activen quan l'XML s'està analitzant. Quan l'analitzador analitza l'XML i es troba amb una etiqueta d'inici, desencadena l'esdeveniment startElement. De manera similar, quan es compleix el final de l'etiqueta, s'acciona endElement. L'ús d'un analitzador SAX implica que necessitem gestionar aquests esdeveniments i donar sentit a les dades obtingudes amb cada esdeveniment.
Lectura XML per nodes (DOM)
public class LecturaXMLDOM {
public static void main(String args[]) {
try {
File stocks = new File("stocks.xml");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(stocks);
doc.getDocumentElement().normalize();
System.out.println("raiz " + doc.getDocumentElement().getNodeName());
NodeList nodes = doc.getElementsByTagName("stock");
System.out.println("==========================");
for (int i = 0; i < nodes.getLength(); i++) {
Node node = nodes.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
System.out.println("Stock símbolo: " + obtenerContenido("simbol", element));
System.out.println("Stock precio: " + obtenerContenido("preu", element));
System.out.println("Stock cantidad: " + obtenerContenido("quantitat", element));
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static String obtenerContenido(String etiqueta, Element element) {
NodeList nodes = element.getElementsByTagName(etiqueta).item(0).getChildNodes();
Node node = (Node) nodes.item(0);
return node.getNodeValue();
}
}
En DOM, no hi ha cap esdeveniment provocat. Tot l'XML s'analitza i es genera i es retorna un arbre DOM (dels nodes de l'XML). Una vegada analitzat, l'usuari pot navegar per l'arbre per accedir a les diferents dades prèviament imbebudes en els diferents nodes de l'XML.
En general, DOM és més fàcil d'utilitzar, però té la sobrecarrega d'analitzar tot l'XML abans de començar a utilitzar-lo.
Creació d'un document XML
public class CreacioEscripturaXML {
public static void main(String argv[]) {
try {
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
Document nodeDocument = docBuilder.newDocument();
Element elementArrel = nodeDocument.createElement("empresa");
nodeDocument.appendChild(elementArrel);
Element treballador = nodeDocument.createElement("treballador");
elementArrel.appendChild(treballador);
treballador.setAttribute("id", "1");
Element nom = nodeDocument.createElement("nom");
nom.appendChild(nodeDocument.createTextNode("sergi"));
treballador.appendChild(nom);
Element cognom = nodeDocument.createElement("cognom");
cognom.appendChild(nodeDocument.createTextNode("grau"));
treballador.appendChild(cognom);
Element sou = nodeDocument.createElement("salari");
sou.appendChild(nodeDocument.createTextNode("100000"));
treballador.appendChild(sou);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource origen = new DOMSource(nodeDocument);
StreamResult sortidaXML = new StreamResult(new File("empresa.xml"));
transformer.transform(origen, sortidaXML);
System.out.println("Desat!");
} catch (ParserConfigurationException pce) {
pce.printStackTrace();
} catch (TransformerException tfe) {
tfe.printStackTrace();
}
}
}