Xml

Contenidos
XML
DTD
Schema
XML Parsing
SAX API
DOM API
XSLT

2

¿Qué es XML?
eXtensible Mark-up Language
Es un metalenguaje que permite diseñar
otros lenguajes (WML, MathML, XHTML,..).
Cualquiera puede desarrollar su propio
lenguaje de etiquetas adecuado al tipo de
aplicación que más le convenga.
En realidad hay muchas tecnologías basadas
en XML (XPath, XLink, XPointer, XSL, ...).
XML 1.0 Specification
http://www.w3.org/TR/REC-xml 3

HTML y XML
SGML (Standard Generalized Markup
Language).
HTML es una aplicación de SGML.
XML es subconjunto más fácil de usar de
SGML.
XHTML es una aplicación de XML.

4

XML describe estructura y
semántica
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE comedor SYSTEM "comedor.dtd">
<comedor>
<fabricante>Muebles Carcoma</fabricante>
<mesa tipo="redonda" madera="arce">
<precio>€400</precio>
</mesa>
<silla madera="arce">
<cantidad>2</cantidad>
<calidad>excelente</calidad>
<cojin incluido="sí">
<color>azul</color>
</cojin>
<precio>€200</precio>
</silla>
</comedor>
5

HTML describe formato
<html>
<head><title>Comedor</title></head>
<body>
<h1>Comedor</h1>
Fabricante: Muebles Carcoma
<ul>
<li>Mesa redonda de madera de arce</li>
<li>Silla de madera de haya</li>
<li>Librería de madera de roble</li>
</ul>
</body>
</html>

6

Ventajas XML
Una de las mayores utilidades de XML es poder
etiquetar los datos con su significado (self-
describing data).
Permite estructurar la información.
Obtenemos una mayor eficiencia y optimización en
el tratamiento automático de la información.
XML es la base de la nueva generación de
aplicaciones web Siendo muy utilizado para el
intercambio de datos.

7

Usos XML
Sitios web
Permite separar contenido y presentación
Comunicación
Intercambio de datos entre servicios web
Configuración de aplicaciones
Descriptores de despliegue en servidores J2EE
Herramienta Apache ANT
Frameworks de desarrollo

8

Componentes documento XML
Los documentos XML constan de:
Instrucciones de procesamiento (processing
instructions – PI)
Declaraciones de tipo de documento
Comentarios
Elementos
Referencias a entidades
Secciones CDATA

9

Instrucciones de
procesamiento

Las PI son instrucciones para el procesador
del documento XML.
Siempre hay al menos una PI, que
pertenece al prólogo del documento:
<?xml version="1.0" encoding="ISO 8859-
="ISO-
<saludo>
Hola, mundo!
</saludo>

10

Comentarios en XML
Los comentarios no se procesan.
Tienen la siguiente sintaxis:


11

Elementos y atributos en XML
Los elementos son los que aportan estructura semántica
al documento.
Se delimitan por etiquetas de apertura, cierre y etiquetas
sin elementos interiores (etiquetas vacías).
Las etiquetas de apertura y las vacías suelen venir
acompañadas de atributos, que parametrizan el
elemento.
El valor de los atributos siempre se encierra entre
comillas, dobles o simples.
<saludo tipo="coloquial">Hola</saludo>

12

Elementos vs. Atributos
Demasiados atributos hacen que los documentos
XML sean difíciles de leer.
No es correcto estructurar un documento mediante
atributos:
<CLIENTE NIF="44777333"
NOMBRE="Jose García“
FECHA="Octubre 15, 2008“
CODIGO=“008“
ARTICULO="Tomates“
PRECIO="1.25" />
13

Elementos vs. Atributos (cont)
<CLIENTE NIF="44777333">
<NOMBRE>José García</NOMBRE>
<FECHA>Octubre 15, 2008</FECHA>
<PEDIDO>
<ARTICULO CODIGO="008">
<DESCRIPCION>Tomates</DESCRIPCION>
<PRECIO>1.25</PRECIO>
</ARTICULO>
</PEDIDO>
</CLIENTE>

14

Referencias a entidades
Las referencias a entidades sirven para
insertar un determinado contenido definido
previamente.

En la DTD:
<!ENTITY Empresa "Muebles Carcoma">

En el documento XML:
<pie>Creado por &Empresa;</pie>

15

Códigos de escape

Existen 5 referencias a entidades
predefinidas:
& es el carácter &
< es el carácter <
> es el carácter >
' es el carácter '
" es el caracter "
&perc; es el caracter %

16

Secciones CDATA
Las secciones CDATA (character data)
contienen texto que no debe ser procesado.
Se tratan como una secuencia de caracteres sin
estructura.

<![CDATA[
![CDATA[<saludo>Hola, mundo!</saludo>]]>
![CDATA[

<![CDATA[<
![CDATA[<abc>(123)<def>(456)<ghi>(789)]]>
![CDATA[<

17

Gramáticas en XML

La gramática que restringe los elementos
válidos dentro de un nuevo derivado de XML
puede expresarse en forma de:
DTD (Document Type Definitions)
Esquemas XML

18

Document Type Definitions
(DTDs)
Especifican la estructura y sintaxis de un documento
XML.

gruposlab.dtd

<!ELEMENT grupo (estudiante)*>
<!ELEMENT estudiante (#PCDATA)>
<!ATTLIST estudiante
dni CDATA #REQUIRED
tutor CDATA #IMPLIED>

19

Document Type Definitions
(cont)
"gruposlab.dtd
gruposlab.dtd">
<!DOCTYPE mensaje SYSTEM "gruposlab.dtd">
<grupo>
<estudiante dni="44777333">
José García
</estudiante>
<estudiante dni="44888444">
Juan González
</estudiante>
<estudiante dni="44999555" tutor="33666222">
Antonio Martínez
</estudiante>
</grupo>
20

XML Schemas
Los DTD no son muy potentes para definir
gramáticas.
Otra forma de hacerlo es con Esquemas XML
basados en el propio XML y que soporta más
tipos de datos.

21

Ejemplo Schema
DTD :
<!ELEMENT factura (cliente, pedido)*>
<!ELEMENT cliente (#PCDATA)>
<!ELEMENT pedido (#PCDATA)>
<!ATTLIST factura numero CDATA #REQUIRED>
<!ATTLIST factura fecha CDATA #REQUIRED>

XML Schema:
<xsd:element name="factura">
<xsd:complexType mixed="true">
<xsd:sequence>
<xsd:element name="cliente" type="xsd:string"/>
<xsd:element name="pedido" type="xsd:string"/>
</xsd:sequence>
<xsd:attribute name="numero" type="xsd:decimal" use="required"/>
<xsd:attribute name="fecha" type="xsd:date" use="required"/>
</xsd:complexType>
</xsd:element>

22

Ejemplo Schema (cont)
Documento XML:

<?xml version="1.0"?>
<factura numero="110" fecha="2008-10-20">
<cliente>44555777</cliente>
<pedido>33308</pedido>
</factura>

23

XML Schema (I)
Definir un esquema:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
…
</xsd:schema>

Elemento simple:
<xsd:element name="nombre" type="xsd:string" />

Atributo:
<xsd:atribute name="edad" type="xsd:decimal" />
<xsd:atribute name="codigo" type="xsd:decimal" use="required" />
use="required"

Grupo de atributos:
<xsd:attributeGroup name="Articulo">
<xsd:attribute name="cantidad" type="xsd:decimal" />
<xsd:attribute name="descripcion" type="xsd:string" />
<xsd:attribute name="precio" type="xsd:decimal" />
</xsd:attributeGroup> 24

XML Schema (II)
Elemento complejo:
<xsd:element name="amigo">
name="amigo">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="apellidos" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element
xsd:element>
</xsd:element>

<xsd:complexType name="Persona">
name="Persona">
<xsd:sequence>
<xsd:element name="apellidos" type="xsd:string" />
</xsd:sequence>
</xsd:complexType
xsd:complexType>
</xsd:complexType>
name="amigo" type="Persona"
<xsd:element name="amigo" type="Persona" />
25

XML Schema (III)
Podemos restringir el número de ocurrencias en la
secuencia de elementos que forman un tipo complejo
usando:
minOccurs
Define el mínimo de ocurrencias para un elemento:
<xsd:element name="cliente" type="xsd:string" minOccurs="1" />
minOccurs="1"

maxOccurs
Define el máximo de ocurrencias para un elemento:
<xsd:element name="cliente" type="xsd:string" maxOccurs="5" />
maxOccurs="5"

<xsd:element name="cliente" type="xsd:string" minOccurs="1"
maxOccurs="unbounded />
unbounded"
unbounded
26

XML Schema (IV)
Tipos de datos:
xsd:boolean
Tipo lógico (true o false).
xsd:date
Fecha en formato “aaaa-mm-dd”.
xsd:decimal
Valor numérico (de cualquier tipo).
xsd:string
Cadena de caracteres.
xsd:time
Hora en formato “hh:mm:ss.sss”.
xsd:short , xsd:integer , xsd:long
Tipos de datos enteros compatibles con JAVA.
xsd:float , xsd:double
Tipos de datos flotantes compatibles con JAVA. 27

XML Schema (V)
Tipos de datos propios:
<xsd:simpleType name="Cuenta">
<xsd:restriction base="xsd:string">
<xsd:pattern value=“d{4}-d{4}-d{2}-d{10}” />
</xsd:restriction>
</xsd:simpleType>

Simbolos para crear patrones:
. cualquier carácter.
d cualquier dígito.
D cualquier carácter que no sea dígito.
s cualquier espacio en blanco.
S cualquier carácter que no sea espacio en blanco.
[0-9] conjunto de valores de 0-9.
[A-Za-z] conjunto de valores de A-Z o de a-z.
28

XML Schema (VI)
x* cero o más ocurrencias de x, donde x puede ser
cualquier carácter o patrón.
x? cero o una ocurrencia.
x+ una o más ocurrencias.
x{4} cuatro x seguidas, donde x puede ser cualquier
carácter o patrón.
x{4,} al menos cuatro seguidas.
x{4,9} entre cuatro y nueve seguidas.

Especificar la precisión y la escala:
<xsd:precision value="6" />
value=
El contenido del elemento debe tener como mucho 6 dígitos,
contando la parte entera y la decimal.
<xsd:scale value="3" />
value=
El contenido debe tener como máximo 3 dígitos decimales. 29

XML Schema (VII)
Especificar un intervalo de valores:
<xsd:maxInclusive value="3500" />
value="3500"
El valor debe ser menor o igual a 3500.
<xsd:maxExclusive value="3500" />
value="3500"
El valor debe ser menor a 3500.
<xsd:minInclusive value="3500" />
value="3500"
El valor debe ser mayor o igual a 3500.
<xsd:minExclusive value="3500" />
value="3500"
El valor debe ser mayor a 3500.

Especificar la longitud del contenido:
<xsd:length value="15" />
value="15"
El contenido del elemento debe tener exactamente 15 caracteres.
<xsd:maxLength value="15" />
value="15"
El contenido debe tener máximo 15 caracteres.
<xsd:minLength value="15" />
value="15"
30
El contenido debe tener mínimo 15 caracteres.

XML Schema (VIII)
Predefinir el contenido de un elemento:
<xsd:element name="Empresa" type="xsd:string" fixed="Gua S.A" />
fixed="Gua S.A"
="
Si el elemento está presente en el docuemento, debe ser el
mismo que el que indica el atributo fixed. Y si el atributo no está
presente, el procesador ofrecerá el valor.
<xsd:element name="Empresa" type="xsd:string" default="Gua S.A" />
default="Gua S.A"
="
Si el elemento no aparece en el documento, el procesador se
encargará de ofrecer el valor contenido en el atributo default.
default y fixed son mutuamente exclusivos.
Valor predefinido de un atributo:
<xsd:atribute name="Genero" type="xsd:string" use="fixed"
use="fixed
fixed"
value="Mujer"
value="Mujer" />
<xsd:atribute name="Genero" type="xsd:string" use="default"
default"
use="default
value="Mujer"
value="Mujer" />

Sucede lo mismo que para los elementos. 31

XML Schema (IX)
Indicar un conjunto de valores aceptables:
<xsd:element name="Pais">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="ES" />
<xsd:enumeration value="UK" />
<xsd:enumeration value="FR" />
</xsd:restriction>
</xsd:simpleType>
</xsd:element>

Hacer referencia a un esquema XML:
<?xml version="1.0" ?>
<raiz xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.dominio.es/schemas/miXMLS
chema.xsd" />

Por ejemplo:
<pedido xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
pedido
xsi:noNamespaceSchemaLocation="pedido.xsd />
pedido.xsd"
pedido.xsd
32

XML bien formado y/o XML
válido
Hay dos tipos de documentos XML:
Bien formados: son aquellos que cumplen las
reglas sintácticas de XML.
Válidos: son aquellos que, además de estar
bien formados, siguen las reglas de una
gramática (definida en un DTD o XML Schema).

33

Reglas para que un
documento esté bien formado
Para que un documento esté bien formado:
Debe tener un prólogo.
Debe tener una etiqueta raíz.
Las etiquetas se hallan correctamente anidadas.
Se usan caracteres válidos y bien aplicados.
Los valores de los atributos vienen encerrados entre
comillas.

34

Reglas para que un
documento sea válido
Para que un documento sea válido debe declarar el
DTD o XML Schema contra el cual debe validarse.
Para validar contra DTD se hace mediante DOCTYPE,
pudiendo ser los DTD públicos o de sistema:
<!DOCTYPE saludo SYSTEM "saludo.dtd">
<!DOCTYPE saludo PUBLIC "-//Saludos//DTD Lenguaje de
saludos//ES" "http://www.rae.es/dtds/saludo.dtd">
También se puede insertar el DTD entero en ese punto, en
lugar de referenciar al fichero.

Para validar contra XML Schema se hace incluyendo la
referencia en el documento XML:
<saludo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.rae.es/schemas/
saludo.xsd" /> 35

Lenguajes basados en XML
Chemical Markup Language (CML)
Mathematical Markup Language (MathML)
Channel Definition Format (CDF)
Synchronized Multimedia Integration Language (SMIL)
eXtensible HyperText Markup Language (XHTML)
Scalable Vector Graphics (SVG)
Web Services (SOAP y WSDL)
Voice Markup Language (VoiceML)
Wireless Markup Language (WML)
Geography Markup Language (GML)

36

Herramientas de XML
Editores
XML Spy, www.xmlspy.com
XML Copy Editor, xml-copy-editor.sourceforge.net
Vex, vex.sourceforge.net
XML Parsers (Parseadores)
Lee un documento XML.
Verifica que XML está bien formado.
Verifican que XML es válido.
Expat, escrito en C, expat.sourceforge.net
Lark, escrito en Java, www.textuality.com/Lark
Xerces, proyecto de apache, xerces.apache.org
XML Validators (Validadores)
Verifican que XML es válido
XML.com's Validator basado en Lark (xml.com)
37

Ejercicios (I)
Ejercicio propuesto: Definir un documento
cartelera.xml que soporte la información referente a
la cartelera de uno o varios cines.
Crear un XML Schema para poder validarlo.
La información soportada debe ser la siguiente:
Cine
Nombre, dirección y población
Película
Título, director y actores
Sesión
Hora

38

Ejercicios (II)
Ejercicio propuesto: Definir un documento
clinica.xml que soporte la información referente a las
citas que debe atender cada médico.
Crear un XML Schema para poder validarlo.
La información soportada debe ser la siguiente:
Clínica
Fecha
Doctor
Nombre y especialidad
Paciente
Cita, NSS y nombre.

39

¿Por qué usar XML?
Un documento XML puede ser fácilmente
procesado y sus datos manipulados.
Existen APIs para procesar esos documentos en
Java, C, C++, Perl…
JAXP API de Java para procesamiento XML.
XML define datos portables al igual que Java define
código portable.

40

XML Parsing
Documento
XML

Aplicación
Parser XML
XML

XML DTD
XML Schema

Parsing: Proceso de analizar una secuencia de símbolos a fin
de determinar su estructura gramatical con respecto a una
gramática formal dada.
Un parseador (parser) es una aplicación o herramienta que lleva
a cabo esta tarea.
El parseo transforma una entrada de texto en una estructura de
datos (usualmente un árbol) que es apropiada para ser
procesada. 41

XML Parsing (cont)
SAX
Define un interfaz dirigido por eventos (event-driven) para
el procesamiento de un documento XML.
Definido por David Megginson:
http://www.megginson.com/SAX

DOM
Provee una representación de un documento XML en
forma de un árbol.
Carga todo el documento XML en memoria.
http://www.w3.org/DOM

42

Simple API for XML: SAX
Analizador o parser SAX:
Detecta cuándo empieza y termina un elemento, el documento o
un conjunto de caracteres, etc.. (genera eventos).
Gestiona espacios de nombres.
Comprueba que el documento está bien formado.
Las aplicaciones necesitan implementar un manejador/es
para los eventos notificados.
SAX lee secuencialmente de principio a fin, sin cargar todo el
documento en memoria.
Ventaja: eficiencia en cuanto al tiempo y la memoria
empleados en el análisis.
Desventaja: no disponemos de la estructura en árbol de los
documentos.
43

¿Cómo funciona SAX?
XML Document SAX Objects

<?xml version=“1.0”?> Parser startDocument

<addressbook> Parser startElement
<person>

<name>Jose Garcia</name> Parser startElement & characters

<email>joseg@empresa.es</email> Parser startElement & characters

</person> Parser endElement

<person> Parser startElement
<name>Juan Gonzalez</name> Parser startElement & characters

<email>juang@empresa.es</email> Parser startElement & characters

</person> Parser endElement
</addressbook> Parser endElement & endDocument
44

JAXP SAX
La clase SAXParserFactory que permite crear
una instancia de un objeto SAXParser.
SAXParserFactory factory =
SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();

El objeto SAXParser tiene un método parse(archivo,
manejador) que inicia el procesamiento.
Es necesario crear un objeto DefaultHandler,
denominado manejador de contenido, el cual dispone de
una serie de métodos que son invocados cuando
analizador detecta determinados eventos al leer
documento.
45

DefaultHandler
void startDocument()
Recibe notificación de comienzo de documento.
void endDocument()
Recibe notificación de final de documento.
void startElement(String uri, String localName, String name,
Attributes attributes)
Recibe notificación de comienzo de elemento.
void endElement(String uri, String localName, String name)
Recibe notificación de final de elemento.
void characters(char[] ch, int start, int length)
Recibe notificación de caracteres encontrados dentro de un
elemento.
void error(SAXParserException e)
Recibe notificación de error recuperable. 46

Ejemplo SAX Parsing I
<libro>
<capitulo>
<numero>Uno</numero>
<titulo>Introducción</titulo>
</capitulo>
<capitulo>
<numero>Dos</numero>
<titulo>Servlets</titulo>
</capitulo>
<capitulo>
<numero>Tres</numero>
<titulo>JSP</titulo>
</capitulo>
</libro>

47

Ejemplo SAX Parsing II
import java.io.File;
import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class ParserSAX extends DefaultHandler {

// Constantes de validación contra XMLSchema
private final String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
private final String W3C_XML_SCHEMA =
"http://www.w3.org/2001/XMLSchema";

protected boolean pNumero;
protected boolean pTitulo;
protected StringBuilder cNumero;
protected StringBuilder cTitulo;

.. Constructor y métodos startElement, characters, endElement ..
} 48

Ejemplo SAX Parsing III
Constructor..

public ParserSAX(File archivo) {

SAXParserFactory factory = SAXParserFactory.newInstance();

try {

SAXParser parser = factory.newSAXParser();
parser.parse(archivo, this);

} catch (ParserConfigurationException e) {
System.out.println(e.getMessage());
} catch (SAXException e) {
} catch (IOException e) {
}

}

49

Ejemplo SAX Parsing IV
Método startElement..

public void startElement(String uri, String localName,
String name, Attributes attributes) {

if (name.equalsIgnoreCase("capitulo")) {

cNumero = null;
cTitulo = null;
}
else if (name.equalsIgnoreCase("numero")) {

pNumero = true;
cNumero = new StringBuilder();
}
else if (name.equalsIgnoreCase("titulo")) {

pTitulo = true;
cTitulo = new StringBuilder();
}

}
50

Ejemplo SAX Parsing V

Método characters..

public void characters(char[] ch, int start, int length) {

if (pNumero)
cNumero.append(ch, start, length);

if (pTitulo)
cTitulo.append(ch, start, length);

}

51

Ejemplo SAX Parsing VI
Método endElement..

public void endElement(String uri, String localName,
String name) {

if (name.equalsIgnoreCase("capitulo")) {

System.out.println(name);

if (cNumero != null)
System.out.println(cNumero.toString());

if (cTitulo != null)
System.out.println(cTitulo.toString());
}
else if (name.equalsIgnoreCase("numero")) {

pNumero = false;
}
else if (name.equalsIgnoreCase("titulo")) {

pTitulo = false;
}
52
}

Ejemplo SAX Parsing VII
Aplicación..

public class Principal {

public static void main(String[] args) {

File archivo = new File("libro.xml");

System.out.println("Parser SAX");
System.out.println("----------");

new ParserSAX(archivo);

}

}

53

Validación SAX contra DTD
// Obtener referencia al SAXFactory

// Habilitar validación
factory.setValidating(true);

// Crear una nueva instancia del parseador

// Parsear el documento contenido en el archivo

// Método para controlar un error SAX
public void error(SAXParseException e) {
}
54

Validación SAX contra
XMLSchema
// Obtener referencia al SAXFactory

// Habilitar validación y espacio de nombres
factory.setNamespaceAware(true);

// Crear una nueva instancia del parseador

// Configurar parametros de validación contra XMLSchema
parser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

// Parsear el documento contenido en el archivo

// Método para controlar un error SAX
public void error(SAXParseException e) throws SAXException {
throw new SAXException("XML no válido.");
} 55

Ejercicios
Ejercicio propuesto: realizar una aplicación que
analice (realizar parseo) del documento cartelera.xml
utilizando SAX Parsing.
Aplicar el XML Schema creado para poder validar el
documento cartelera.xml.
Crear el conjunto de clases y colecciones de objetos
necesarias para procesar la información del documento.
La aplicación debe recorrer las diferentes colecciones de
objetos generadas y mostrar los atributos de los elementos
contenidos en ellas.

56

W3C Document Object Model
(DOM)
Los documentos XML son tratados como un árbol de
nodos.
Cada elemento es un “nodo”.
Los elementos hijos y el texto contenido dentro de un
elemento son subnodos.
Los atributos de un elemento también son contemplados
como subnodos.
El documento se carga totalmente en memoria como una
estructura en árbol.
Ventaja: es fácil acceder a datos en función de la jerarquía
de los elementos, así como modificar el contenido de los
documentos e incluso crearlos desde cero.
Desventaja: el coste en tiempo y memoria que conlleva
57
construir el árbol.

Documento XML como un
árbol de nodos

<DOCUMENT>
<GREETING>Hello from XML</GREETING>
<MESSAGE>
Welcome to Programing XML in Java.
</MESSAGE>
</DOCUMENT>

58

Documento XML como un
árbol de nodos (cont)

59

W3C XML DOM Objects
Document – El objeto documento.
ProcessingInstruction – Una instrucción de procesamiento.
Element – un elemento XML.
Attribute – un attributo.
Text – texto contenido en un elemento o atributo.
CDATAsection – sección CDATA.
EntityReference – Referencia a una entidad.
Comment – Contenido de un comentario de XML.
DocumentType – Referencia al elemento DOCTYPE.
DocumentFragment – Referencia a un fragmento del documento.
Notation – Contenedor de una anotación.

60

JAXP DOM
Para conseguir una instancia del analizador DOM a
través de JAXP usamos las clases DocumentBuilder
y DocumentBuilderFactory:

DocumentBuilderFactory fact =
DocumentBuilderFactory.newInstance();
// Construir nueva instancia
DocumentBuilder parser = fact.newDocumentBuilder();

El método parse(…) analiza el fichero entrada y
devuelve un objeto Document que representa al
documento parseado.

Document documento = parser.parse(archivo);
61

Objetos relacionados con
Nodos
Node
Representa un nodo en el árbol de un documento.
NodeList
Representa una lista de objetos nodo.
NamedNodeMap
Permite la interacción y el acceso por nombre a una
colección de atributos.

62

Métodos del objecto
Document
Attr createAttribute(String name)
Crea un atributo con el nombre dado.
Element createElement(String tagName)
Crea un elemento con el nombre de etiqueta dado.
Text createTextNode(String data)
Crea un nodo de texto.
Element getDocumentElement()
Devuelve el elemento raíz el documento.
Element getElementById(String elementId)
Devuelve el elemento identificado por el id.
NodeList getElementsByTagName(String tagName)
Devuelve una lista de elementos identificados por el nombre de
etiqueta dado. 63

Métodos del interfaz Node
NamedNodeMap getAttributes()
Devuelve lista de atributos en un nodo.
Node getFirstChild()
Devuelve el primer hijo de este nodo.
Node getLastChild()
Devuelve el último hijo de este nodo.
NodeList getChildNodes()
Devuelve todos los hijos de este nodo.
Node getParentNode()
Devuelve nodo padre del nodo actual.
short getNodeType()
Devuelve tipo de nodo actual.
String getNodeName()
Devuelve nombre nodo.
String getNodeValue()
Devuelve contenido nodo. 64

Métodos del interfaz NodeList
y NamedNodeMap
NodeList
int getLength()
Devuelve número de nodos en lista.
Node item(int index)
Devuelve el nodo identificado por index en una colección.

NamedNodeMap
int getLength()
Devuelve número de nodos en lista.
Node getNamedItem(String name)
Recupera un nodo dado su nombre.
Node item(int index)
Devuelve el nodo identificado por index en una colección. 65

Ejemplo DOM I
<peliculas>
<pelicula codigo="01">
<titulo>Matrix</titulo>
<director>Hermanos Wachowski</director>
<actores>Keanu Reeves, Laurence Fishburne</actores>
</pelicula>
<titulo>El club de la lucha</titulo>
<director>David Fincher</director>
<actores>Brad Pitt, Edward Norton</actores>
</pelicula>
<titulo>Trainspotting</titulo>
<director>Danny Boyle</director>
<actores>Ewan McGregor</actores>
</pelicula>
</peliculas>
66

Ejemplo DOM II

root

peliculas

codigo pelicula …. pelicula codigo

titulo director actores titulo director actores

67

Ejemplo DOM III
import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class ParserDOM {

.. Constructor y método tratarNodos ..

}

68

Ejemplo DOM IV
Constructor..

public ParserDOM(File archivo) {

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();

try {

DocumentBuilder parser = factory.newDocumentBuilder();
Document doc = parser.parse(archivo);
tratarNodo(doc);

} catch (ParserConfigurationException e) {
} catch (SAXException e) {
} catch (IOException e) {
}

} 69

Método tratarNodo..

public void tratarNodo(Node nodo) {

switch (nodo.getNodeType()) {
case Node.DOCUMENT_NODE:
...
break;
case Node.ELEMENT_NODE:
...
break;
case Node.ATTRIBUTE_NODE:
...
break;
case Node.TEXT_NODE:
...
break;
case Node.CDATA_SECTION_NODE:
...
break;
case Node.COMMENT_NODE:
...
break;
}
} 70

Ejemplo DOM VI
case Node.DOCUMENT_NODE:
Document doc = (Document)nodo;
tratarNodo(doc.getDocumentElement());
break;

case Node.ELEMENT_NODE:

System.out.println(nodo.getNodeName().toUpperCase());

// Tratar nodos atributo con recursividad
NamedNodeMap ats = nodo.getAttributes();
for (int i = 0; i < ats.getLength(); i++) {
tratarNodo(ats.item(i));
}

// Tratar nodos hijo con recursividad
NodeList hijos = nodo.getChildNodes();
for (int i = 0; i < hijos.getLength(); i++) {
tratarNodo(hijos.item(i));
}

break;
71

Ejemplo DOM VII
case Node.ATTRIBUTE_NODE:
System.out.println(nodo.getNodeName() +
" = '" + nodo.getNodeValue() + "'");
break;

case Node.TEXT_NODE:
if (nodo.getParentNode().getNodeName().equals("titulo")
|| nodo.getParentNode().getNodeName().equals("director")
|| nodo.getParentNode().getNodeName().equals("actores"))
System.out.println(nodo.getNodeValue());
break;

case Node.CDATA_SECTION_NODE:
System.out.println("CDATA: " + nodo.getNodeValue());
break;

case Node.COMMENT_NODE:
System.out.println("COMENTARIO: " + nodo.getNodeValue());
break; 72

Ejercicios
analice (realizar parseo) del documento clinica.xml
utilizando DOM Parsing.
Aplicar el XML Schema creado para poder validar el
documento clinica.xml.

73

Validación DOM contra DTD

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

// Habilitar validación
dbf.setValidating(true);

DocumentBuilder db = dbf.newDocumentBuilder();

// Establecer la clase manejadora de errores
db.setErrorHandler(new ParserErrorHandler());

Document d = db.parse(new File(ruta));

74

Validación DOM contra
XMLSchema
final String JAXP_SCHEMA_LANGUAGE =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
final String W3C_XML_SCHEMA =
"http://www.w3.org/2001/XMLSchema";

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

// Habilitar validación y espacios de nombres
factory.setNamespaceAware(true);

// Configurar parametros de validación contra XMLSchema
factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
DocumentBuilder parser = factory.newDocumentBuilder();

// Establecer la clase manejadora de errores
parser.setErrorHandler(new ParseErrorHandler());

75
Document doc = parser.parse(new File(ruta));

Validación DOM
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;

public class ParserErrorHandler implements ErrorHandler {

@Override
public void fatalError(SAXParseException exception) throws
SAXException {
}

@Override
public void warning(SAXParseException exception) throws
SAXException {

}

@Override
public void error(SAXParseException exception) throws SAXException
{
}
76
}

XML Namespaces (I)
Permiten que un mismo documento XML tenga
etiquetas de diferentes vocabularios.
Si a cada uno de estos vocabularios se le da un
espacio de nombres, se resuelve la ambigüedad
existente entre elementos o atributos que se
llamen igual.
Los nombres de elementos dentro de un espacio
de nombres deben ser únicos.

77

XML Namespaces (II)
<fac:factura xmlns:fac="http://www.dominio.es/Factura"
xmlns:fac=
xmlns:cli=
xmlns:cli="http://www.dominio.es/Cliente"
xmlns:ped=
xmlns:ped="http://www.dominio.es/Pedido"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsi
xsi:schemaLocation="
xsi:schemaLocation
http://www.dominio.es/Factura
http://www.dominio.es/schemas/factura.xsd">
<fecha>2008-11-03</fecha>
<cli:cliente>
id>208</id>
>208</id
<id>208</id>
<nombre>Jose García</nombre>
<telefono>696999666</telefono>
</cli:cliente>
<ped:pedido>
id>56</id>
>56</id
<id>56</id>
<articulo>Tornillo</articulo>
<precio>1.35</precio>
</ped:pedido>
</fac:factura>

Con el uso de espacios de nombres distintos, se evita la ambigüedad
existente entre las etiquetas “id” pertenecientes tanto a cliente como a 78
pedido.

XML Namespaces (III)
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
" "
targetNamespace="
="http://www.dominio.es/Cliente">
targetNamespace=" "
<xsd:element name="cliente">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="id" type="xsd:string“ />
<xsd:element name="telefono" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

79

XML Namespaces (IV)
" "
targetNamespace="
="http://www.dominio.es/Pedido">
targetNamespace=" "
<xsd:element name=“pedido">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="id" type="xsd:string“ />
<xsd:element name="articulo" type="xsd:string" />
<xsd:element name="precio" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

80

XML Namespaces (V)
" "
targetNamespace="
targetNamespace=" ="http://www.dominio.es/Factura""
xmlns:cli="
="http://www.dominio.es/Cliente"
xmlns:cli=" "
xmlns:ped="
="http://www.dominio.es/Pedido">
xmlns:ped=" "
namespace="
<xsd:import namespace=" ="http://www.dominio.es/Cliente"
"
schemaLocation="
schemaLocation=" ="http://www.dominio.es/schemas/cliente.xsd" />
"
<xsd:import namespace="
namespace=" ="http://www.dominio.es/Pedido""
schemaLocation="
schemaLocation=" ="http://www.dominio.es/schemas/pedido.xsd" />
"
<xsd:element name="factura">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fecha" type="xsd:string" />
<xsd:element ref="cli:cliente" />
ref="cli:cliente"
="cli:cliente
<xsd:element ref="ped:pedido" />
ref="ped:pedido"
="ped:pedido
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
81

Ejercicios
analice el documento de ejemplo taller.xml utilizando
cualquiera de las APIs de parseo (SAX o DOM).
Crear los XMLSchemas necesarios para poder validar el
documento usando espacios de nombre (Namespaces).
El parseador debe validar el documento contra su
XMLSchema referenciado.
82

Serialización en XML (I)
Para serializar objetos en un fichero XML y
poderlos recuperar posteriormente, el paquete
java.beans proporciona las clases XMLEncoder
y XMLDecoder.
Este tipo de serialización solo puede ser usada
con objetos de tipo POJO (Plain Old Java Object).
Se denomina a un objeto de tipo POJO, cuando la
clase a la que pertenece:
Siempre cuenta con el constructor por defecto.
Solo hereda de Object o de cualquiera de las
clases nativas de J2SE.
83

public class Persona {

private String nombre = new String();
private int edad = 0;

// Siempre debe tener constructor por defecto
public Persona() {}

public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}

public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}

public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
84
}

Serialización en XML (III)
Clase XMLEncoder
Constructor:
XMLEncoder(OutputStream os)
El objeto OutputStream que hay que proporcionar al
constructor será un objeto FileOutputStream asociado
a un fichero.
Métodos:
void writeObject(Object objeto)
Realiza la escritura de un objeto serializado en disco.
void close()
Cierra la conexión con el fichero y libera los recursos
utilizados por esta.
85

Serialización en XML (IV)
String ruta = "objetos.xml";

FileOutputStream fos = new FileOutputStream(ruta);
XMLEncoder xe = new XMLEncoder(fos);

xe.writeObject(new Persona("jose", 30));
xe.writeObject(new Persona("juan", 40));
xe.writeObject(new Persona("antonio", 20));

xe.close();

86

Serialización en XML (V)
Clase XMLDecoder
Constructor:
XMLDecoder(InputStream is)
El objeto InputStream que hay que proporcionar al
constructor será un objeto FileInputStream asociado a
un fichero.
Métodos:
Object readObject()
Realiza la lectura de un objeto serializado en disco.
Se deberá realizar un casting al tipo original para evitar que
se produzca una excepción ClassNotFoundException.

87

Serialización en XML (VI)
String ruta = "objetos.xml";

FileInputStream fis = new FileInputStream(ruta);
XMLDecoder xd = new XMLDecoder(fis);

try {

while (true) {
Persona persona = (Persona)xd.readObject();
System.out.println(persona);
}

} catch (ArrayIndexOutOfBoundsException e) {
} finally {

xd.close();

}
88

XSL (eXtensible Stylesheet
Language)
XSL es una familia de lenguajes basados en el
estándar XML que permite describir cómo la
información contenida en un documento XML debe
ser transformada o formateada para su
presentación.
Esta familia está formada por:
XPath, es una sintaxis para acceder o referirse a
porciones de un documento XML.
XSLT (XSL - Transformaciones), que permite convertir
documentos XML de una sintaxis a otra (por ejemplo, de
un XML a otro o a un documento HTML).
89

XPath (I)
XPath es un lenguaje declarativo, que sirve para
“navegar” dentro de un documento XML, seleccionando
elementos, atributos, etc.
Como ya sabemos, la estructura de un documento XML
se compone de nodos, estos nodos pueden ser
elementos o atributos. Los elementos pueden ser
hijos/padres de otros atributos, etc.
Se basa básicamente en expresiones (expresiones
XPath) similares a las expresiones regulares, pero
diseñadas para la estructura jerárquica de XML.

90

XPath (II) – Expresiones
/factura/cliente/nombre
Seleccionaría el elemento nombre que está dentro del elemento
cliente y este a su vez dentro de factura.
//nombre
Se seleccionan TODOS los elementos nombre.
/empresa/factura//nombre
Se seleccionan TODOS los elementos nombre contenidos dentro del
elemento factura.
//@fecha
Se seleccionan TODOS los atributos fecha.
/empresa/factura/albaran/@fecha
Se selecciona el atributo fecha del elemento albaran.
/empresa/factura/albaran[3]
Se selecciona el tercer elemento albaran dentro de factura.
//coche[@color="ROJO"]
Se seleccionan todos los elementos coche que tengan su atributo
color igual a ROJO.
count(/taller/coche//averia/@fecha)
Devuelve el número de atributos fecha de elementos averia dentro del
91
elemento coche, hijo de taller.

XPath (III)
<factura>
<albaran numero="1">
<importe>2500</importe>
</albaran>
</albaran>
</albaran>
</factura>

92

XPath (IV)
J2SE 5.0 nos provee de una API para trabajar con
expresiones XPath.
Se encuentra en el paquete javax.xml.xpath.
Creación de una expresión XPath:
XPathFactory factory = XPathFactory.newInstance();
XPath xpath = factory.newXPath();

Le pasamos la expresión como parametro String al método
compile() del objeto XPath. Y si es correcta, devuelve un objeto
XPathExpression:
XPathExpression expr = xpath.compile("//albaran[@numero>2]/fecha[1]");

Si la expresión no era correcta se lanza una
TransformerException.
93

XPath (V)
También es necesario crear un objeto Document para pasarlo al
objeto XPathExpression:
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
Document doc = factory.newDocumentBuilder().parse("factura.xml");

Ahora para evaluar la expresión en un documento XML, llamamos al
método evaluate() de XPathExpression:
String result = expr.evaluate(doc, XPathConstants.STRING);

El primer parámetro es el objeto Document, y el segundo es una
constante que indica que tipo de dato esperamos recibir como
resultado.
Por último, mostramos el resultado:
System.out.println(result);
94

Ejercicios
recupere información del documento taller.xml
utilizando XPath.
El usuario podrá solicitar por consola la siguiente
información:
Nombre, dirección o teléfono de un cliente,
introduciendo su id o dni.
Los nombres y categoría profesional de los mecanicos
que repararon una avería, introduciendo la fecha en que
se solucionó la avería y el número de reparación.
La denominación y cantidad de las piezas empleadas
para realizar una reparación, introduciendo el número
de ésta.
95

eXtensible Style Language
Transformations XSLT (I)
Con la diversidad de lenguajes de presentación
que hay (WML, HTML, XHTML) existen dos
alternativas para desarrollar las aplicaciones:
Desarrollar diferentes versiones de los procesos de
generación de presentación (JSP, ASP, CGI,..) para
cada lenguaje.
Desarrollar solo una versión que genere XML y
conversores de XML a los lenguajes de
presentación.

96

Transformations XSLT (II)
Ventajas:
No asume un único formato de salida de documentos.
Permite manipular de muy diversas maneras un
documento XML: reordenar elementos, filtrar, añadir,
borrar, etc.
Permite acceder a todo el documento XML.
XSLT es un lenguaje XML.
Desventajas:
Su utilización es más compleja que un lenguaje de
programación convencional.
Consume cierta memoria y capacidad de proceso DOM
está detrás. 97

Transformations XSLT (III)

98

Transformations XSLT (IV)
Para crear una transformación se necesita:
Un documento XML a transformar:
estudiantes.xml
Una hoja de estilo (.xsl) que especifique la
transformación:
estudiantes.xsl

99

Transformations XSLT (V)
<curso>
<nombre id="xj_2910">Programando XML en Java</nombre>
<profesor id="lt">Linus Torvalds</profesor>
<estudiante id="bg">
<nombre>Bill Gates</nombre>
<p1>30</p1>
<p2>70</p2>
<practica>80</practica>
<final>85</final>
</estudiante>
<estudiante id="sj">
<nombre>Steve Jobs</nombre>
<p1>80</p1>
<p2>90</p2>
<practica>100</practica>
<final>40</final>
</estudiante>
</curso> 100

Transformations XSLT (VI)
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="curso">
match="curso
curso">
<HTML>
<HEAD><TITLE>Lista de estudiantes</TITLE></HEAD>
<BODY>
<xsl:apply-templates select="estudiante"/>
xsl:apply- select="estudiante"/>
estudiante
</BODY>
</HTML>
</xsl:template
xsl:template>
</xsl:template>

<xsl:template match="estudiante">
match="estudiante
estudiante">
<xsl:value-of select="nombre"/>
<xsl:value- select="nombre"/>
nombre"/>
</xsl:template
xsl:template>
</xsl:template>

</xsl:stylesheet>
</xsl:stylesheet>
xsl:stylesheet 101

Transformations XSLT (VII)
Resultado:
<HTML>
<HEAD>
<TITLE>Lista de estudiantes</TITLE>
</HEAD>
<BODY>
Bill Gates
Steve Jobs
</BODY>
</HTML>

102

Transformations XSLT (VIII)
Formas de uso de XSLT:
Visualizar directamente en un navegador el documento
XML que tiene asociada una hoja XSLT.
<?xml-stylesheet type="text/xsl" href="estudiantes.xsl"?>

Ejecutar un procesador XSLT independientemente del
navegador. Se le pasan las entradas necesarias
(fichero origen y hoja XSLT a utilizar) y genera la salida
en un fichero, con el que podemos hacer lo que
queramos.
Realizar las transformaciones dentro de una aplicación
en el servidor y enviar a los clientes sólo el resultado
de la transformación. 103

XSLT (IX)
Elementos en un documento XSLT:
xsl:stylesheet elemento raiz:

xsl:template es usado para crear plantillas:
Cada plantilla define la transformación que se debe realizar
en el fragmento del documento XML asociado a este
elemento.
El atributo match asocia la plantilla a un elemento XML
seleccionado usando una expresión Xpath.
"/" – expresión perteneciente al nodo raiz del documento XML.
xsl:apply-
xsl:apply-templates
Aplica las plantillas definidas para todos los hijos de un nodo
seleccionado. 104

XSLT (X)
xsl:value-
xsl:value-of permite recuperar el valor de un nodo.
El atributo select define la expresión XPath usada para la
selección del nodo.
<xsl:value-of select="estudiante"/>
</xsl:template>
Si queremos seleccionar varios podemos hacer:
<xsl:apply-templates select="estudiante"/>
</xsl:template>
<xsl:value-of select="."/>
</xsl:template>
xsl:for-
O usar xsl:for-each
<xsl:template match=“curso">
<xsl:for-each select="estudiante">
<xsl:value-of select="."/>
</xsl:for-each>
</xsl:template> 105

XSLT (XI)
xsl:choose permite realizar distintos procesamientos en
función de los datos:
Se compone de elementos xsl:when
Un elemento opcional xsl:otherwise
<xsl:choose>
<xsl:when test="expresión"
test="expresión">
... alguna salida ...
</xsl:when>
<xsl:otherwise>
... alguna salida ....
</xsl:otherwise>
</xsl:choose>
xsl:if permite procesar o no un elemento en función de una
condición:
La condición se define en su atributo test.
<xsl:if test="expresión"
test="expresión">
... salida ...
</xsl:if> 106

Expresiones Xpath para el atributo match o select:
Seleccionar el nodo raiz:
<xsl:template match="/">
...
</xsl:template>
Seleccionar un elemento:
<xsl:template match=“estudiante">
...
</xsl:template>
Seleccionar hijos de un elemento:
<xsl:template match="curso/estudiante">
...
</xsl:template>
<xsl:template match="curso/*/nombre">
...
</xsl:template>
Seleccionar descendientes de un elemento:
<xsl:template match="curso//nombre">
...
107
</xsl:template>

XSLT (XIII)
Seleccionar atributo id:
<xsl:value-of select="./@id"/>
Seleccionar comentarios:
<xsl:template match="comment()">
...
</xsl:template>
Seleccionar elementos de texto:
<xsl:template match="text()">
...
</xsl:template>
Recuperar posición que ocupa un subelemento dentro de
elemento padre:
<xsl:value-of select="position()"/>
108

XSLT (XIV)
Evaluando si una condición es cierta:
Si el elemento estudiante tiene un hijo nombre:
<xsl:template match="estudiante[nombre]">
Cualquier elemento que tiene un elemento nombre:
<xsl:template match="*[nombre]">
Elemento estudiante tiene un sub-elemento p1 o p2:
<xsl:template match="estudiante[p1 | p2]">

109

XSLT (XV)
<xsl:output method="text"/>
<xsl:apply-templates select=“estudiante"/>
</xsl:template>

<xsl:variable name="avg">
name="avg">
avg
<xsl:value-of select="(p1 + p2 + practica + final) div 4"/>
</xsl:variable
xsl:variable>
</xsl:variable>

<xsl:if test="$avg > 65">
test="$avg
nombre="<xsl:value-of select="nombre"/>"
media="<xsl:value-of select="$avg"/>"
</xsl:if
xsl:if>
</xsl:if>

</xsl:template>
110
</xsl:stylesheet>

XSLT (XVI)

Resultado transformación:
nombre="Bill Gates" media="66,25"

nombre="Steve Jobs" media="77,5"

111

XSLT (XVII)
Java JAXP provee las clases
TransformerFactory y Transformer para
la aplicación de XSL a un documento XML.
Se encuentran en el paquete
javax.xml.transform.
Creación de un objeto transformador XSL:
TransformerFactory factory =
TransformerFactory.newInstance();
StreamSource source =
new StreamSource("estudiantes.xsl");
Transformer transformer =
factory.newTransformer(source);
112

XSLT (XVIII)
Ahora para realizar la transformación del documento
XML, invocamos al método transform() del objeto
transformador:
transformer.transform(source, result);

Al que hay que pasarle 2 parametros:
Un objeto StreamSource que referencia al documento XML
que se quiere transformar.
Un objeto StreamResult que representa el documento de
salida, resultado de la transformación.
StreamSource source = new StreamSource("estudiantes.xml");
StreamResult result = new StreamResult("estudiantes.html");

113

Ejercicios
transforme la información del documento taller.xml
a formato HTML.

114

Xml

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Xml

Similar to Xml (20)

Xml