Xml

Requisitos
- PC con Windows 98 / NT / 2000, 64 MB de RAM (dependen del
servidor a usar)
Para entorno Microsoft:
- Internet Explorer
- Parser MSXML 3 o superior.
- Servidor IIS o Personal Web Server de Microsoft.
Para entorno Java:
- JDK 1.1.8 o superior
- JAXP (Java API for XML Processing)
- Servidor Web (por ej. iPlanet Web Server FastTrack Edition)

El estándar XML
DOM
El estándar XML
Qué es XML y qué elementos lo
componen
Acceso a los datos de un documento
XML
XSL
Cómo dar formato a un documento
XML con XSL
Aplicaciones
Prácticas
Uso práctico de XML en entornos
Java y Microsoft

• XML (eXtended Markup Language) es un lenguaje que
proporciona un formato para describir datos estructurados
• Es un lenguaje de marcas
• Es un subconjunto de SGML (Standard Generalized Markup
Language)
• Definido por el W3C en 1998
XML - Introducción

XML - Características
• Lenguaje de marcas extensible, es un metalenguaje
• Es “case sensitive”
• Representación estructural de los datos en forma de árbol
• Define los datos en una aplicación, no su presentación
• Permite interoperatividad entre máquinas distintas (un
estándar para el intercambio de datos)

XML - Ejemplo de documento XML
<?xml version="1.0"?>
<!DOCTYPE discos SYSTEM "cds.dtd">
<discos>
<disco>
<artista tipo="individual">Frank Sinatra</artista>
<titulo numerodepistas="2">In The Wee Small Hours</titulo>
<pistas>
<pista>In The Wee Small Hours</pista>
<pista>Mood Indigo</pista>
</pistas>
<precio>$12.99</precio>
</disco>
<disco>
<artista tipo="band">The Offspring</artista>
<titulo numerodepistas="2">Americana</titulo>
<pistas>
<pista>Welcome</pista>
<pista>Have You Ever</pista>
</pistas>
<precio>$12.99</precio>
</disco>
</discos>

XML - Elementos XML
•Un documento XML está formado por tags o etiquetas
para la estructuración de los datos.
Por ejemplo: <disco>
•Un elemento XML está formado por una etiqueta de
inicio y otra etiqueta final. Entre ambas está el valor del
dato al que se refiere el tag.
En este ejemplo, el elemento pista tiene como valor
“Welcome”:
<pista>Welcome</pista>

XML - Elementos XML - Atributos
• Un elemento XML puede contener uno o más atributos
en su tag inicial
En este ejemplo, el atributo sería “tipo”, y su valor
“individual”:
• Un elemento XML puede no contener un valor, solamente
atributos. En este caso se puede escribir con un solo tag
terminado en /.
Esta expresión
equivale a
<artista tipo="individual">Frank Sinatra</artista>
<precio valor=“$12.99”></precio>
<precio valor=“$12.99”/>

XML - Documentos XML
Un documento XML es un conjunto de elementos XML anidados
(con estructura de árbol)
Reglas a tener en cuenta:
• Todos los elementos deben cerrarse
• Los elementos deben estar limpiamente anidados
• Un documento XML debe tener un único elemento raíz

XML - Reglas de Construcción de
Nombres XML
En la construcción de nombres XML (atributos y elementos
XML) se deben tener en cuenta las siguientes reglas:
• Un nombre XML puede contener los siguientes caracteres:
Letras (A-Z, a-z), dígitos (0-9), guión bajo (_), guión (-) y
punto (.)
• Debe empezar con una letra o guión bajo
• Puede usar dos puntos (:) sólo en namespaces
• No puede contener espacios en blanco

XML - Documento XML Bien Formado
Se dice que un documento XML está bien formado si
cumple las siguientes reglas:
• Todo tag debe tener su correspondiente tag final.
• Los elementos deben quedar debidamente anidados
• Debe haber exactamente un elemento raíz
• Los valores de los atributos deben estar entre comillas
• Un mismo elemento no debe tener más de un atributo con
el mismo nombre
• Los comentarios no deben colocarse dentro de los tags
• Los caracteres & y < deben ser precedidos por un si
forman parte de los datos de un elemento o atributo.
Validar un documento XML Con un Parser XML

XML - Ejercicio 1
<empleados>
<empleado nombre=“Juan” apellido=“Pérez” apellido=“Sánchez”>
<direccion calle=“López Peñalver”>
</empleado>
<Empleado nombre=“Alberto”>
<direccion calle=“López Peñalver”>
</Empleado>
<empleado>
<localidad>Málaga</localidad>
</Empleado>
</empleados>
<oficinas>
<oficina 1tlf=“951000000” 2tlf=“951000001”>
<ciudad>Madrid</ciudad>
</oficina>
<oficina>
<ciudad telefono=“12312312”>Barcelona</ciudad>
</oficina>
</oficinas>
¿Es el siguiente documento XML un documento bien formado?

XML - Ejercicio 2
Crear un documento XML válido que contenga los siguientes datos:
Vuelo Origen Destino Salida Llegada
IB777 Málaga Madrid 8:00 8:50
IB888 Madrid Barcelona 9:00 10:10
IB999 Madrid Málaga 12:00 12:50
Código Avión Vuelos
1234 IB777,IB999
1122 IB888

XML - Namespaces
•Un XML namespace es una colección de nombres que
pueden ser usados en elementos o atributos.
•Un namespace distingue nombres de forma única en la Web,
para evitar conflictos.
•Un namespace puede ser identificado por una:
URI (Universal Resource Identifier)
URL (Uniform Resource Locator)
URN (Uniform Resource Number)

XML - Namespaces - Declaración
Se declara con el atributo xmlns en el elemento deseado.
Existen dos tipos de declaración:
•Declaración por defecto. No hace falta usar prefijo, todos los
nombres pertenecen al namespace declarado:
•Declaración explícita. Cada nombre debe usar un prefijo
especificando el namespace al que pertenece:
<BOOK xmlns="urn:BookLovers.org:BookInfo">
<TITLE>A Suitable Boy</TITLE>
<PRICE currency="US Dollar">22.95</PRICE>
</BOOK>
<BOOKS>
<bk:BOOK xmlns:bk="urn:BookLovers.org:BookInfo"
xmlns:money="urn:Finance:Money">
<bk:TITLE>A Suitable Boy</bk:TITLE>
<bk:PRICE money:currency="US Dollar">22.95</bk:PRICE>
</bk:BOOK>
</BOOKS>

XML - Prólogo del Documento XML
Antes del elemento raíz del documento XML pueden aparecer una
serie de elementos, formando la siguiente estructura:
<?xml version="1.0"?>

<?xml-stylesheet href=“discos.xsl” type=“text/xml”?>
<!DOCTYPE discos SYSTEM “discos.dtd">
<discos>
....
</discos>
Declaración XML
Comentarios
Instrucciones de
procesamiento
Document Type
Declaration
Elemento raiz

Declaración
• No es necesaria para que el documento sea bien formado
• Incluye los siguientes atributos:
• version: versión de XML
• encoding: codificación de los caracteres
• standalone: especifica si no es necesaria una validación por
DTD
Comentarios
• Pueden aparecer en cualquier sitio excepto dentro de un tag

<?xml version="1.0" encoding="ISO-8859-1"?>

Instrucciones de procesamiento
• Asocia el documento XML con algún elemento externo, como por
ejemplo una hoja de estilos xsl.
<?xml-stylesheet href=“discos.xsl” type=“text/xml”?>
Document Type Declaration
• Referencia a un DTD (Document Type Definition), el cual valida el
documento XML.

XML - DTDs (Document Type
Definition)
• Un DTD es un documento que especifica las restricciones que
debe cumplir un documento XML.
• Un documento válido es aquel que cumple las restricciones
especificadas en su DTD. Un documento es inválido si no las
cumple o simplemente no referencia a ningún DTD.
• Permite la declaración de tres tipos de estructuras:
 Elementos
 Atributos
 Entidades
• Debido a sus limitaciones se creó el lenguaje XML Schema.

XML - DTDs - Declaración
Un DTD se puede declarar de 2 formas:
• En el propio documento XML (en el prólogo):
<!DOCTYPE empleado
[
<!ELEMENT empleado (nombre, direccion)>
<!ELEMENT nombre (#PCDATA)>
<!ELEMENT direccion (ciudad, calle)>
<!ELEMENT ciudad (#PCDATA)>
<!ELEMENT calle (#PCDATA)>
]
>
• En un fichero aparte

XML - DTDs - Declaración de Elementos
• Un Elemento se declara especificando su nombre y los elementos
que lo componen:
• Si el elemento no contiene ningún otro elemento, se
especifica el tipo del valor que contiene
<!ELEMENT nombre (#PCDATA)>
#PCDATA permite caracteres alfanuméricos
•Así, el siguiente documento XML sería válido para el DTD anterior:
<empleado>
<nombre>Antonio</nombre>
<direccion>
<ciudad>Málaga</ciudad>
<calle>Larios</calle>
</direccion>
</empleado>

• Si separamos con comas los elementos hijo, el orden de
aparición de éstos debe cumplirse
• Si separamos los elementos con una barra ( | ), con que
aparezca sólo uno de ellos ya se cumplirá la condición
<!ELEMENT empleado (nombre | direccion)>
• También pueden agruparse con paréntesis:
<!ELEMENT empleado ((nombre | apellido) , direccion)>

Modificadores
• Los siguientes modificadores especifican el número de elementos
que deben aparecer:
<!ELEMENT empleado (nombre , apellido? , direccion+)>
* 0 ó más
+ 1 ó más
? 0 ó 1
• Si no se muestra ningún modificador, debe aparecer
exactamente 1 elemento.
Ejemplos:
<!ELEMENT empleado (nombre , apellido , (direccion | telefono)*)>

Elementos Vacíos
• Si un elemento no contiene valor, se declara con la palabra EMPTY
<!ELEMENT direccion EMPTY>
Contenido ANY
• Si un elemento puede tener cualquier tipo de valor o de elementos
compuestos, se declara con la palabra ANY
<!ELEMENT otrosDatos ANY>

XML - DTDs - Ejercicio 1
Crear un DTD que valide la siguiente estructura:
<proveedores>
<proveedor>
<nombre>Pascal</nombre>
<productos>
<producto>Leche</producto>
<producto>Flan</producto>
</productos>
</proveedor>
<proveedor>
<nombre>Capitán Pesconovo</nombre>
<productos>
<producto>Merluza</producto>
</productos>
<telefono>
952888777
</telefono>
</proveedor>
</proveedores>

XML - DTDs - Declaración de Atributos
• Un elemento puede tener 1 o más atributos. Por ejemplo, para
declarar los atributos ciudad, calle y numero del elemento
direccion, se haría de la siguiente forma:
<!ATTLIST direccion
ciudad CDATA #FIXED
calle CDATA #REQUIRED
numero CDATA #IMPLIED
>
<direccion ciudad=“Málaga” calle=“Larios”
numero=“5”/>
• La expresión #REQUIRED indica que el atributo es obligatorio
• La expresión #IMPLIED indica que el atributo es opcional
• La expresión #FIXED indica que el atributo no es modificable
• La expresión CDATA es el tipo de dato (datos alfanuméricos)
• Se puede especificar un valor por defecto:
<!ATTLIST direccion pais CDATA “España”>

XML - DTDs - Declaración de Atributos
Tipos de atributos
• Enumeración. Limita los posibles valores del atributo.
<!ATTLIST empleado sexo (hombre | mujer) #REQUIRED>
• Tipos de atributos simple.
• CDATA. Caracteres alfanuméricos
• ID. Identificador único para un elemento.
• IDREF. Referencia a un número identificador contenido en
el atributo ID de algún otro elemento
<!ATTLIST empleado
empid ID #REQUIRED
supervisor IDREF #IMPLIED
>
<empleado empid=“A120”>
</empleado>
<empleado empid=“A240” supervisor=“A120”>
</empleado>

XML - DTDs - Declaración de Entidades
• Una entidad es una asociación entre el nombre de la entidad y su
valor. La entidad puede aparecer en el valor de un elemento o
atributo, y será sustituido por su valor.
• Hay 5 entidades predefinidas:
• < (<)
• & (&)
• > (>)
• " (")
• ' (')
• Se pueden definir entidades nuevas:
<!ENTITY empresa “Coritel AOS">
y usarlas de la siguiente forma
<empleado empresa=“&empresa;">

XML - DTDs - Ejercicio 2
Crear un DTD que valide la siguiente estructura:
<almacen empresa="&empresa;">
<productos>
<producto id="A191">
<nombre>Teclado</nombre>
<precio valor="20" moneda="euros"/>
<caracteristicas>15 pulgadas</caracteristicas>
</producto>
<producto id="A167">
<nombre>Monitor 14'</nombre>
<precio valor="20000" moneda="pesetas"/>
</producto>
<producto id="A180" nohay="A167">
<nombre>Monitor 15'</nombre>
<precio valor="20000" moneda="pesetas"/>
</producto>
</productos>
</almacen>

XML - Schema
• Estándar para la validación de documentos XML
• Validación mediante un parser
• Mejora con respecto a los DTDs
 Permite mayor exactitud en el tipo de datos.
 Está escrito en formato XML
 Es extensible y escalable
 Permite especificar el número de elementos que contiene un
elemento
 Las declaraciones de elementos están anidadas

XML - Schema - Declaración
• Todo schema debe ser declarado con el elemento Schema y en el
siguiente namespace:
<Schema xmlns=“urn:schemas-microsoft-com:xml-data“
xmlns:dt="urn:schemas-microsoft-com:datatypes">
...
</Schema>
• Al ser el schema un documento XML, la primera línea será la
versión de XML usada.
• Se almacena en un archivo con extensión xml.

• Elementos simples:
 content: textOnly, eltOnly, empty, mixed (por defecto)
• Elementos compuestos:
minOccurs: número mínimo de apariciones del elemento
0,1
maxOccurs: número máximo de apariciones del elemento
1,*
order: seq (por defecto), one, many
XML - Schema - Elementos
<ElementType name=“precio“ content=“textOnly”/>
<ElementType name=“producto“ order=“seq”>
<element type=“nombre” minOccurs=“1”/>
<element type=“precio”/>
</ElementType>

XML - Schema - Elementos
• Agrupación: especifica reglas de aparición para un subconjunto de
elementos
<ElementType name=“producto“>
<element type=“nombre”/>
<group order="one">
<element type=“descripcion"/>
<element type=“categoria"/>
</group>
</ElementType>

Declaración de atributos:
XML - Schema - Atributos
<AttributeType name=“origen“/>
<AttributeType name=“proveedor“ required=“yes”/>
<ElementType name=“producto“>
<element type=“nombre” minOccurs=“0”/>
<attribute type=“origen” default=“Madrid”/>
<attribute type=“proveedor”/>
</ElementType>

XML - Schema - Referencia al schema
Un documento XML especifica que debe ajustarse a un schema de
la siguiente forma:
<productos xmlns=“x-schema:schemaproductos.xml">
...
</productos>

XML - Schema - Ejercicio 1
Ejercicio 1: XML Schema
Ejercicio 1.1
• Crear un XML Schema en productosesq.xml para la validación
del archivo productos.xml, donde debe haber al menos 1
producto, idProducto sea obligatorio, cada producto tenga al
menos 1 procedencia y el precio sea opcional.

XML - Schema - Tipos
Los tipos se especifican con el atributo dt:type
Tipos:
id valor único
idref referencia a un id
string cadena
boolean 0 ó 1
char 1 carácter
date fecha en formato 1994-11-05
time hora en formato 08:15:27
int entero consigo opcional
float número real
i1,i2,i4,i8 entero, especificando el número de bytes
r4,r8 real, especificando el número de bytes
ui1,ui2,ui4,ui8 entero sin signo
<ElementType name=“precio“ dt:type=“int”/>

XML - Schema - Restricciones
El elemento datatype permite especificar el tipo de un elemento o
atributo y restringir sus valores
Posibles atributos de datatype:
dt:type tipo del elemento o atributo
dt:values valores posibles si dt:type = enumeration
dt:max máximo valor permitido
dt:maxExclusive máximo valor permitido excluyente
dt:min mínimo valor permitido
dt:minExclusive mínimo valor permitido excluyente
dt:maxLength máxima longitud del valor
<ElementType name=“FechaEntrega" content="textonly">
<datatype dt:type="date" dt:min="1969-07-20“
dt:max=“2003-12-31"/>
</ElementType>

XML - Schema - Enumeración
En la enumeración sólo es válido uno de los valores especificados:
<AttributeType name=“calidad" dt:type="enumeration“
dt:values=“alta media baja"/>

XML - Schema - Ejercicio 2
Ejercicio 2: XML Schema
Ejercicio 2.1
• Crear un XML Schema para la validación del archivo
clientes.xml, de forma que:
idCliente sea obligatorio y número de 5 dígitos como
máximo
dni sea obligatorio y alfanumérico con 8 caracteres máximo
localidad opcional
nombre obligatorio
apellido1 opcional
apellido2 opcional, pero si aparece debe ser después de un
apellido1
sexo opcional, y será “Hombre” o “Mujer”
direcciones es opcional, pero si aparece habrán 1 ó más
direcciones. ciudad, calle y número deben aparecer en ese
orden

XML - SAX
• SAX (Simple API for XML) es una API que permite a una
aplicación escribir código genérico que pueda funcionar con
cualquier parser
• SAX no es un parser en sí, sólo una capa entre una aplicación
y un parser
XML file XML parser SAX aplicación

DOM
El estándar XML
componen
XML
XSL
XML con XSL
Aplicaciones
Prácticas
Java y Microsoft
DOM

DOM - Introducción
• El DOM (Document Object Model) es una API (Application
Programming Interface) creada para acceder a los datos de un
documento XML.
• Muchos lenguajes tienen librerías que permiten acceder al DOM de
un documento XML mediante un parser.
• El estándar “Level 1 DOM” definido por el W3C es seguido, entre
otros navegadores, por Netscape 6 y Explorer 5.
• Al DOM de un documento XML puede accederse desde Javascript,
VBScript u otros lenguajes que lo soporten.

DOM - Data Island
• Un Data Island es un documento XML insertado en una página
HTML. Esto se puede conseguir de 2 formas:
• Insertando el código del documento XML en la página:
• Referenciando el archivo donde está contenido el documento
XML:
<XML ID="XMLCliente">
<clientes>
<cliente idCliente=“81422”>
</cliente>
<nombre>Jose Carlos</nombre>
</cliente>
</clientes>
</XML>
<XML ID="XMLCliente" SRC=“clientes.xml"></XML>

DOM - Acceso a elementos
• XMLDocument: obtiene el documento XML
• documentElement: obtiene el elemento raiz del documento XML
• childNodes: obtiene una lista de los elementos hijos de un
elemento
• item(n): devuelve el elemento n de una lista
• text: devuelve el valor de un nodo
XMLCliente.XMLDocument.documentElement.childNodes.item(0).childNodes.item(0).text
La expresión
devuelve “Antonio”
• length: devuelve el número de nodos hijos

• firstChild: devuelve el primer elemento hijo de otro elemento
• lastChild: devuelve el último elemento hijo de otro elemento
• getElementsByTagName(nombre): obtiene una lista de los
elementos encontrados con el nombre indicado. Busca de forma
recursiva.
devuelve “Antonio”
• nextSibling: devuelve el siguiente elemento en la lista de hijos
del elemento padre, o null si es el último elemento.
• previousSibling: devuelve el anterior elemento en la lista de
hijos del elemento padre, o null si es el primer elemento.
• parentNode: devuelve el nodo padre de un elemento.
DOM - Acceso a elementos
XMLCliente.XMLDocument.documentElement.getElementsByTagName(“nombre”).item(0).text

DOM - Acceso a atributos
• getAttribute(nombre): obtiene el valor del atributo con el nombre
especificado
devuelve “81422”
• attributes: obtiene una lista de los atributos de un elemento
también devuelve “81422”
XMLCliente.XMLDocument.documentElement.firstChild.getAttribute("idCliente")
XMLCliente.XMLDocument.documentElement.firstChild.attributes.item(0).text

DOM - Ejercicio 1
Ejercicio 1: Acceso a XML
Ejercicio 1.1
• Insertar el contenido de clientes.xml en un Data Island en el
código de pagina.htm
• Modificar la función mostrarDatos() para que muestre mensajes
con los siguientes datos:
• Mostrar el nombre del primer cliente
• Mostrar el idCliente del último cliente
• Mostrar el número de clientes
• Hacer un bucle que muestre los dni.
• Hacer un bucle que, para cada cliente, si tiene localidad
que la muestre, y si no, que muestre el mensaje “Sin
localidad”

DOM - Modificación de elementos
Creación de un elemento
• createElement(nombre): devuelve un elemento con el nombre
especificado
• createTextNode(nombre): devuelve un objeto Text que debe ser
insertado en un elemento
• appendChild(objeto): inserta un hijo a la lista de hijos de un
elemento. El objeto puede ser un Elemento o un objeto Text.
El siguiente código inserta el apellido al primer cliente con valor
“Fernández”
element = XMLCliente.createElement("apellido");
textNode = XMLCliente.createTextNode("Fernández");
element.appendChild(textNode);
XMLCliente.XMLDocument.documentElement.firstChild.appendChild(element);

DOM - Modificación de elementos
Eliminación de un elemento
• removeChild(objeto): elimina el objeto especificado
La siguiente instrucción elimina el segundo cliente:
Cambiar el valor de un elemento
Simplemente con la operación de asignación. La siguiente sentencia
modifica el nombre del primer cliente:
XMLCliente.XMLDocument.documentElement.firstChild.firstChild.text = “Jesús";
XMLCliente.XMLDocument.documentElement.removeChild (
XMLCliente.XMLDocument.documentElement.childNodes.item(1) );

DOM - Modificación de atributos
Creación o cambio de valor de un atributo
• setAttribute(nombre,valor): si el atributo especificado existe,
cambia su valor, si no, crea uno nuevo y le asigna el valor especificado.
El siguiente ejemplo crea el atributo “dni” para el primer cliente:
Eliminación de un atributo
• removeAttribute(nombre): elimina de un nodo el atributo con el
nombre especificado. Este ejemplo borra el atributo “nif” creado en la
sentencia anterior:
XMLCliente.XMLDocument.documentElement.firstChild.setAttribute(“dni", “55333444");
XMLCliente.XMLDocument.documentElement.firstChild.removeAttribute(“dni");

DOM - Ejercicio 2
Ejercicio 2: Modificación de XML
Ejercicio 2.1
• Referenciar al archivo clientes.xml desde un Data Island en el
código de pagina.htm
• Modificar la función cambiarDatos() para que haga lo siguiente:
• Añadir el atributo “localidad” al segundo cliente con el valor
“Málaga”
• Añadir una etiqueta “apellido” al último cliente con el valor
“Martín”
• Eliminar el primer cliente
• Cambiar el nombre del último cliente por “Jorge”.
• Para comprobar los cambios, hacer 3 bucles que muestren
todos los nombres, apellidos y localidades. Debe mostrar:
Nombres: Jose Carlos, Jorge
Apellidos: Sánchez, Martín
Localidades: Málaga, null

XSL
DOM
El estándar XML
componen
XML
XSL
XML con XSL
Aplicaciones
Prácticas
Java y Microsoft

XSL - Introducción
• XSL (eXtensible Stylesheet Language) es un estándar creado por el
W3C para el tratamiento visual de documentos XML.
• El estándar XSL define dos lenguajes: XSLT y XPath.
• XSLT (XSL Transformations) es un lenguaje que define una serie de
elementos que sirven para dar un formato a un documento XML.
• XPath (XML Path Language) es un lenguaje que define una forma de
construir expresiones que identifican parte de un documento XML.
• Sigue una estructura de árbol, al igual que XML.
Procesador XSLT
• Un procesador XSLT es un programa que se encarga de aplicar una
plantilla XSL a un documento XML.
• Recibe como entrada un documento XSL y otro XML y devuelve como
salida un documento XML, que puede ser una página HTML.

XSL - Modo de funcionamiento
• XSLT usa una serie de tags que están definidos dentro de un
namespace. El namespace definido para los tags de XSLT 1.0 debe
definirse en el tag stylesheet de la siguiente forma:
• El documento XSL contiene 1 o más plantillas (templates), definidas
dentro del elemento stylesheet. El atributo match indica a que
elemento se le aplica la plantilla. “/” indica que la plantilla se aplica al
elemento root.
<xsl:template match="/">
...
</xsl:template>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
....
</xsl:stylesheet>

Para aplicar el documento XSL al XML, el procesador XSLT busca un
template que se aplique al elemento root, y lo ejecuta.
XSL - Ejemplo
Éste sería un ejemplo de documento XSL:
<xsl:stylesheet version="1.0“ mlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match=“/">
<html>
<head><title>Clientes</title></head>
<body>
.....
</body>
</html>
</xsl:template>
</xsl:stylesheet>

XSL - Ejecución en IE
• Internet Explorer 5 contiene un Procesador XSLT (MSXML).
• Para aplicar una plantilla XSLT a un documento XML, se añade la
siguiente línea al comienzo del documento XML.
<?xml-stylesheet type=“text/xsl” href=“clientes.xsl” ?>
• Abrir el fichero xml con el Explorer

XSL - XPath
• XPath es un lenguaje para construir expresiones que referencien
a una parte de un documento XML
<clientes>
<cliente idCliente=“81422” dni=“33555888”>
</cliente>
<nombre>Jose Carlos</nombre>
</cliente>
</clientes>
• Referencias absolutas: comienzan con el elemento root ( / )
/clientes/cliente devuelve todos los nodos cliente
/clientes/cliente[1] devuelve el primer cliente
• Referencias relativas: parten del nodo contextual.
clientes/cliente también devuelve los nodos cliente

XSL - XPath - Símbolos especiales
Símbolos especiales
Aparte de la barra / , hay otros símbolos con los siguientes significados:
/clientes/cliente/@idCliente devuelve todos los idCliente
/clientes//* devuelve todos los nodos descendientes de cliente
Suponiendo que el nodo contextual es /clientes/cliente con idCliente=“81422”:
./nombre devuelve el valor del elemento nombre (“Antonio”)
Símbolo Significado
@nombre Atributo llamado nombre
// El nodo y todos sus descendientes
. El propio nodo
.. El nodo padre
* Todos los nodos hijo
@* Todos los atributos

XSL - XPath - Predicados
Predicados
Un predicado es una condición que filtra los elementos devueltos
por una expresión.
/clientes/cliente[nombre=‘Antonio’] devuelve los clientes
llamados Antonio
/clientes/cliente[@idCliente=‘81422’]/nombre devuelve el
nombre del cliente con idCliente igual a ‘81422’
Negación
La palabra not pone como condición que no esté un elemento o
atributo.
/clientes/cliente[not(@dni)] devuelve los clientes que no
tengan como atributo el dni.
/clientes/cliente[not(apellido)] devuelve los clientes que no
tengan el tag apellido

XSL - XPath - Ejercicio 1
<paises>
<pais idPais=“11”>
<nombre>Italia</nombre>
<ciudades>
<ciudad idCiudad=“320”>
<nombre>Roma</nombre>
<poblacion>5000000</poblacion>
</ciudad>
</ciudades>
</pais>
</paises>
• Obtener los nombres de todos los países
• Obtener los nombres de todas las ciudades del segundo país de la lista
• Obtener los nombres de las ciudades con población mayor a 1000000
• Obtener los idCiudad de las ciudades con población entre 50000 y 100000
• Obtener el idPais del país que contenga la ciudad con idCiudad = 320

XSL - XHTML
XHTML (eXtended HyperText Markup Language)
• Implementación de HTML compatible con XML
• Validación:
Reglas de construcción:
• Tags obligatorios: head y body
• Tags en minúscula
• Elementos correctamente anidados
• Todos los elementos deben ser cerrados
Texto<p> <p>Texto</p>
<br> <br/>
<!DOCTYPE html PUBLIC
"-//W3C//DTD XHTML 1.0 Strict//EN“
"DTD/xhtml1-strict.dtd">

Reglas de construcción:
• Los atributos deben ir entre comillas
• Los atributos deben tener valor
• Para los scripts se delimita una sección CDATA
XSL - XHTML
<td width=100> <td width=“100”>
<option value=“1” selected>
<option value=“1” selected=“selected”>
<script language="JavaScript type="text/javascript">
<![CDATA[
document.write("<b>Hello World!</b>");
]]>
</script>

XSL - XHTML - Ejercicio
Ejercicio: Convertir a XHTML
<script language="JavaScript" src="myscript.js"></script>
<html>
<body>
Pagina inicio
<br>
<B>Formulario 1</B>
<form name=“form1”>
<img src=“imagen.gif” border=0>
<input type=“checkbox” checked>
</form>
</body>
</html>

XSL - Elementos XSLT
<xsl:template match=“cliente">
<xsl:value-of select="@idCliente"/>
</xsl:template>
• xsl:value-of
devuelve el valor especificado en el atributo select. Puede calcular
el resultado de operaciones aritméticas
<xsl:element name=“a">
Ir a siguiente página
</xsl:element>
• xsl:element
inserta un elemento con el nombre indicado en name

<xsl:if test=“not(@idCliente)">
<b>Falta el dni del cliente</b>
</xsl:if>
• xsl:if
si la evaluación del contenido del atributo test es true, inserta el
contenido del elemento
<a>
<xsl:attribute name=“href">
http://www.com
</xsl:attribute>
Ir a inicio
</a>
• xsl:attribute
añade un atributo al elemento en el que esté contenido. El nombre
del atributo se especifica en el atributo name y su valor se especifica
en el contenido del elemento xsl:attribute.

<xsl:for-each select=“/clientes/cliente">
<i><xsl:value-of select=“@idCliente”/></i><br>
</xsl:for-each>
• xsl:for-each
itera sobre los elementos de la lista que devuelva la expresión
contenida en el atributo select
<xsl:choose>
<xsl:when test=“expresion1”>
...
</xsl:when>
...
<xsl:otherwise>....
</xs:otherwise>
</xsl:choose>
• xsl:choose, xsl:when, xsl:otherwise
instancia el contenido del primer elemento xsl:when cuyo atributo
test devuelva true. Si ningún test se cumple, se instancia el contenido
del elemento xsl:otherwise.

<xsl:comment>
comentario
</xsl:comment>
• xsl:comment
inserta un comentario en el árbol resultante.

genera el código

XSL - Funciones
Estas son las funciones más usadas definidas por XPath.
• position(). Devuelve la posición del nodo actual relativa al
conjunto de nodos del contexto.
• count(conjuntoNodos). Devuelve el número de nodos del
conjunto pasado como parámetro.
• concat(cadena1, cadena2, ...). Devuelve la concatenación de
sus argumentos.
• substring(cadena, inicio, fin). Devuelve la subcadena que
comienza en la posición inicio y termina en fin.
• round(numero). Devuelve el entero más cercano al valor pasado.
• not(boolean). Devuelve la negación del argumento. Si el
argumento no es booleano, lo convierte con la función boolean().
• boolean(objeto). Si objeto es 0, NaN, un conjunto vacío o una
cadena vacía, devuelve false; en otro caso devuelve true.

XSL - Ejercicios
Preparación de la máquina
• Instalación del parser MSXML 3 o superior de Microsoft
• Activación del parser (xmlinst.exe)

XSL - Ejercicio 1
Ejercicio 1: Aplicar plantilla XSL a XML
Ejercicio 1.1
• Modificar el archivo productos.xml para aplicarle la plantilla
productos.xsl
Ejercicio 1.2
• Modificar el archivo productos.xsl para que debajo de cada
código muestre el precio
Ejercicio 1.3
• Modificar el archivo productos.xsl para que debajo de cada
precio muestre una lista de ciudades de procedencia.
Ejercicio 1.4
• Modificar el archivo productos.xsl para que al comienzo
muestre el número total de productos y, delante de cada
producto, aparezca un índice (1,2,...).

XSL - Ejercicio 2
Ejercicio 2: Elementos XSLT
Ejercicio 2.1
• Modificar el archivo productos.xsl para que si el código del
producto es 100, muestre tras el nombre el texto “(Producto en
Oferta)”
Ejercicio 2.2
• Modificar el archivo productos.xsl para que, si el precio es
menor que un euro, muestre tras el nombre el texto “(menos de
1 euro)”
Ejercicio 2.3
• Modificar el fichero productos.xsl para que, debajo de cada
producto, aparezca un botón con el nombre del producto y, al
pulsarlo, muestre su precio.

Aplicaciones Prácticas
DOM
El estándar XML
componen
XML
XSL
XML con XSL
Aplicaciones
Prácticas
Java y Microsoft

Aplicaciones Prácticas - Introducción
XML se usa principalmente en los siguientes entornos:
• Uso de XML conjuntamente con HTML en el cliente.
 Internet Explorer
 Netscape Navigator
• XML en entorno Java
 JAXP
• XML en entorno Microsoft
 MSXML

Aplicaciones Prácticas - Java
• JAXP (Java API for XML Processing) es una librería de
clases de Sun que contiene:
• Un parser XML (Crimson)
• Un procesador XSLT (Xalan)
• Parte de las clases tienen licencia de W3C, y el resto de Apache.
• Puede descargarse libremente desde http://java.sun.com/xml
• Necesita la previa instalación del JDK 1.1.8 (Java Development
Kit) o Java 2 SDK (Software Development Kit)

Uso de las clases de JAXP
Acceso a un documento XML desde un fichero
// Clases de JAVAXP
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
// Excepciones
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
// Acceso a ficheros
import java.io.File;
import java.io.IOException;
// DOM de W3C
import org.w3c.dom.Document;
import org.w3c.dom.DOMException;

// Se declara el documento donde se almacenará el XML
static Document document;
public static void main(String argv[])
{
// Se instancia la clase DocumentBuilderFactory
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
// Se obtiene el xml del archivo
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(new File(“archivo.xml”));
// Se accede al documento
document.getDocumentElement().....
}
Acceso a un documento XML desde un fichero (2)

Aplicaciones Prácticas - Java - Objetos
En JAXP su usan los siguientes objetos. Algunos métodos
cambian ligeramente, pero su significado son el mismo que en
el DOM:
Document
• Element createElement(nombre)
• Text createTextNode(valor)
• Element getDocumentElement()
Element subclase de Node
• String getAttribute(nombre)
• NodeList getElementsByTagName(nombre)
• removeAttribute(nombre)
• setAttribute(nombre,valor)
Text subclase de Node

Node
• appendChild(Node)
• NodeList getChildNodes()
• Node getFirstChild()
• Node getLastChild()
• Node getNextSibling()
• String getNodeValue()
• Node getPreviousSibling()
• removeChild(Node)
NodeList
• int getLength()
• Node item(i)

El método getChildNodes() devuelve una sucesión de elementos
Text y Element intercalados:
<clientes>
Texto1
<cliente>Antonio</cliente>
Texto2
<cliente>Jose</cliente>
Texto3
</clientes>
getChildNodes().item(i)
i Devuelve
0 Text
1 Element
2 Text
3 Element
4 Text

Aplicaciones Prácticas - Java - Ejercicios
Preparación de la máquina
• Instalación de JDK (Java Development Kit) 1.1.8 o superior
 http://java.sun.com/products
• Instalación de JAXP (Java API for XML Processing)
 http://java.sun.com/xml
• Instalación del servidor Web
Por ejemplo: iPlanet Web Server FastTrack Edition
 http://www.iplanet.com/downloads/download/index.html

Aplicaciones Prácticas - Java - Ejercicio 1
Ejercicio 1: Acceso a XML
Ejercicio 1.1
• Compilar la clase ejemplo.java
 javac ejemplo.java (genera el fichero ejemplo.class)
• Ejecutar la clase ejemplo.class
 jview ejemplo clientes.xml
Ejercicio 1.2
• Modificar la clase java acceder.java para que lea un documento
XML pasado como parámetro.
 jview acceder clientes.xml
Ejercicio 1.3
• Modificar la clase acceder.java para que muestre por pantalla el
nombre del segundo cliente
Ejercicio 1.4
• Modificar la clase acceder.java creando un bucle que muestre
todos los atributos idCliente de todos los clientes.

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
Transformación de un documento XML con XSLT

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
File stylesheet = new File(“archivo.xsl”);
File datafile = new File(“archivo.xml”);
document = builder.parse(datafile);
TransformerFactory tFactory = TransformerFactory.newInstance();
StreamSource stylesource = new StreamSource(stylesheet);
Transformer transformer = tFactory.newTransformer(stylesource);
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(System.out);
transformer.transform(source, result);
Transformación de un documento XML con XSLT (2)

Ejercicio 2: Aplicar una plantilla XSL
Ejercicio 2.1
• Crear la clase java conversor.java al que se le pase como
parámetro un documento XSL y un documento XML y que escriba
en un fichero htm de salida el resultado de aplicarle la plantilla
XSL al documento XML.
• Probarla con el documento clientes.xml y la plantilla clientes.xsl
 java conversor clientes.xsl clientes.xml
Ejercicio 2.2
• Modificar la plantilla clientes.xsl para que muestre debajo del
idCliente su dni, y si no tiene, que muestre un mensaje
indicándolo.

Almacenar un documento XML en un archivo
• Usando el Transformer sin aplicarle ningún estilo:
Transformer transformer = tFactory.newTransformer();
StreamResult result = new StreamResult(new FileWriter("salida.xml"));

Ejercicio 3: Modificación de un archivo XML
Ejercicio 3.1
• Crear la clase modificar.java a partir de la clase conversor.java
para que ésta lea el contenido de un documento Xml pasado
como parámetro, inserte un dni en el segundo cliente y guarde
las modificaciones.
Ejercicio 3.2
• Modificar la clase modificar.java para que cree un nuevo cliente
con los siguientes datos:
 Nombre: Javier
 idCliente: 81678
 dni: 55666777

Otros parsers
• JDOM (www.jdom.org)
• XT (http://www.jclark.com/xml/xt.html). Implementación de un
procesador XSLT usando el parser XP.
• Xerces-J (http://xml.apache.org/xerces-j/index.html). Parser
creado por el proyecto Apache XML.

Aplicaciones Prácticas - Java - JSP
Acceso a un documento XML desde JSP
• Se importan las mismas clases que en Java
• Se accede al documento. El fichero leído partirá del directorio
raíz del servidor web:
<%@ page import="javax.xml.parsers.DocumentBuilder" %>
...
<%
Document document;
File xmlFile = new File("public_htmlarchivo.xml");
document = builder.parse(xmlFile);
%>
<%=document.getDocumentElement().....%>

Aplicaciones Prácticas - Java - JSP
Aplicación de XSL desde JSP
• Se importan las mismas clases que en Java
• Se aplica la plantilla y se manda a la variable out:
<%
Document document;
File stylesheet = new File("public_htmlarchivo.xsl");
File datafile = new File("public_htmlarchivo.xml");
document = builder.parse(datafile);
TransformerFactory tFactory = TransformerFactory.newInstance();
StreamSource stylesource = new StreamSource(stylesheet);
Transformer transformer = tFactory.newTransformer(stylesource);
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(out);
transformer.transform(source, result);
%>

Ejercicio 4: Uso de XML con JSP
Ejercicio 4.1
• Modificar el archivo pagina.jsp para que muestre los datos del
archivo cliente.xml de la siguiente forma:
Nombre: Antonio
Código: 81422
Dni: 33555888 ó No tiene
Teléfonos: 952334455 666909090 ó No tiene
Ejercicio 4.2
• Modificar la página pagina2.jsp para que muestre por pantalla
el resultado de aplicar la plantilla clientes.xsl a clientes.xml.
• Modificar el archivo clientes.xsl para que pagina2.jsp muestre el
mismo resultado de pagina.jsp

Aplicaciones Prácticas - Microsoft
• Para usar XML en aplicaciones Microsoft, se usa el objeto COM
Microsoft XML (MSXML).
• Internet Explorer 5 viene con una versión antigua (msxml.dll)
 Objeto Microsoft.XMLDOM
• Se debe instalar una versión más moderna
 Objeto MSXML2.DOMDocument

Acceder a un documento XML
• Si estamos en Visual Basic, añadir el objeto Microsoft XML a las
referencias del proyecto.
• Instanciar el objeto.
 En Visual Basic.
 En ASP
Set objParser = Server.CreateObject("Microsoft.XMLDOM")
Dim objParser As MSXML.DOMDocument
Set objParser = New MSXML.DOMDocument

• Cargar el documento XML
 desde un archivo:
 Desde una cadena de texto:
• Usar el documento (obtener el elemento raíz):
• Destruir el objeto tras usarlo.
Set objParser = nothing
If objParser.Load("c:tempxmldocumento.xml") Then
' Ha funcionado
Else
' Ha ocurrido un error
End If
objParser.loadXML(“<clientes> .... </clientes>”);
objParser.documentElement

Aplicaciones Prácticas - Microsoft -
Ejercicio 1
Ejercicio 1: Acceso a XML desde ASP
Ejercicio 1.1
• Modificar el archivo pagina.asp para que guarde en la variable
domXml el documento almacenado en productos.xml.
• Modificar la página para que muestre el idPedido del primer
pedido del documento XML.
Ejercicio 1.2
• Modificar la página para que aparezca la cantidad del segundo
producto del tercer pedido.
Ejercicio 1.3
• Modificar la página para que muestre los nombres de todos los
productos adquiridos.
Ejercicio 1.4
• Modificar la página para que aparezca el número de cliente del
pedido con idPedido=1002, y la suma de todo su pedido.

Aplicar una plantilla XSLT a un documento XML
<%
Dim domXml As MSXML.DOMDocument
Dim domXsl As MSXML.DOMDocument
Dim resutl As String
Set domXml = New MSXML.DOMDocument
Set domXsl = New MSXML.DOMDocument
domXml.Load("c:documento.xml")
domXsl.Load("c:plantilla.xsl")
result = domXml.transformNode(domXsl)
%>
Mostrar el resultado en ASP
<%=result
%>

Aplicaciones Prácticas - Microsoft -
Ejercicio 2
Ejercicio 2: Aplicación de una plantilla XSL a un
documento XML desde ASP
Ejercicio 2.1
• Modificar el archivo pagina.asp para que muestre el resultado
de aplicar la plantilla productos.xsl al documento productos.xml.
Ejercicio 2.2
• Modificar el archivo productos.xsl para que muestre el siguiente
resultado:
Pedido nº: 1000
Cliente: 123
Productos:
....
Línea Id Nombre Precio Total (euros)
1 315 Patatas fritas 0.9
2... ... .... ....

Recursos
• W3C (Wolrd Wide Web Consorcium)
http://www.w3.org
• Sun
http://java.sun.com/xml
• Microsoft
http://msdn.microsoft.com/xml
• Apache XML Project
http://xml.apache.org
• Otros
http://www.xml.com
http://www.xml.org
http://www.xmlsoftware.com
http://www.xmlhack.com

Xml

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Xml

Último

Xml