tecnología xml - · pdf filexml laboratorio de programacion 6 estructura de un...

Tecnología XML

Unidad: 3Laboratorio de Programación

Universidad Nacional de la Patagonia AustralUnidad Académica Río Gallegos

XML Laboratorio de Programacion 1

Indice

� DOM� Concepto� Características� Niveles� Estructura del documento� Tipo de nodos� Ventajas y desventajas� Acceso y manipulación de nodos

� Ejemplos


DOM

� DOM: Modelo de Objetos de Documento

� Origen en el Consorcio World Wide Web (W3C)

� Es una interfaz independiente de la plataforma y el lenguaje de programación que permite acceder y manipular dinámicamente el contenido, el estilo y la estructura de un documento.


Niveles DOM

� Existen 3 niveles de DOM:� Nivel 0: es una formalizacion del DOM HTML definido implicitamente por JavaScript.

� Nivel 1: permite acceder a todas las partes de un documento XML pero no a las DTD ni a las hojas de estilo.

� Nivel 2: permite acceso a las DTD, hojas de estilo y espacio de nombres.


Características DOM nivel 1

� Proporciona un modelo para el documento completo representándolo mediante un árbol.

� Cada nodo del árbol representa:� Una etiqueta (elemento)� o un texto encerrado por una etiqueta.

� Los nodos del árbol están relacionados mediante vínculos de tipo:� Padre,� hijo� y hermano.

� La estructura permite navegar desde un nodo cualquiera a otro.


DOM: funcionalidad

� El DOM permite:� Crear documentos.

� Navegar su estructura.

� Añadir, modificar o eliminar elementos y contenido, estableciendo relaciones entre los nodos.

� Cambiar el estilo y contenido de los nodos.


Estructura de un documento (1)

� Estructura generado por DOM para el siguiente documento XML:

<?xml version=“1.0”?>

<documento>

<carta/>

<contenido>Algun texto…</contenido>

</documento>

La raíz del árbol es el propio documento.La raíz posee, en este caso, dos nodossecundarios:- Un nodo de declaración de la versión.- Un nodo de elemento que es la raíz deldocumento.


Estructura de un documento (2)

� Documento XML:

� Representación DOM:

<catalogo>

<libro>

<autor>Deepak Chopra</autor>

<titulo>El sendero del

Mago</titulo>

<precio>30.000</precio>

</libro>

…

</catalogo>

catalogo

libro

autor titulo precio

Document

Root element(document element)

Element

Child Element


Como acceder a los nodos en el DOM

� Hay dos formas de acceder a un nodo en el DOM.1. Recorrer el árbol

� Se empiece en cualquier parte del árbol y se utilizan los métodos de la interfaz de nodo del DOM.

2. Acceder al nodo por el nombre� A través del método getElementsByTagName() se crea una lista de nodos (NodeList) de todos los elementos de documento del nombre que se pasa como parámetro. Este es el método que se usa sí se desea acceder a un elemento por su nombre.


DOM: tipos de nodos� Document. Representa el nodo de nivel superior del documento que

proporciona acceso a todos los nodos, incluido el raíz.� Node. Representa un nodo del documento XML. Todo en un documento puede

ser considerado un nodo. Esta interfaz contiene varios atributos generales apropiados para manipular cualquier tipo de nodo.

� Attr. Esta interfaz trata sobre los atributos XML de un nodo. La versión abreviada Attr se usa para evitar la confusión con un atributo.

� Element. Representa a un nodo elemento. Esta interfaz posee propiedades y métodos que sirven para tratar con los elementos y sus atributos XML.

� Text. Representa un nodo de texto. � Comment. Representa un nodo comentario� NodeList. Es un conjunto ordenado de nodos, al que se puede acceder por

medio de un índice, empezando por 0.� NameNodeMap. Es una colección de nodos a los que se puede acceder por

nombre. Los atributos de un elemento se almacenan como NadeNodeMap. � CharacterData. Es una interfaz que trata sobre los datos de caracteres o con

el texto de un documento.


DOM: ventajas y desventajas

� Ventajas:� Provee acceso aleatorio dentro de documentos XML.

� Más rápido.

� Ofrece una interfaz para recorrer el árbol.

� Implementa metodos para cambiar documentos XML en memoria.

� Desventajas:� Todo el documento en memoria.

� Puede consumir mucha memoria.

� Puede tardar más en arrancar.

� No recomendable con documentos XML grandes


DOM: implementación

� DOM se puede utilizar para cualquier lenguaje:

� PHP

� Perl

� Java

� C++

� Etc.

� Nos centramos en Java para introducir su forma de trabajar.

� Para presentar los ejemplos, recurriremos a una serie de paquetes básicos (incluiremos con el correspondiente import):� org.w3c.dom (la interfaz API de DOM para programar)

� javax.xml.parser (con las clases para compilar)


DOM: principal

� import javax.xml.parsers.*;import org.w3c.dom.*;

� public class HolaMundo {public static void main(String args[]) {

try {... Programa ...

} catch (Exception e) {e.printStackTrace(System.out);

}}

}


DOM: lectura archivo XML

� Crear una instancia del objeto DocumentBuilderFactory.� Crear un DOM Parser, llamando al objeto DocumentBuilder

� Es decir:DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance();

DocumentBuilder db = fact.newDocumentBuilder();

� El siguiente paso es cargar el archivo XML.

� Para leer este archivo añadir lo siguiente:Document doc = db.parse(“algun_archivo.xml”);

� Notas:� Document contiene el archivo XML como árbol

� El archivo XML debe estar el mismo directorio


DOM: mostrar un nodo

� El siguiente código busca el contenido del elemento root y lo imprime:Element root = document.getDocumentElement();

Node unNodo = root.getFirstChild();

System.out.println(unNodo.getNodeValue());

� La salida del programa es:

Hola Mundo!


DOM: métodos� Métodos Nodo:

� String getNodeName()� short getNodeType()� Document getOwnerDocument()� NodeList getChildNodes()� Node getFirstChild()� Node getLastChild()� Node getParentNode()� Node getNextSibling()� String getNodeVallue() ...

� Element extienden de Nodo y agregar:� String getTagName()� boolean hasAttribute(String name)� String getAttribute(String name)� NodeList getElementsByTagName(String name) ...

� Document extiende de Nodo y agrega:� Element getDocumentElement()� DocumentType getDoctype() ...

DOM:Acceso a los objetos

� Documento XML:

� Ejemplo de uso (mas comunes):� // Recupera el nodo raiz

Element root = doc.getDocumentElement();

// Recupera un nodo determinado con los hijos

NodeList puntos = root.getElementsByTagName(“punto");

// Recupera nodo hijo por indice

Element primerPunto = (Element) puntos.item(1);

// Lee un atributo

String x = primerPunto.getAttribute("x");

<puntos>

antes del primer punto

<punto x="9" y="81" />

<punto x="11" y="121" />



</puntos>


DOM:Manipular objetos Document

� Además de los métodos para acceder a los nodos, el API de DOM incluye métodos para crear y manipular documentos XML:

// Crear un nuevo documento XMLDocument doc = docBuilder.newDocument();

// Añade un elemento puntosElement root = doc.createElement(“puntos");doc.appendChild(root);

// Crear un elemento punto dependiente de puntos, con atributosElement punto = doc.createElement(“punto");punto.setAttribute("x", "9");punto.setAttribute("y", "81");root.appendChild(punto);


DOM:Manipular objetos Document (cont.)

� Métodos de Nodo:� void setNodeValue(String nodeValue)

� Node appendChild(Node newChild)

� Node insertBefore(Node newChild, Node refChild)

� Node removeChild(Node oldChild) ...

� Métodos de Element:� void setAttribute(String name, String value)

� void removeAttribute(String name) ...

� Métodos de Document:� Text createTextNode(String data)

� Comment createCommentNode(String data) ...


DOM:guardar documento XML

� Se importan los siguientes paquetes� El código siguiente genera un archivo XML:

import com.sun.org.apache.xml.serialize.OutputFormat;import com.sun.org.apache.xml.serialize.XMLSerializer;import com.sun.org.apache.xml.serialize.LineSeparator;...OutputFormat format = new OutputFormat((Document)core);format.setLineSeparator(LineSeparator.Windows);format.setIndenting(true);format.setLineWidth(0); format.setPreserveSpace(true);...XMLSerializer serializer = new XMLSerializer (

new FileOutputStream(“output.xml"), format);serializer.serialize(document);


Ejemplo (1)

� Documento XML:

� Código:import javax.xml.parsers.*;

import org.w3c.dom.*;

public class HolaMundo {

public static void main(String args[]) {

try {

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

Document documento = builder.parse("hola.xml");

Element raiz = documento.getDocumentElement();

Node nodoTexto = raiz.getFirstChild();

System.out.println(nodoTexto.getNodeValue());

} catch (Exception e) {

e.printStackTrace(System.out);

}

}

}

<?xml version="1.0"?>

<saludo>Hola Mundo!</saludo>


Ejemplo (2)

� Crear un documento XML desde DOMimport javax.xml.parsers.*;


import java.io.*;

import com.sun.org.apache.xml.internal.serialize.*;

class CrearDomXml {

public static void main(String[] args) {

try {

// Crear una instancia de DocumentBuilderFactory

DocumentBuilderFactory factory = DocumentBuilderFactory

.newInstance();

// Genera un DocumentBuilder

DocumentBuilder docBuilder = factory.newDocumentBuilder();

// Crea documento DOM en blanco

Document docXML = docBuilder.newDocument();

// Crea un elemento raiz

Element root = docXML.createElement("root");

// Agregar el elemento como raiz del arbol XML

docXML.appendChild(root);

// Crea un comentario

Comment comentario = docXML.createComment("Esto es un comentario...");

Ejemplo (2)…

// Agrega el elemento comentario al nodo raiz

root.appendChild(comentario);

// Crea un elemento hijo

Element childElement = docXML.createElement("Hijo");

// Agrega un atributo

childElement.setAttribute("Atributo1", "Valor del atributo 1");

root.appendChild(childElement);

//guarda el documento XML en disco

OutputFormat format = new OutputFormat(docXML);

format.setLineSeparator(LineSeparator.Windows);

format.setIndenting(true);

format.setLineWidth(0);

format.setPreserveSpace(true);

XMLSerializer serializer = new XMLSerializer (new

FileOutputStream("prueba.xml"), format);

serializer.serialize(docXML);

} catch (Exception e){

System.out.println(e.getMessage());

}

}

}

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

<root>



<Hijo Atributo1="Valor del atributo1"/>

</root>


Ejemplo (3)

� Retorna todos los elementos de un documento XML

import javax.xml.parsers.*;


public class ConsultasDomXml {

static public void main(String[] arg) {

try {

String xmlFile = "ejemplo.xml";

// Create a factory

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

// Use the factory to create a builder

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse(xmlFile);

// Get a list of all elements in the document

NodeList list = doc.getElementsByTagName("*");

System.out.println("XML Elements: “+list.getLength());

for (int i=0; i<list.getLength(); i++) {

// Get element

Element element = (Element)list.item(i);

System.out.println(element.getNodeName());

}

} catch (Exception ex) {

System.out.println(ex);

}

}

}


Consultas…


Próxima clase

� JSP&Servlet

� Ejemplos

� Ejercitación

tecnología xml - · pdf filexml laboratorio de programacion 6 estructura de un...

Documents