XML en sus siglas en español “lenguaje de marcas extensible”. Tiene varias ventajas respecto a otras formas de almacenar información.
- Es extensible: Después de diseñado y puesto en producción, es posible extender XML con la adición de nuevas etiquetas, de modo que se pueda continuar utilizando sin complicación ninguna.
- El analizador es un componente estándar, no es necesario crear un analizador específico para cada versión de lenguaje XML. Esto posibilita el empleo de cualquiera de los analizadores disponibles. De esta manera se evitan bugs y se acelera el desarrollo de aplicaciones.
- Si un tercero decide usar un documento creado en XML, es sencillo entender su estructura y procesarla. Mejora la compatibilidad entre aplicaciones. Podemos comunicar aplicaciones de distintas plataformas, sin que importe el origen de los datos, es decir, podríamos tener una aplicación en Linux con una base de datos Postgres y comunicarla con otra aplicación en Windows y Base de Datos MS-SQL Server.
- Transformamos datos en información, pues se le añade un significado concreto y los asociamos a un contexto, con lo cual tenemos flexibilidad para estructurar documentos.
Lectura tipo 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, los eventos se activan cuando el XML está siendo analizado. Cuando el analizador analiza el XML, y se encuentra con una etiqueta de inicio desencadena el evento startElement. De modo similar, cuando el final de la etiqueta se cumple se acciona endElement. El uso de un analizador SAX implica que necesitamos manejar estos eventos y dar sentido a los datos obtenidos con cada evento.
Lectura XML por nodos (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 hay ningún evento provocado. Todo el XML se analiza y un árbol DOM (de los nodos del XML) se genera y se devuelve. Una vez analizado. el usuario puede navegar por el árbol para acceder a los diferentes datos previamente embebidos en los distintos nodos del XML.
En general, DOM es más fácil de usar, pero tiene una sobrecarga de analizar el XML entero antes de empezar a usarlo.
Creación de un documento 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();
}
}
}
|
Cap comentari :
Publica un comentari a l'entrada