Programación B

Programación Orientada a Objetos

Ingeniería en Informática
Universidad FASTA

Ing. Luis Buffoni

Lic. Claudio Gea

Java: Trabajando con archivos XML

 El lenguaje XML
Características
 Es un lenguaje simple, basado en texto, independiente de la plataforma,
diseñado para almacenar y transmitir datos en un formato de texto plano
 Su nombre deriva de eXtensible Markup Language
 XML es un lenguaje: responde a una gramática que define su estructura
 Es un lenguaje de marcas: Al igual que HTML, es un lenguaje basado en tags
 Pero, a diferencia de HTML, esos tags no están predefinidos: Es posible
definir nuestros propios tags, razón por la cuál, decimos que XML es
extensible

 Los tags de un documento XML son auto-descriptivos

 Es una Recomendación de la W3C para almacenar y transmitir
información; se ha constituido como un estándar para el intercambio de
información estructurada entre diferentes plataformas

Universidad FASTA – Programación B 2

 El lenguaje XML
Características
 Es una tecnología sencilla y muy potente
 Extensible: Se pueden definir nuevas etiquetas
 Estructurado: se pueden modelar datos a cualquier nivel de complejidad: su
definición está en un DTD (Document Type Definition) o XSD (XML Schema
Definition)
 Validable: Puede validarse su estructura frente a un DTD / XSD, en su defecto,
determinar que está bien formado
 Fácil de aprender y usar
 Sigue reglas de generación sencillas pero bien definidas que las hacen fácilmente procesables
 XML puede ser leído tanto por máquinas como por personas.

 XML utiliza el conjunto de caracteres UNICODE, lo que facilita la internacionalización

 Facilita encontrar lo que se está buscando con exactitud y agilidad.

 Permite el intercambio de información sobre Internet y sobre cualquier medio

Universidad FASTA – Programación B 3

 El lenguaje XML
Documentos validados / Bien formados

 Un documento es válido si está configurado conforme a una DTD o XSD

 Los documentos pueden ser validados fácilmente por parsers

 Si no se dispone de DTD, se puede calificar el documento como bien

formado si cumple las siguientes condiciones:
 Tienen un único elemento raíz
 Todas las etiquetas tienen una etiqueta de cierre
 Los elementos están correctamente anidados
 Todos los valores de los atributos están entrecomillados

 Los navegadores son muy tolerantes con la calidad de etiquetado de los

documentos HTML, pudiendo procesarlo/mostrarlo aún cuando no esté bien
formado. En cambio, un XML mal formado no puede considerarse como tal.

 Es fácil saber si un documento XML es válido, o, en ausencia de DTD, si

está bien formado.
Universidad FASTA – Programación B 4
 El lenguaje XML
Desventajas

Sintaxis redundante
 Los archivos XML contiene una gran cantidad de términos repetitivos
 Siendo un lenguaje descriptivo, en texto plano, los archivos XML
son voluminosos y los costos de almacenamiento y transmisión se
incrementan

Universidad FASTA – Programación B 5

 El lenguaje XML
Documentos validados / Bien formados
Prologo

Clientes.xml

Cuerpo

cli.dtd

Universidad FASTA – Programación B 6

 XML en Java
Parsers
Los XML Parsers son analizadores de archivos XML que permiten acceder, navegar
y modificar el contenido de documentos XML:
Parser Características

DOM Parser Analiza un XML cargando el contenido completo del documento y creando su árbol jerárquico
completo en la memoria

SAX Parser Analiza un documento XML sobre triggers basados en eventos. No carga el documento completo
en la memoria.

JDOM Parser Similar a DOM, pero más sencillo

StAX Parser Similar a SAX, pero más eficiente

JAXP Capa de alto nivel para utilizar parsers DOM, SAX y StAX

XPath Parser Analiza un XML en base a expresiones. Soporta XSLT

DOM4J Parser Librería Java para analizar XML, XPath, y XSLT usando Collections de Java. Soporta DOM, SAX
y JAXP.
Universidad FASTA – Programación B 7
 Documentos XML
Técnicas de Parseo

Árbol en memoria
El documento entero es leído y traído a memoria con estructura de
árbol, permitiendo acceso a cualquier parte del documento de
forma aleatoria

Streaming (procesamiento de eventos)

El parser lee el documento y dispara eventos conforme va
encontrando entidades XML.
Dos tipos:
-Push parsers: El parser tiene el control e informa al cliente
-Pull parsers: El cliente controla al parser y este avanza hacia el
siguiente elemento del documento cuando se le indica

Universidad FASTA – Programación B 8

 Documentos XML
Parsers

Universidad FASTA – Programación B 9

 Documentos XML
Parsers

Universidad FASTA – Programación B 10

 XML en Java
Parser DOM
 DOM - Document Object Model
 Los parsers DOM implementan una interface para manipular la estructura de un
XML.
 Se obtiene un árbol en memoria que contiene todos los elementos del XML
 Usarlo cuando...

-Se necesita conocer acerca de la estructura del documento

-Se requiere mover partes de un documento XML (por ejemplo, para ordenar
ciertos elementos)
-Es necesario usar la información de un documento XML más de una vez

 Desventaja:

 No es óptimo para analizar archivos muy grandes

Universidad FASTA – Programación B 11

 XML en Java
Parser DOM
Documento DOM → Estructura jerárquica de Nodos de distinto tipo, algunos
de los cuales pueden tener hijos y otros no:
– Document: Representa al documento XML entero. Es un árbol de nodos
– Element: Bloques que componen el XML
– Attr: Representa un atributo de un elemento
– Text: El contenido actual de un elemento o atributo (no tiene hijos)
– Otros tipos de elementos:
• Comment,
• DocumentType,
• DocumentFragment,
• EntityReference,
• ProcessingInstruction,
• CdataSection,
• Notation

Universidad FASTA – Programación B 12

 XML en Java
Parser DOM
Métodos más usuales
• Document.getDocumentElement(): Element Retorna el elemento raíz del árbol
• Element.getChildNodes(): NodeList Retorna todos los hijos de un nodo
• Node.getFirstChild(): Node Retorna el primer hijo de un nodo dado.
• Node.getLastChild(): Node Retorna él último hijo de un nodo dado
• Node.getNextSibling(): Node Retorna el siguiente hermano de un nodo dado
• Node.getPreviousSibling(): Node Retorna el hermano anterior de un nodo dado
• Element.getAttribute(attrName): String Retorna el valor del atributo attrName
• Document.getElementsByTagName("student"):NodeList Retorna todos los
nodos con tagname “student”

Universidad FASTA – Programación B 13

 XML en Java
Parser DOM
final DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
Carga del
final DocumentBuilder docBuilder = dbfac.newDocumentBuilder(); Documento y
final Document doc =
docBuilder.parse(this.getClass().getResourceAsStream(file)); Obtención del
Element nodoRaiz = doc.getDocumentElement(); Nodo Raíz
final NodeList children = e.getChildNodes(); //e es de tipo Element
for (int i = 0; i < children.getLength(); i++) { Navegando nodos
final Node n = children.item(i);
if (n.getNodeType() == Node.ELEMENT_NODE) {
System.out.print(n.getNodeName() + ": " + (!n.hasChildNodes() ? "" : n.getTextContent()));
}
}

<?xml version = "1.0" encoding = "UTF-8"?>

<cars>
<supercars company = “Mercedes Benz">
Modificando valores de los nodos
<carname type = "F1">Ferrari 101</carname> Node
<carname type = "sports">Ferrari 202</carname> supercar=doc.getElementsByTagName("supercars").item(0);
</supercars> // modificar atributo
<luxurycars company = "Benteley"> NamedNodeMap attr = supercar.getAttributes();
<carname>Benteley 1</carname> Node nodeAttr = attr.getNamedItem("company");
<carname>Benteley 2</carname> nodeAttr.setTextContent(“Ferrari");
<carname>Benteley 3</carname>
</luxurycars>
</cars>

Universidad FASTA – Programación B 14

 XML en Java
Parser DOM
Node supercars = doc.getElementsByTagName("supercars").item(0);
Element carname = doc.createElement("carname");
Attr attrType = doc.createAttribute("type");
attrType.setValue("coleccion"); Agregando y borrando nodos y
carname.setAttributeNode(attrType);
carname.appendChild(doc.createTextNode("Ferrari 125S")); grabando en archivo XML
supercars.appendChild(carname);

. . . .

Node cars = doc.getFirstChild();

NodeList childNodes = cars.getChildNodes();
for(int i = 0; i < childNodes.getLength(); i++) {
Node node = childNodes.item(i);
if("luxurycars".equals(node.getNodeName()))
cars.removeChild(node);
}
TransformerFactory transformerFactory =
TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(new File("cars.xml"));
transformer.transform(source, result);

Universidad FASTA – Programación B 15

 XML en Java
Ejercicio utilizando DOM parser

Universidad FASTA – Programación B 16