XML Tecnologías y sus aplicaciones

Las Tecnologías XML y sus aplicaciones
LAS TECNOLOGÍAS
XML Y SUS
APLICACIONES
Carlos J. Torrecilla Salinas

Junta de Comunidades de Castilla-La Mancha
Consejería de Agricultura
1 de 76
INDICE
INDICE ............................................................................................................... 2
Capitulo 1: ¿Qué es XML?. ................................................................................ 4
1.1. Introducción. ........................................................................................ 4
1.2. Origen de XML. .................................................................................... 4
1.3. Características generales de XML. ...................................................... 4
1.4. Estructura del estándar XML................................................................ 5
1.5. Uso de XML. ........................................................................................ 5
Capítulo 2: Estructura y sintaxis de XML............................................................ 6
2.1. Estructura de los documentos XML. .................................................... 6
2.1.1. Documentos XML bien formados.................................................. 6
2.1.2. Documentos XML validos. ............................................................ 7
2.2. Sintaxis XML. ....................................................................................... 7
2.2.1. Cabecera XML. ............................................................................. 7
2.2.2. Comentarios.................................................................................. 8
2.2.3. Elementos. .................................................................................... 8
2.2.3.1. Elementos sin atributos con datos. ........................................ 9
2.2.3.2. Elementos con atributos y datos............................................ 9
2.2.3.3. Elementos con atributos sin datos. ........................................ 9
2.2.3.4. Elementos vacíos. ............................................................... 10
2.2.4. Atributos...................................................................................... 10
2.2.5. Entidades. ................................................................................... 10
2.2.6. Primer ejemplo............................................................................ 11
Capítulo 3: Restricciones sobre los documentos XML. .................................... 12
3.1. Introducción. ...................................................................................... 12
3.2. DTD.................................................................................................... 12
3.2.1. Introducción y concepto. ............................................................. 12
3.2.2. Sintaxis DTD. .............................................................................. 12
3.2.2.1. Elementos............................................................................ 12
3.2.2.2. Atributos............................................................................... 15
3.2.2.3. Entidades............................................................................. 16
3.2.2.4. Relación entre DTD y XML. ................................................. 16
3.2.2.5. Ejemplos. ............................................................................. 17
3.3. XML Schema. .................................................................................... 20
3.3.2. Sintaxis XML Schema................................................................. 21
3.3.2.1. Tipos de datos ..................................................................... 21
3.3.2.2. Ejemplo................................................................................ 26
Capítulo 4: XML Namespaces.......................................................................... 29
Capítulo 5: XSL ................................................................................................ 31
5.1. Introducción ....................................................................................... 31
5.2. XSLT .................................................................................................. 31
5.2.2. Sintaxis. ...................................................................................... 31
5.2.2.1. Estructura básica. ................................................................ 32
5.2.2.2. Etiquetas.............................................................................. 32
5.2.2.3. Ejemplos. ............................................................................. 34
5.3. XPath ................................................................................................. 41
2 de 76
5.3.1. Introducción y concepto .............................................................. 41

5.3.2. Sintaxis ....................................................................................... 41
5.3.2.1. Ruta de localización............................................................. 41
5.3.3. Ejemplos. .................................................................................... 42
5.4. XSL-FO .............................................................................................. 44
5.4.1. Introducción. ............................................................................... 44
5.4.2. Características básicas............................................................... 45
5.4.3. Espacio de nombres Formatting Objects .................................... 45
5.4.4. Etiquetas FO. .............................................................................. 45
5.4.4.1. Descripción de páginas ....................................................... 45
5.4.4.2. Contenido ............................................................................ 47
5.4.5. Ejemplo. ...................................................................................... 47
Capítulo 6: Analizadores .................................................................................. 50
6.1. Introducción. ...................................................................................... 50
6.2. SAX.................................................................................................... 50
6.3. DOM................................................................................................... 50
Capítulo 7: XML en ORACLE 9i. ...................................................................... 51
7.1. SQLX, generando XML a partir de datos en SGBDR......................... 51
7.2. Ejemplos. ........................................................................................... 51
Capítulo 8: XQUERY........................................................................................ 53
8.1. Introducción. ...................................................................................... 53
8.2. Expresiones FLWOR ......................................................................... 54
Capítulo 9: Sindicación de contenidos y RSS .................................................. 58
9.1. Introducción. ...................................................................................... 58
9.2. Usos de RSS. .................................................................................... 58
9.2.1. Cómo usar el RSS para recibir información ................................ 58
9.2.2. Cómo usar el RSS para ofrecer información .............................. 59
9.3. Como crear un RSS. .......................................................................... 59
Capítulo 10: SOAP (Simple Object Access Protocol)....................................... 62
10.1. Introducción. ................................................................................... 62
10.2. Web Services. ................................................................................ 62
10.2.1. Lenguaje de descripción de servicios Web (WSDL – Web
Services Description Language). .............................................................. 62
10.2.2. UDDI (Universal Description, Discovery and Integration) ........... 63
10.2.3. WSIL (Web Service Inspection Language). ................................ 63
10.2.4. Ejemplo de funcionamiento......................................................... 63
Capítulo 10: Casos Prácticos. .......................................................................... 65
10.1. Caso práctico 1............................................................................... 65
10.2. Caso práctico 2............................................................................... 70
3 de 76
Capitulo 1: ¿Qué es XML?

1.1. Introducción.
El objeto de este manual es explicar el uso de las tecnologías basadas en XML
(eXtensible Markup Language), metalenguaje extensible de etiquetas desarrollado y
estandarizado por el W3C (World Wide Web Consortium), que originalmente se diseño para la
publicación electrónica a gran escala y que actualmente se está implantando como estándar
para el intercambio de información entre diferentes aplicaciones, adquiriendo gran relevancia
ya que permite la compatibilidad entre sistemas para compartir la información de una manera
segura, fiable y fácil, pudiéndose usar en bases de datos, editores de texto, hojas de cálculo...
XML es de vital importancia para los Webservices, una de las tecnologías más pujantes
actualmente, ya que muchos de los estándares involucrados en la implementación y el uso de
éstos están basados en tecnologías XML (tales como WSDL, WSIL o SOAP).
1.2. Origen de XML.

XML surgió como una variante de SGML (Standard Generalized Markup Language –
ISO 8879), el cual provenía, a su vez, de un lenguaje inventado por IBM en los años 60: el
GML (Generalized Markup Language) y que tenía como objetivo el permitir separar el formato
de un documento de su contenido.
En 1986, ISO comenzó los trabajos de normalización de GML, creando SGML, que es
un estándar sobre cómo especificar un lenguaje de marcas. Es lo que se conoce como
metalenguaje.
Como derivado de SGML, surgió en 1989 el lenguaje HTML, utilizado para la creación
de páginas Web. Y a partir de 1996, el W3C, comenzó el desarrollo de XML, en el que aún
continúa.
En febrero de 2004 se publicó la recomendación XML 1.1.
1.3. Características generales de XML.

Como se ha comentado anteriormente, XML es un metalenguaje, es decir que es un
lenguaje que nos permite definir lenguajes de marcas propios para múltiples clases de
documentos. Es decir es un conjunto de reglas que permiten definir etiquetas semánticas para
dividir un documento en diferentes partes.
Llamaremos marca, etiqueta o tag a un elemento encerrado entre los elementos menor
que y mayor que (< y >).
Las características principales de XML son:
• Su formato es texto plano, usando caracteres Unicode (es decir de 16 bits).

• Es un lenguaje de marcas, que usa etiquetas y atributos, no estando estos
preestablecidos.
• Es un lenguaje sintácticamente estricto, que no obvia ningún error.
• XML es una familia de tecnologías.
• Los ficheros XML son extensos.
• XML es un estándar gratuito multiplataforma producido por el W3C.
• Es una arquitectura más abierta y extensible.
• Proporciona mayor consistencia, homogeneidad y amplitud de los identificadores
descriptivos del documento en comparación a los atributos <META> del HTML.
• Permite la integración de los datos de las fuentes más dispares.
• Permite agrupar datos compuestos de múltiples aplicaciones.
4 de 76
Aplicación SGML
Las Tecnologías XML y sus aplicaciones HTML
SGML
XML Aplicación XML

XHTML
1.4. Estructura del estándar XML.

El metalenguaje XML consta de cuatro especificaciones:
• DTD (Document Type Definition): Definición de tipo de documento.

• XSL (eXtensible Stylesheet Language): Define o implementa hojas de estilo para
documentos XML. Consta de tres partes:
o XSLT (XSL Transformation): Lenguaje que transforma documentos XML en
otros documentos XML.
o XPath: Es un lenguaje que permite acceder o referirse a partes de un
documento XML.
o XSL-FO (XSL Formatting Objects): Lenguaje que permite la transformación
de documentos XML a formatos de presentación de tipo binario.
• XLL (eXtensible Linking Language): Define como enlazar diferentes documentos
XML.
• XUA (XML User Agent): Estandarización de los navegadores XML.
1.5. Uso de XML.

La potencia de XML permite que éste pueda ser utilizado para múltiples fines, entre los
que cabe destacar:
• Meta información: Uso de XML para describir meta-contenidos (información relativa al

contenido de un documento, tal como su autor, fecha de creación, palabras clave...)
respecto a documentos o recursos en línea.
• Bases de datos: Uso de XML para publicar e intercambiar contenidos de Bases de
Datos.
• Mensajería: Uso de XML como formato para sistemas de mensajería con el fin de
permitir la comunicación entre diferentes aplicaciones.
5 de 76
Capítulo 2: Estructura y sintaxis de XML.

2.1. Estructura de los documentos XML.
Un documento XML es una forma de representación digital de un contenido, y todos los
documentos XML contienen los siguientes elementos:
• Prólogo (o cabecera): En el se agrupan la declaración de documento XML, las

instrucciones de procesamiento y la declaración de tipo de documento.
• Elemento raíz o entidad documento: Cada documento XML tiene un elemento raíz,
que engloba al resto y que solo puede aparecer una vez en el documento.
• Árbol: Contiene los elementos del documento, que son los componentes lógicos del
documento, y que se indican mediante marcas explicitas. Estos elementos se pueden
componer de otros elementos, surgiendo una jerarquía que conforma una estructura en
árbol.
El texto de un documento XML esta compuesto por caracteres, usándose la

codificación UNICODE, cuyos 128 primeros caracteres son compatibles con ASCII 7 bits, lo
que permite que se puedan usar editores de texto estándar para generar documentos XML.
Para el español conviene usar el juego de caracteres Latin-1 (ISO-8859-1).
2.1.1. Documentos XML bien formados.

Todos los documentos XML deben estar bien formados, lo que significa que todos los
documentos deben cumplir lo siguiente:
• Si no se usa DTD, el documento debe comenzar con un Declaración de Documento

Standalone: <?xml version=" 1.0 " encoding=" UTF-8 " standalone= "
yes "?>
• Todas las etiquetas deben estar balanceadas o equilibradas: Esto es, todos los
elementos que contengan datos de tipo carácter deben tener etiquetas de principio y fin
• Todos los valores de los atributos deben ir entrecomillados.
• Cualquier elemento VACÍO deben terminar con '/>' o debe hacerse no VACÍO.
• No debe haber etiquetas aisladas (< ó &) en el texto
• Los elementos deben anidar dentro de sí sus propiedades.
• Los ficheros bien-formados sin-DTD pueden utilizar atributos en sus elementos, pero
éstos deben ser todos del tipo CDATA, por defecto. El tipo CDATA representa
caracteres.
• Los nombres de etiquetas pueden ser alfanuméricos, comenzando con una letra e
incluyendo los caracteres – y :, aunque este con un significado especial.
• Los comentarios son: 
• En elementos y atributos, las mayúsculas y minúsculas son letras distintas.
Según la especificación de XML del W3C, un documento XML está bien formado si:
• Tomado como un todo, cumple la regla denominada "document". Lo que significa que:
• Que contiene uno o más elementos.
• Hay exactamente un elemento, llamado raíz, o elemento documento, del cual
ninguna parte aparece en el contenido de ningún otro elemento.
• Para el resto de elementos, si la etiqueta de comienzo está en el contenido de
algún otro elemento, la etiqueta de fin está en el contenido del mismo elemento. Es
decir, los elementos delimitados por etiquetas de principio y final se anidan
adecuadamente mutuamente.
• Respeta todas las restricciones de buena formación dadas en la especificación.
• Cada una de las entidades analizadas que se referencia directa o indirectamente en el
documento está bien formada.
6 de 76
2.1.2. Documentos XML validos.
Una documento validador proporciona la gramática para un tipo de documentos XML,

es decir especifica que etiquetas, en que orden, dentro de qué otras, que atributos... pueden
existir en un tipo de documentos XML concretos.
Para especificar cada tipo de documentos se utilizan unos lenguajes propios y

específicos. Estos lenguajes, que sirven para definir otros lenguajes, se denominan
metalenguajes. Existen varios metalenguajes para definir los lenguajes que se pueden obtener
a partir de XML, siendo los más populares, el DTD y el XML Schema o Esquemas XML, que
posteriormente se explicarán.
Una DTD puede residir en un fichero externo, y quizás compartido por varios (puede
que miles) de documentos. O bien, puede estar contenido en el propio documento XML, como
parte de su declaración de tipo de documento.
Los documentos que se ajustan a su DTD, se denominan "válidos". El concepto de

"validez" no tiene nada que ver con el de estar "bien formado". Un documento "bien formado"
simplemente respeta la estructura y sintaxis definida por la especificación de XML. Un
documento "bien formado" puede además ser "válido" si cumple las reglas de una DTD
determinada. También existen documentos XML sin una DTD asociada, en ese caso no son
"válido", pero tampoco "inválido"... simplemente "bien formados"... o no.
Resumiendo, los documentos XML podrán ser:
• Documentos XML bien formados. Son aquellos que respetan la sintaxis del XML.
• Documentos XML validos. Son aquellos que además de bien formados se ajustan a
la DTD que define su estructura.
2.2. Sintaxis XML.

A continuación se describirá brevemente como codificar un documento XML,
especificando la sintaxis de cada una de las partes que lo componen.
2.2.1. Cabecera XML.

La cabecera XML es donde se realizan las primeras definiciones que afectarán al
documento. En esta zona se indican aspectos tan importantes como la manera en que se ha
codificado la información o que archivos se usan para validar la información.
En la cabecera XML se incluyen los siguientes elementos: la declaración XML,

instrucciones de procesamiento y declaraciones de tipo de documentos.
Declaración XML: Indica que el documento es un documento XML, y tiene la siguiente

estructura:
<?xml version=”1.0” encoding=”ISO-8859-1” standalone=”yes” ?>
Incluye tres atributos:
• version: Indica la versión de XML que se utilizará en el documento.

• encoding: Indica el juego de caracteres utilizado.
• standalone: Indica si el documento sigue una Declaración de Tipo de Documento. Si
standalone es yes, el procesador no espera ninguna Declaración de Tipo de
Documento externa, si vale no, espera una Declaración de Tipo de Documento externa.
Instrucciones de procesamiento: Es una instrucción interpretada por la aplicación a

la que se destina, no formando parte completamente del documento XML. Las más utilizadas
7 de 76
son la declaración de documento XML y la declaración de hoja de estilo. Tienen la siguiente

estructura:
<?application atributo1=”valor” atributo2=”valor” ... ?>
Hay que aclarar algunos puntos sobre este tipo de marcas:
• No pueden existir espacios en blanco entre el carácter “<” y el carácter “?”.

• Los datos a procesar comienzan tras el primer espacio en blanco encontrado, con lo
que la marca se debe escribir:
<?application atributo1=”valor” atributo2=”valor” ... ?>
Y no:
<? application atributo1=”valor” atributo2=”valor” ... ?>
• Dentro de los valores de los atributos si se pueden escribir espacios en blanco, siempre
que el valor del dato vaya entrecomillado:
<?application atributo1=”valor del atributo”?>
Anteriormente hemos visto la declaración de documento XML, mientras que la

declaración de hoja de estilo tiene la siguiente estructura:
<?xml-stylesheet type=”text/xsl” href=”hoja.xsl” ?>
Declaración de Tipo de Documento: Puede ser externa o interna. Si forma parte del
documento XML se denomina interna, y si esta en un archivo independiente, para que pueda
ser reutilizada en otros documentos XML, se denomina externa..
Las DTD externas pueden ser privadas o públicas, siendo las primeras solo accesibles
localmente y las segundas accesibles mediante una URI.
Una declaración usando DTD tiene la forma:
<!DOCTYPE elt.raiz declaraciones>
Si la DTD es externa, las declaraciones pueden ser SYSTEM (indica que el archivo
externo esta en el ordenador local) o PUBLIC (indica que el fichero esta disponible en un
servidor Web público).
A continuación podemos ver un ejemplo de una declaración de tipo de documento

externa usando DTD:
<!DOCTYPE definicion.dtd SYSTEM “definicion.dtd”>
2.2.2. Comentarios.
Como el resto de lenguajes, XML permite que se inserten comentarios, de manera que
se pueda aclarar la codificación. Los comentarios en XML tienen la misma estructura que en
HTML:

Los comentarios se pueden introducir en cualquier parte del documento y pueden

extenderse varias líneas.
2.2.3. Elementos.
Los elementos son los principales componentes del contenido del documento. Pueden
contener texto u otros elementos, denominando elemento padre a aquel que contiene otros
elementos, y elementos hijos a los contenidos.
Podemos ver algunos ejemplos:
8 de 76
<elemento1>Uno</elemento1>
<elemento1>
<subelemento1>Uno</subelemento1>
</elemento1>
Los elementos pueden ser de los siguientes tipos:
• Elementos sin atributos con datos.

• Elementos con atributos y datos.
• Elementos con atributos sin datos.
• Elementos vacíos.
2.2.3.1. Elementos sin atributos con datos.

Los elementos sin atributos con datos solo tienen datos entre las etiquetas de apertura
y de cierre, tratándose como un todo lo que se encuentre entre ambas etiquetas, el cual va a
representar el valor que corresponde a la variable que indican las marcas.
Así en el caso de los siguientes ejemplos:
<etiqueta1>Valor</etiqueta1>
<etiqueta2>Texto asignado a la variable</etiqueta2>
Equivaldría a asignar:
etiqueta1 = Valor.
etiqueta2 = “Texto asignado a la variable”.
2.2.3.2. Elementos con atributos y datos.

Este tipo elementos además de contener información entre las etiquetas de apertura y
cierre, tienen atributos, similares a los que aparecen en HTML, y que contienen información
adicional que complementa a la proporcionada por el elemento.
Un ejemplo será:
<elemento1 atributo=”valor”>Datos</elemento1>
2.2.3.3. Elementos con atributos sin datos.

Como se ha visto en el apartado anterior, los atributos pueden proporcionar información
por si mismos, con lo cual es posible la creación de elementos e los que toda la información a
transmitir se codifique en ellos sin necesidad de elementos hijos.
Podemos ver el siguiente ejemplo:
<elemento1 atributo=”valor” valor=”Datos”></elemento1>
Que será equivalente a:
<elemento1 atributo=”valor” valor=”Datos”/>
9 de 76
2.2.3.4. Elementos vacíos.

Existen algunos casos en los que puede ser interesante el no indicar ningún valor para
un elemento, en este caso hablamos de elementos vacíos que se pueden representar de dos
maneras:
<elemento1></elemento1>
O bien, de modo abreviado:
<elemento1/>
Este modo abreviado permite indicar el comienzo y cierre del elemento con una sola
marca, que representa a ambos, con lo que cumple la normativa XML.
2.2.4. Atributos.
Como se ha comentado anteriormente, los atributos son modificadores que se añaden
a los elementos, a los que añaden información adicional.
Los atributos, de manera similar a HTML, se forman mediante un identificador, un signo

igual y el valor del atributo, el cual y a diferencia de HTML, debe ir obligatoriamente
entrecomillado, tanto si contiene espacios en blanco, como si no.
Los elementos pueden contener uno o varios atributos, pero cada elemento solo puede
contener un mismo atributo una única vez, de lo contrario sería un documento XML “no bien
formado”, como se vio en el capitulo anterior.
Un ejemplo de uso de atributos puede ser:
<elemento1 atributo=”valor”>Datos</elemento1>
<elemento1 atributo=”valor” valor=”Datos”/>
La decisión de añadir un atributo o un elemento hijo a un elemento es una decisión de

diseño, que corresponde al programador, debiendo ser él, el que en función de los requisitos
del problema concreto, elija entre ambas opciones siendo, usualmente, ambas válidas.
2.2.5. Entidades.
Las entidades son unidades de almacenamiento, que pueden contener desde un
carácter hasta el nombre de un fichero que se quiera incluir en el XML.
Las entidades tienen la siguiente forma:
&entidad;
Suelen usarse para reemplazar una cadena que aparece muchas veces en el
documento, de forma similar a como se usan las constantes en otros lenguajes.
Otro uso muy normal es el de sustituir a cadenas de texto excesivamente largas y

también a caracteres extraños, como la ñ.
Las entidades pueden ser de dos tipos: definibles (si las define el programador) y
predefinidas (que son aquellas definidas de antemano y que permiten mostrar los caracteres
reservados, tales como < o >).
Las entidades se definen en la DTD, y un ejemplo de su uso puede ser:
<elemento1>&entidad;</elemento1>
10 de 76
2.2.6. Primer ejemplo.

Con lo que se ha expuesto hasta ahora es posible escribir el primer documento XML de
ejemplo, que simulará una agenda de contactos, en la que se incluirá el contacto, su teléfono y
su dirección:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>

<agenda>
<contacto fecha="3/4/1999">
<nombre>Antonio Perez</nombre>
<direccion>C/ Pez, 2</direccion>
<telefono numero="999888777"/>
</contacto>
<nombre>Luis Lopez</nombre>
<direccion>Avda. Ancha, 4</direccion>
</contacto>
<nombre>Angela Jimenez</nombre>
<direccion>Plza. Libertad, 8</direccion>
</contacto>
</agenda>
11 de 76
Capítulo 3: Restricciones sobre los documentos XML.

3.1. Introducción.
Como hemos visto, es necesario indicar al sistema que datos debe esperar en un
determinado documento XML y en que formato se esperan. Es decir cual debe ser la estructura
(elementos, atributos, jerarquía...) que debe tener un documento XML.
Para ello se utilizan los documentos validadores, que, como se ha descrito

anteriormente, permiten al programador moldear la estructura del documento XML, estos
documentos validadores tienen las siguientes funciones principales:
• Indicar el nombre de cada elemento.

• Indicar la jerarquía del documento.
• Indicar los tipos de datos.
Existen varios lenguajes para definir este tipo de documentos, pero los más usados son
los DTD y los XML Schema, que son los que se describirán a continuación
3.2. DTD.
3.2.1. Introducción y concepto.

El documento DTD (Document Type Definition – Definición de Tipo de Documento) es
un documento en texto plano que contiene la definición formal de un tipo de documento XML
en particular. Una DTD no es más que un conjunto de declaraciones que definen los
elementos, atributos, entidades, jerarquías que aparecen en un tipo de documento concreto
El DTD tiene una sintaxis distinta a la de XML, muy sencilla, ya que esta basada en
SGML, sin embargo es un lenguaje menos flexible que XML Schema, y su uso no esta
permitido en muchas aplicaciones (como es el caso de SOAP), sin embargo su estudio puede
facilitar la comprensión de los esquemas XML.
3.2.2. Sintaxis DTD.

En DTD existen:
• Elementos.
• Atributos.
• Entidades.
Que se describirán a continuación:
3.2.2.1. Elementos
La declaración de un elemento en una DTD define las características que tendrá una
etiqueta XML. Su sintaxis es:
<!ELEMENT nombreElemento (contenidoDeElemento)>
Pueden ser de los siguientes tipos:
Elementos sin contenido: Estas declaraciones definen etiquetas sin contenido. Su

sintaxis será:
<!ELEMENT nombreElemento (EMPTY)>
12 de 76
Un elemento que cumpliría con la definición anterior sería:
<nombreElemento/>
Elementos conteniendo datos: Definen etiquetas que contienen datos. Estos datos
pueden ser de dos tipos: #PCDATA (Si los datos pueden ser analizados) o #CDATA (Si los
datos no pueden ser analizados), o ambos con ANY.
Un ejemplo de su sintaxis es:
<!ELEMENT elemento (#PCDATA)>
Una etiqueta valida con esta declaración sería:
<nombreElemento>Valor</nombreElemento>
Elementos conteniendo otros elementos: Estas declaraciones definen etiquetas

dentro de las cuales se pueden definir otras etiquetas, permitiendo obtener distintos niveles de
dependencia jerárquica.
Su sintaxis es:
<!ELEMENT nombreElemento (elementoHijo1, elementoHijo2,...)>
Cuando se realiza una declaración como esta, en la que se tiene varios elementos hijos
separados por comas, a continuación hay que declarar estos en el mismo orden.
Los elementos hijos pueden ser a su vez elementos padres de otros elementos, lo cual
habrá que definir en la DTD.
Podemos ver un ejemplo:
<!ELEMENT nombre_completo (nombre, apellido1, apellido2)>

<!ELEMENT nombre (#PCDATA)>
<!ELEMENT apellido1 (#PCDATA)>
Una etiqueta que seguiría esta definición será:
<nombre_completo>
<nombre>Antonio</nombre>
<apellido1>Lopez</apellido1>
<apellido2>Perez</apellido2>
</nombre_completo>
Elementos conteniendo modificadores: Los modificadores sirven para poder indicar

el número de elementos que contiene una etiqueta, aunque no se controla de manera exacta
las ocurrencias de cada elemento
Para controlar el número de apariciones de un elemento se coloca un modificador tras

su nombre, y, por defecto, si no aparece ningún modificador, el número de ocurrencias de ese
elemento será igual a uno.
Los modificadores validos son:
?: Indica que el elemento aparece una o ninguna vez. Por ejemplo
<!ELEMENT elemento1 (subelemento1?)>

<!ELEMENT subelemento1 (#PCDATA)>
Una etiqueta valida será
13 de 76
<elemento1>
<subelemento1>Valor</subelemento1>
</elemento1>
O también:
<elemento1/>
+: Indica El elemento aparece una o más veces, pero al menos una vez. Un ejemplo:
<!ELEMENT elemento (subelemento+)>

<!ELEMENT subelemento (#PCDATA)>
Una etiqueta valida será:
<elemento>
<subelemento>Valor</subelemento>
</elemento>
O también:
<elemento>
<subelemento>Valor1</subelemento>
</elemento>
Mientras que la siguiente etiqueta NO sería valida:
<elemento/>
*: Indica que el elemento aparece ninguna, una o más veces. Un ejemplo podría ser:
<!ELEMENT elemento (subelemento*)>

<!ELEMENT subelemento (#PCDATA)>
Una etiqueta valida será:
<elemento>
<subelemento>Valor</subelemento>
</elemento>
O también:
<elemento>
</elemento>
E incluso:
<elemento></elemento>
,: Este modificador se usa para separar elementos hijo dentro de la definición.
<!ELEMENT nombre_completo (nombre, apellido1, apellido2)>
|: Este modificador se usa para indicar una operación O (OR),es decir que aparece el
elemento de la derecha, o el de la izquierda, pero no los dos.
14 de 76
<!ELEMENT elemento (subelemento1|subelemento2)>

Una etiqueta valida sería:
<elemento>
</elemento>
O también:
<elemento>
</elemento>
Pero NO sería valida:
<elemento>
<subelemento1>Valor</ subelemento1>
</elemento>
Es posible usar combinaciones entre estos modificadores para conseguir los elementos
que se necesite.
<!ELEMENT elemento (sub1, sub2?, sub3+, sub4*)>
En este caso, por cada elemento, solo podría aparecer un sub1, uno o ningún sub2,
uno o más sub3 y uno, muchos o ningún sub4.
También es posible aplicar estos modificadores a listas de varios elementos como por
ejemplo:
<!ELEMENT libro (autor, capitulo, pagina)+>
De manera que por cada libro puede haber uno o más autor, capitulo y pagina.
3.2.2.2. Atributos
Los atributos son modificadores de los elementos que complementan la información
que estos proporcionan.
Su sintaxis es:
<!ATTLIST nombreElem nombreAtrib tipoAtrib modificadorValor>
Donde:
• nombreElem: Indica el elemento al que se le añade el/los atributo/s.

• nombreAtrib: el nombre que se le da al atributo.
• tipoAtrib: indicará el carácter del atributo, pudiendo tomar los valores:
o CDATA: Valor alfanumérico sobre el que no se realiza análisis.
o (dato|dato|...): Toma un valor de los de la numeración.
o ID: Contenido único en todo el documento para identificar de manera univoca
al elemento.
o IDREF: valor referido al identificador de otro elemento.
o IDREFS: El valor es una lista de IDREF, separados por espacios en blanco,
tabuladores o nuevas líneas.
o NMTOKEN: El valor es un nombre xml valido.
15 de 76
o NMTOKENS: El valor es una lista de NMTOKEN, separados por espacios en

blanco, tabuladores o nuevas líneas.
o ENTITY: El valor es una entidad definida en el DTD previamente.
o ENTITIES: El valor es una lista de ENTITY, separados por espacios en blanco,
tabuladores o nuevas líneas.
o NOTATION: El contenido es un nombre de una notación, que describe datos
o XML: El valor está predefinido.
• ModificadorValor: fija el comportamiento del atributo, pudiendo ser:
o #DEFAULT valorPorDefecto: el atributo tiene como valor por defecto el
indicado en la declaración.
o #REQUIRED: El valor es obligatorio.
o #IMPLIED: El valor esta implícito.
o #FIXED valor: El valor es fijo, y no puede cambiar en el documento.
Un ejemplo puede ser:
<!ELEMENT persona (#PCDATA)>

<!ATTLIST persona id ID #REQUIRED>
<!ATTLIST persona edad CDATA #IMPLIED>
<!ATTLIST persona cargo (jefe|trabajador) #REQUIRED>
3.2.2.3. Entidades
Se utilizan para abreviar textos a la hora de escribir el XML.
Las entidades son referenciadas con &nombreEntidad, y con ellas podemos referenciar
caracteres extraños (ñ) o frases largas que se repiten mucho.
Su sintaxis es:
<!ENTITY nombreEntidad valorAsociado>
Un ejemplo puede ser:
<!ENTITY titulo “Introducción a la programación en XML”>
Y su uso:
<curso>&titulo;</curso>
Las declaraciones de entidades pueden realizarse externamente al DTD, haciendo

referencia a los archivos que los contienen mediante una URL:
<!ENTITY nombre SYSTEM URL>
3.2.2.4. Relación entre DTD y XML.

Una vez que se tiene la plantilla que especifica las reglas que ha de seguir el
documento XML, es necesario especificar como se va a relacionar dicha plantilla con el
documento XML, lo que se puede llevar acabo de dos maneras:
• Dentro del documento XML, al principio de este, tras la cabecera XML, con una
declaración de tipo de documento:
<!DOCTYPE elementoRaiz [

]>
16 de 76
• Referenciando a un documento externo con: Documento en el que se habrán

almacenado todas las definiciones, y que suele tener la extensión .dtd.
<!DOCTYPE elementoRaiz SYSTEM “nombrefichero.dtd”>
3.2.2.5. Ejemplos.
Se quiere diseñar un modelo para que los funcionarios propongan preguntas para los
exámenes de oposición, cada pregunta debe incluir el autor, indicando el cuerpo, sus datos
personales, su teléfono y su email, y también la pregunta, con su enunciado, su respuesta
correcta, cinco señuelos y la justificación de la respuesta.
Vamos a diseñar primero el modelo del objeto documento que debe seguir este
documento, tras lo cual generaremos la DTD, y por ultimo mostraremos un ejemplo del citado
documento.
El modelo de objeto documento será:
Pregunta_Candidata
Señuelo1
Autor Pregunta
Señuelo5
Cuerpo Nombre Apellido1 Enunciado Justificación
Telefono eMail Apellido2

Respuesta
Y la definición de tipo de documento:
<!ELEMENT pregunta_candidata (autor, pregunta)>

<!ELEMENT autor (cuerpo, nombre, apellido1, apellido2, telefono,
mail)>
<!ELEMENT cuerpo (#PCDATA)>
<!ELEMENT telefono EMPTY>
<!ATTLIST telefono numero CDATA #REQUIRED>
<!ELEMENT mail EMPTY>
<!ATTLIST mail direccion CDATA #REQUIRED>
<!ELEMENT pregunta (enunciado, respuesta, senyuelo+,
justificacion)>
<!ELEMENT enunciado (#PCDATA)>
17 de 76
<!ELEMENT respuesta (#PCDATA)>

<!ELEMENT senyuelo (#PCDATA)>
<!ELEMENT justificacion (#PCDATA)>
Dicha DTD se almacenara en el fichero “pregunta_candidata.dtd”
Un ejemplo de documento xml será:
<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>

<!DOCTYPE pregunta_candidata SYSTEM "pregunta_candidata.dtd">
<pregunta_candidata>
<autor>
<cuerpo>Superior de Sistemas y Tecnología de la
Información</cuerpo>
<nombre>Luis</nombre>
<apellido2>Sala</apellido2>
<telefono numero= "91999999"/>
<mail direccion="luisperezsala@map.es"/>
</autor>
<pregunta>
<enunciado>¿En que puerto opera el protocolo
LDAP?</enunciado>
<respuesta>En el puerto 389</respuesta>
<senyuelo> En el puerto 300</senyuelo>
<justificacion>Este es el puerto registrado por la
ICANN para el protocolo LDAP</justificacion>
</pregunta>
</pregunta_candidata>
Que se almacenaría en el documento “pregunta_candidata.xml”.
Otro ejemplo podría ser el modelado de un sistema para otorgar citas a personas
físicas o jurídicas, indicando la fecha y quien les atenderá.
El problema tendrá los siguientes requisitos:
• Cada respuesta contendrá el NIF o CIF de la persona.

• Cada respuesta indicará de que tipo es esa persona.
• Se indicarán los datos personales de la misma
• Se indicará la fecha de la cita.
• Se indicará el asesor o asesores que le atenderán.
• De cada asesor se indicará su nombre, teléfono y ubicación.
18 de 76
Del cual se puede obtener el siguiente modelo de objeto documento:
RESPUESTA
NIF/CIF Tipo Datos Fecha Asesor1 AsesorN

Personales
Apellido1 Apellido2
Nombre
Una respuesta estará compuesta por los siguientes elementos:
o NIF/CIF: Identifica al usuario solicitante, es único y deber aparecer siempre.

o Tipo: Indica si es una persona física o jurídica. Es único y deberá aparecer siempre.
o Datos Personales:
o Nombre: Nombre de la persona o razón social de la empresa. Es único y
aparece siempre.
o Apellido1: Primer apellido de la persona. Es único y solo aparece si el usuario
es persona física
o Apellido2: Segundo apellido de la persona. Es único y solo aparece si el
usuario es persona física.
o Fecha: Indica la fecha asignada para la cita. Es única y aparece siempre.
o Asesor1...AsesorN: Asesores asignados para resolver la solicitud. Siempre aparece al
menos uno, y pueden aparecer varios. Cada asesor tendrá como atributos su nombre,
la mesa o despacho y el teléfono desde el que atenderán al usuario.
Podemos ver dos posibles soluciones DTD para el problema:
<!ELEMENT respuesta ((nif|cif),datos,asesor+)>

<!ATTLIST respuesta fecha CDATA #REQUIRED>
<!ELEMENT nif (#PCDATA)>
<!ELEMENT cif (#PCDATA)>
<!ELEMENT datos EMPTY>
<!ATTLIST datos nombre CDATA #REQUIRED>
<!ATTLIST datos apellido1 CDATA #IMPLIED>
<!ELEMENT asesor (nombre,ubicacion)>
<!ATTLIST asesor telefono CDATA #REQUIRED>
<!ELEMENT ubicacion (#PCDATA)>
Que se almacenará en el documento “respuesta.dtd” y a la que se ajustaría el siguiente

documento XML:

<!DOCTYPE respuesta SYSTEM "respuesta.dtd">
<respuesta fecha="16/10/2006">
<nif>78678765P</nif>
<datos nombre="Antonio" apellido1="Perez"
apellido2="Lopez"/>
<asesor telefono="987987987">
19 de 76
<nombre>Jose Lopez</nombre>
<ubicacion>Despacho 670</ubicacion>
</asesor>
<nombre>Luis Martinez</nombre>
</asesor>
</respuesta>
Y también:
<!ELEMENT respuesta (identificacion, datos, fecha, asesor+)>

<!ELEMENT identificacion (#PCDATA)>
<!ATTLIST identificacion tipo (fisica|juridica) #REQUIRED>
<!ELEMENT datos (nombre,apellido1?,apellido2?)>
<!ELEMENT fecha (#PCDATA)>
<!ELEMENT asesor (nombre_asesor,ubicacion)>
<!ELEMENT nombre_asesor (#PCDATA)>
Que se almacenará en el fichero “respuesta1.dtd” y a la que se ajustaría este otro

documento XML:

<!DOCTYPE respuesta SYSTEM "respuesta1.dtd">
<respuesta>
<identificacion tipo="fisica">78678765P</identificacion>
<datos>
</datos>
<fecha>16/10/2006</fecha>
<nombre_asesor>Jose Lopez</nombre_asesor>
</asesor>
<nombre_asesor>Luis Martinez</nombre_asesor>
</asesor>
</respuesta>
3.3. XML Schema.

DTD tiene muchas limitaciones, entre las que podemos destacar:
• DTD tiene una sintaxis distinta a la de XML, lo que provoca problemas a la hora del
aprendizaje.
• DTD tiene un tipado de datos extremadamente limitado.
• DTD no permite un control estricto del número de ocurrencias
Debido a estos y otros inconvenientes, el W3C intentó encontrar una manera de

escribir en XML la definición de otro lenguaje XML. Surgió así el lenguaje XML Schema, que
20 de 76
evita la necesidad de utilizar un nuevo lenguaje con su sintaxis particular, a costa de ser un
poco más complicado que DTD.
XML Schema, que presenta las siguientes ventajas:
• Sintaxis en modo XML

• Más de 37 tipos básicos de datos soportados.
• Reutilización de nombres.
• Herencias.
• Definición de datos no necesariamente ordenada.
• Restricciones y extensiones de los tipos de datos.
• Mayor control del número de ocurrencias de elementos que deben aparecer.
• Posibilidad de uso de datos complejos definidos por el usuario.
Además, al ser el XML Schema en si mismo un XML, es posible validarlo también

contra su documento validador, realizando una comprobación en dos etapas, de la siguiente
manera:
XML Schema.xsd
Valida el archivo de validación a través del schema

de schemas
Fichero.xsd
Valida la estructura de Fichero.xml a través de su

fichero de validación.
Fichero.xml
3.3.2. Sintaxis XML Schema.
3.3.2.1. Tipos de datos

Es posible realizar la división de los datos en simples y complejos, los simples son
aquellos que no contienen ningún atributo o subelementos que varíen su comportamiento,
mientras que en los datos complejos aparecerán todo tipo de variaciones.
Tipos de datos simples: Los datos simples pueden ser de múltiples categorías:
• Referentes al tiempo: time, timeDuration, timeInstant, date, month, year, century...

• Datos Numéricos: decimal, integer, float, double, non-negative-integer, positive-
integer.
• Otros: string, boolean, uri-reference...
Además a los datos simples que vienen definidos, se les pueden hacer restricciones,
para adaptarlos a cada necesidad, haciendo uso de la etiqueta <restriction>
Por ejemplo, una restricción para un tipo numérico:
21 de 76
<sympleType name=”dorsal>
<restriction base=”integer”>
<minInclusive value=”1”>
<maxExclusive=”12”>
</restriction>
</sympleType>
Donde hemos definido el tipo dorsal, con base entera, y con valores comprendidos
entre el 1 y el 12 ambos inclusive.
Otra restricción son los patrones o patterns, que se usan con cadenas de texto y
permiten dejar claramente identificada su morfología. La sintaxis que permite definir patrones
es:
<pattern value=”patron”>
Donde el patrón definirá como es la cadena, con las siguientes reglas:
• \s: Indica un espacio.

• \d{n}: Indica que se incluyen n dígitos decimales.
• \d{n,}: Indica que se incluye un mínimo de n dígitos no importando el máximo.
• \d{n,m}: Indica que se incluye un numero de dígitos entre n y m.
• \d(condiciones){n}: Indica que se incluyen una serie de n dígitos cumpliendo las
condiciones.
• [n-m]: los valores pueden variar entre n y m.
• Carácter: indica que se incluye ese carácter.
• *: El carácter aparece cero o más veces
• ?: El carácter aparece cero o una vez.
• +: El carácter aparece una o más veces.
Además, hemos de saber que si no se especifica el número de repeticiones, el número

de ocurrencias del carácter es uno.
Podemos ver un ejemplo usando el código INE de una población, que se compone de
provincia (dos caracteres), municipio (tres caracteres), código de entidad colectiva (dos
caracteres), código de entidad singular (dos caracteres) y núcleo (dos caracteres), para un total
de 11, con lo que el esquema para este tipo de dato sería:
<simpleType name=”cod_INE”>
<restriction base=”string”>
<pattern value=”\d{2}-\d{3}-\d{2}-\d{2}-\d{2}”/>
</restriction>
</simpleType>
Otro patrón sería la definición de un ISBN, en el cual los dos primeros caracteres son
84, seguidos de un espacio, un dígito, y luego una secuencia de 6 caracteres que pueden ser
un dígito decimal o un espacio. Tras esta secuencia se espera un dígito decimal, un espacio, y
se termina con un dígito o una “x”:
<simpleType name=”ISBN”>
<restriction base=”string”>
<pattern value=”84\s\d{1}\d([0-9]|\s){6}\d{1}\s[0-
9|x]”/>
</restriction>
</simpleType>
Los datos simples se pueden agrupar en Listas, que son colecciones de datos
semejantes a los arrays, en las que se indica, si se desea, su tipo base y su longitud.
22 de 76
Así, la sintaxis para indicar una lista será:
<list base=”tipoBase”/>
Y para indicar su longitud
<length value=”longitud”/>
También se pueden enumerar los valores que compondrán la lista, con la siguiente
sintaxis:
<enumeration value=”valor”/>
Por ejemplo, podemos definir una lista de cadenas de caracteres, de longitud dos, y
con los valores prefijados:
<simpleType name=”lista”>
<list base=”string/>
<length value=”2”/>
<enumeration value=”uno”/>
<enumeration value=”dos”/>
</simpleType>
Tipos de datos complejos: Los tipos de datos complejos nos permiten definir nuevos
tipos de datos a partir de los tipos de datos simples.
También permiten definir elementos en el documento XML que contengan otros

elementos o que contengan atributos.
La etiqueta que permite definir un tipo complejo es:
<complexType name=”nombre”>


</complexType>
Si queremos que los elementos ordenados, de manera que estos aparezcan en un

orden determinado usaremos la etiqueta sequence:
<complexType name=”nombre”>
<sequence>
</sequence>
</complexType>
Los elementos se incluirán mediante la etiqueta:
<element name=”nombre” type=”tipoBase”/>
Donde name indica el nombre de la etiqueta y type, el tipo de la misma, adicionalmente

se pueden incluir los atributos minOccurs y maxOccurs que indican el número mínimo y
máximo de ocurrencias de un elemento, pudiendo dar el valor “ubounded” al atributo
maxOccurs para indicar que no hay límite superior.
Y los atributos con:
<attribute name=”nombre” type=”tipoBase” use=”tipoUso”/>
Donde name indica el nombre del atributo, type, el tipo del mismo, y use, como usarlo,
pudiendo tomar los siguientes valores:
23 de 76
• required: Si son obligatorios.

• optional: Si son opcionales.
• prohibited.
Podemos ver un ejemplo en la definición del tipo complejo lista, que consta de dos
elementos, que deben aparecer como mínimo una vez y como máximo dos, y un atributo
obligatorio de tipo entero:
<complexType name=”lista”>
<sequence>
<element name=”uno” type=”string” minOccurs=”1”
maxOccurs=”2”/>
<element name=”dos” type=”string” minOccurs=”1”
maxOccurs=”2”/>
</sequence>
<attribute name=”atributo” type=”integer” use=”required”/>
</complexType>
Que se usará:
<elemento type=”lista” atributo=”1”>

<uno>valor</uno>
<dos>valor</dos>
</elemento>
Si se quiere definir un elemento haciendo uso de un tipo complejo se utiliza el atributo

ref:
<element name=”elemento” ref=”lista”/>
A veces interesa definir un elemento complejo, sin necesidad de definir un tipo de

datos, con lo que podemos incluir la etiqueta complexType dentro de la etiqueta element:
<element name=”nombre”>
<complexType>
<sequence>
</sequence>
</complexType>
</element>
Si se dispone de un conjunto de atributos que van a ser usados por varios elementos,
se pueden definir Grupos de atributos. Su sintaxis es:
<attributeGroup name=”grupo”>
<attribute name=”atributo1” type=”string”/>
</attributeGroup>
Y para referenciarlos se usará el atributo ref, en la etiqueta attribute:
24 de 76
<element name=”nombre”>
<complexType>
<sequence>
<element name=”uno” type=”string” />
<element name=”dos” type=”string” />
</sequence>
<attribute ref=”grupo”/>
</complexType>
</element>
Mediante la etiqueta <all>, se obliga a incluir una serie de elementos aunque no sea
en orden. Su uso
<all>
</all>
</complexType>
Además podemos incluir en el esquema la posibilidad de elegir entre un elemento u

otro haciendo uso de la etiqueta <choice>. Siendo el siguiente su uso:
<sequence>
<choice>
</choice>
<element name=”tres” type=”string” />
</sequence>
</complexType>
Al que corresponderían los siguientes elementos:

<uno>valor</uno>
<tres>valor</tres>
</elemento>
O bien:

<dos>valor</dos>
<tres>valor</tres>
</elemento>
Pero NO sería valido:

<uno>valor</uno>
<dos>valor</dos>
<tres>valor</tres>
</elemento>
XML Schema incluye algo similar a la herencia, de manera que se puede generar un
objeto con características básicas y luego extenderlo para obtener el objeto deseado. Para ello
se hace uso de la etiqueta:
<extension base=”elemento que se extiende”></extension>.
25 de 76
Podemos ver un ejemplo si creamos un tipo vehículo y después dos tipos, motocicleta y
coche, que lo extiendan:
<complexType name=”vehiculo”>
<sequence>
<element name=”nruedas” type=”integer”/>
<element name=”caballos” type=”integer”/>
<element name=”marca” type=”string”/>
</sequence>
<attribute name=”dueño” type=”string” use=”optional”/>
</complexType>
<complexType name=”motocicleta”>
<complexContent>
<extension base=”vehiculo”>
<element name=”cilindrada” type=”decimal”/>
</extension>
</complexContent>
</complexType>
<complexType name=”coche”>
<complexContent>
<extension base=”vehiculo”>
<element name=”numPuertas” type=”integer”/>
</extension>
</complexContent>
</complexType>
Como hemos comentado anteriormente, los documentos XML Schema son

documentos XML, por tanto deben incluir la cabecera XML antes de comenzar con las
definiciones de elementos, atributos...
La etiqueta raíz que ha de contener todas las declaraciones es la etiqueta:
<schema>

</schema>
Normalmente los documentos que contienen XML Schema se suelen almacenar en

ficheros con la extensión .xsd.
La relación entre los XML Schema y los documentos XML se hace mediante espacios
de nombres o namespaces, que se explicarán en el capitulo siguiente.
3.3.2.2. Ejemplo.
El ejemplo del apartado anterior, haciendo uso de XML Schema sería:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="cuerpo" type="xs:string"/>

<xs:element name="nombre" type=" xs:string"/>
<xs:element name="apellido1" type=" xs:string"/>
<xs:element name="apellido2" type=" xs:string"/>
<xs:element name="enunciado" type=" xs:string"/>
<xs:element name="respuesta" type=" xs:string"/>
<xs:element name="senyuelo" type=" xs:string" minOccurs="5"
maxOccurs="5"/>
<xs:element name="justificacion" type=" xs:string"/>
26 de 76
<xs:element name="telefono">
<xs:attribute name="numero" type="xs:string"
use="required"/>
</xs:element>
<xs:element name="email">
<xs:attribute name="direccion" type="xs:string"
use="required"/>
</xs:element>
<xs:element name="autor">
<xs:complexType>
<xs:sequence>
<xs:element ref="cuerpo"/>
<xs:element ref="nombre"/>
<xs:element ref="apellido1"/>
<xs:element ref="apellido2"/>
<xs:element ref="telefono"/>
<xs:element ref="email"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="pregunta">
<xs:complexType>
<xs:sequence>
<xs:element ref="enunciado"/>
<xs:element ref="respuesta"/>
<xs:element ref="senyuelo"/>
<xs:element ref="justificacion"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="pregunta_candidata">
<xs:complexType>
<xs:sequence>
<xs:element ref="autor"/>
<xs:element ref="pregunta"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Este XML Schema se almacenará en el documento “pregunta_candidata.xsd”.
Un ejemplo de documento xml será:

<xsi:pregunta_candidata
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="pregunta_candidata.xsd">
<xsi:autor>
<xsi:cuerpo>Superior de Sistemas y Tecnologias de la
Informacion</xsi:cuerpo>
<xsi:nombre>Luis</xsi:nombre>
<xsi:apellido1>Perez</xsi:apellido1>
<xsi:apellido2>Sala</xsi:apellido2>
<xsi:telefono numero="91999999"/>
<xsi:mail direccion="luisperezsala@map.es"/>
27 de 76
</xsi:autor>
<xsi:pregunta>
<xsi:enunciado>¿En que puerto opera el protocolo
LDAP?</xsi:enunciado>
<xsi:respuesta>En el puerto 389</xsi:respuesta>
<xsi:senyuelo> En el puerto 300</xsi:senyuelo>
<xsi:justificacion>Este es el puerto registrado por
la ICANN para el protocolo LDAP</xsi:justificacion>
</xsi:pregunta>
</xsi:pregunta_candidata>
28 de 76
Capítulo 4: XML Namespaces

Una de las principales características de XML es su flexibilidad, es decir, que permite al
programador el definir las etiquetas que va a utilizar en sus documentos XML, sin embargo esta
flexibilidad puede ser fuente de problemas, ya que se podrían producir colisiones entre
nombres de etiquetas en un mismo documento XML si estas proviniesen de DTD diferentes.
Es decir, que si se están utilizando dos DTD diferentes para validar un mismo
documento XML, es posible que se hayan diseñado etiquetas con el mismo nombre en cada
una de las DTD, lo que provocaría un error al analizar el documento, pues el analizador no
sabría a que DTD corresponde la citada etiqueta, una posible solución sería el modificar el
nombre de una de ellas para evitar la colisión, pero eso redundaría en contra de la flexibilidad
propia de XML, ya que estaríamos limitando la elección de nombres de etiquetas, la solución
para evitar las colisiones de nombres y no eliminar la flexibilidad en el etiquetado es el uso de
espacios de nombres o namespaces
Un espacio de nombres o namespace tiene como objetivo principal el permitir que el

autor del documento le diga al analizador qué DTD usar cuando analice un elemento dado, es
decir, especificar para cada etiqueta qué DTD usar. Estos espacios de nombres se usan tanto
para atributos como para elementos.
Para definir un namespace se utiliza la siguiente sintaxis:
<elemento_raiz xmlns:idns=”url” >
Donde idns es el identificador del namespace que se usará en nuestro documento y la

url puede apuntar a un documento con las especificaciones del espacio de nombres.
El identificador o prefijo del namespace se puede seleccionar a voluntad, lo que

caracteriza al namespace es la URL. Este identificador se colocará delante de todas las
etiquetas que queramos que sean validadas con esa DTD.
Las definiciones de namespaces no son validas en todo el documento, si no en el

elemento en que se han definido y en sus elementos hijos, con lo que si se quieren utilizar en
todo el documento, las definiciones de namespaces se han de añadir a la etiqueta raíz.
El hecho de que la referencia sea en sí el URL implica que durante el análisis se

trabajará con la URL, no con el prefijo, con lo que la definición de prefijos diferentes con URL
iguales daría problemas.
Los XML Schema se añaden a los documentos XML como namespaces. Pero esta
dependerá de la ubicación del documento de validación.
Si queremos hacer referencia a un documento ubicado en URI conocida, se utilizará:
<elemento_raiz xmlns:xs="http://www.w3.org/2001/XMLSchema-
instance" xs:schemaLocation="URL file:agenda.xsd">
Indicando en el elemento raíz cual va a ser el prefijo que se va a utilizar para identificar
el esquema (en este caso, xs), y cual es la localización del documento XML que contiene la
definición del esquema.
Podemos ver un ejemplo, imaginando que existen dos DTD que definen, la primera una
clasificación por edades y la otra una clasificación cultural, y que ambas incluyen la etiqueta
clasificación:
29 de 76
<?xml version=”1.0” encoding=”ISO-8859-1” standalone=”no”?>

<videoteca xmlns:ce=”http://www.prueba.com/edades”
xmlns:cc= http://www.prueba.com/cultural”>
<pelicula titulo=”Sombras”>
<ce:clasificacion>+13</ce:clasificacion>
<cc:clasificacion>Obra maestra</cc:clasificacion>
</pelicula>
</videoteca>
Si el documento se encuentra almacenado en local, se usará:
<elemento_raiz xmlns:xs="http://www.w3.org/2001/XMLSchema-
instance"
xs:noNamespaceSchemaLocation="file:nombre.xsd">
30 de 76
Capítulo 5: XSL
5.1. Introducción
El XSL (eXtensible Stylesheet Language – Lenguaje Extensible de Hojas de Estilo) es
un lenguaje para crear hojas de estilo adaptadas al XML
XSL se compone de tres elementos:
• XSLT (XSL Transformations): Es un lenguaje que permite transformar documentos

XML en otros documentos XML.
• XPath (XML Path Language): Es un lenguaje usado por XSLT para acceder o
referenciar partes de un documento XML.
• XSL Formatting Objects: Un vocabulario para especificar formatos y semántica.
5.2. XSLT
XSLT es un lenguaje para transformar documentos XML en otros documentos XML,
puede convertir un XML que obedezca a un DTD en otro que obedezca a otro diferente, o, lo
más habitual, transformarlo a “formatos finales”, tales como WML o HTML.
Mediante XSLT se pueden añadir nuevos elementos al documento de salida o

eliminarlos, pudiendo también reordenar y mezclar los elementos existentes, además de poder
realizar decisiones, bucles...
XSLT es un estándar del W3C y es el más importante de los estándares XSL.
XSLT hace uso de XPath para definir las partes del documento fuente que coinciden
con uno o varios de los templates predefinidos. Cuando se encuentra una coincidencia, XSLT
transformará la parte coincidente del documento fuente en el documento resultante. Las partes
del documento original que no coincidan con un template, quedarán sin modificar en el
documento final.
XSLT no es completamente soportado por todos los navegadores (por ejemplo Internet
Explorer 5.0 y Netscape 6 no lo soportan 100%, pero Internet Explorer 6.0 si lo hace, ya que
incluye MSXML Parser 3.0 y también lo hace Netscape 7).
Los programas XSLT están escritos en XML, y generalmente se necesita un

procesador de hojas de estilo (o stylesheet processor) para procesarlas, aplicándolas a un
fichero XML, algunos de ellos son: Xalan sobre Xerces, Saxon, XT, Sablotron...
Como ventajas de XSLT podemos destacar
• La salida no tiene por que ser HTML, puede estar en muchos formatos.
• Permite manipular de diversas formas un documento XML.
• Permite acceder a todo el documento XML, no solo a los contenidos.
• XSLT es un lenguaje XML.
Y como inconvenientes:
• Su uso es complejo.
• Consume cierta capacidad de memoria y proceso.
5.2.2. Sintaxis.
31 de 76
5.2.2.1. Estructura básica.
La estructura básica de un documento XSL comprende un prólogo y un elemento

<xsl:stylesheet> o <xsl:transform>, que son sinónimos, y se pueden usar
indistintamente.
El prologo contiene la cabecera XML que indica la versión y el tipo de codificación que
se ha utilizado:
Con respecto a las etiquetas <xsl:stylesheet> o <xsl:transform>, estas

tendrán la siguiente sintaxis:
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:transform version="1.0"
Donde xmlns:xsl="http://www.w3.org/1999/XSL/Transform" identifica la

recomendación oficial de XSL del W3C, si se decide usar este namespace (xsl), es necesario
incluir el atributo version="1.0". Las citadas etiquetas indicarán el comienzo de la hoja de
estilos.
Los documentos XSL se suelen archivar en ficheros con la extensión .xsl.
Podemos ver un ejemplo de un documento XSL


</xsl:stylesheet>
Para que un documento XML haga referencia a una hoja de estilo determinada se ha
de incluir en él, tras la cabecera XML la instrucción de procesamiento necesaria para añadir
una referencia a la hoja de estilos, de la siguiente manera:

<?xml-stylesheet type="text/xsl" href="documento.xsl"?>
5.2.2.2. Etiquetas.
En esta sección vamos a describir algunas de las etiquetas más importantes de XSLT.
Una hoja de estilos XSL consiste en un conjunto de reglas llamadas templates, que se
definen utilizando la etiqueta <xsl:template>, y en cada uno de ellos se especifica las
reglas que se van a aplicar cuando se encuentre un nodo coincidente:
<xsl:template name=”nombreModelo” match=”expresion”

mode=”modoModelo”>
</xsl:template>
El atributo name es el nombre asociado a la etiqueta, el atributo match indica los nodos
afectados por el template, pudiendo incluir todo el árbol usando match=”/”.
El elemento apply-templates (<xsl:apply-templates>), aplica las reglas de un

template al elemento actual o a los hijos del elemento actual:
32 de 76
<xsl:apply-templates select=”nodo” >
El atributo select procesará solo los elementos hijo que coincidan con el valor del
atributo. Se suele usar para especificar el orden en que se tratan los elementos
El elemento value-of (<xsl:value-of>) extrae el valor de un nodo seleccionado, y lo

añade al documento de salida de la transformación:
<xsl:value-of select=”expresion”/>
El atributo select de este nodo puede contener una expresión XPath, similar a un
sistema de ficheros, por el que navegar utilizando / para acceder a los distintos nodos.
El elemento for-each (<xsl:for-each>) permite implementar bucles en XSLT, para

seleccionar todos los elementos XML de un conjunto de nodos que se especifiquen:
<xsl:for-each select=”conjuntoNodos”>
</xsl:for-each>
Su atributo select contiene también una expresión XPath. Se puede filtrar la salida
que se obtiene utilizando este elemento añadiendo criterios de selección, que según la sintaxis
XPath van entre corchetes:
<xsl:for-each select="/ruta[condicion]">
Los operadores de filtrado que se pueden utilizar son:
• = (igual)
• != (distinto)
• < menor que
• > mayor que
El elemento sort (<xsl:sort>) se usa para ordenar la salida, para lo que se añade
esta etiqueta dentro del elemento for-each:
<xsl:for-each select="ruta">
<xsl:sort select="que_ordenar"
order=”ascending|descending”/>
</xsl:for-each>
Donde el atributo select especifica que ordenar y el atributo order cómo ordenarlo.
El elemento if (<xsl:if>) se usa para especificar que si se cumple una condición, se

aplicará un template. Por ejemplo:
<xsl:if test="condicion”>
...
</xsl:if>
Donde se evalúa la condición incluida en el atributo test para ver si aplicar o no el

template.
El elemento choose (<xsl:choose>) se usa en conjunción con when (<xsl:when>)

y otherwise (<xsl:otherwise>), para implementar expresiones condicionales múltiples. Por
ejemplo:
<xsl:choose>
<xsl:when test="condicion">
...
</xsl:when>
33 de 76
<xsl:otherwise>
....
</xsl:otherwise>
</xsl:choose>
Donde se evalúa la condición incluida en el atributo test para ver si aplicar lo que esta
contenido en el when (si se cumple) o en el otherwise (si no se cumple). Se pueden
combinar muchos when, para verificar el cumplimiento de varias condiciones dentro de un
mismo choose.
La etiqueta element permite crear elementos de salida de manera dinámica:
<xsl:element name=”element-name”>
...
</xsl:element>
La etiqueta attribute permite añadir dinámicamente un atributo a un elemento de

salida:
<xsl:attribute name=”attribute-name”>
...
</xsl:attribute>
Además, en XSLT podemos definir variables y constantes, que nos pueden ser útiles a
la hora de la programación, lo cual se hace mediante la etiqueta variable.
Esta etiqueta se usa de la siguiente manera:
<xsl:variable name=”Variable-name”>
Valor
</xsl:variable>
Lo que es equivalente a:
Variable-name = Valor
Y para poder usarla dentro de otra etiqueta se ha de usar el nombre de la variable

precedido del símbolo $. Así en el ejemplo anterior: $Variable-name
5.2.2.3. Ejemplos.
Vamos a exponer algunos ejemplos del uso de las etiquetas especificadas, para su
mejor comprensión:
Veamos como se aplican dos templates a un documento:
Definición de la hoja de estilo:


</xsl:stylesheet>
Inclusión de una hoja de estilo en un documento XML:

<?xml-stylesheet type=”text/xsl” href=”documento.xsl”?>
<raiz>
<!—Documento XML -->
34 de 76
</raiz>
A continuación podemos ver algunos ejemplos del uso de las etiquetas antes
definidas:
Supongamos el siguiente documento XML:

<?xml-stylesheet type=”text/xsl” href=”lista.xsl”?>
<lista titulo=”Lista de CD”>
<cd>
<autor>Deep Purple</autor>
<titulo>Made In Japan</titulo>
<especif type=”Directo”/>
</cd>
<cd>
<autor>Led Zeppelin</autor>
<titulo>The Song Reamins The Same</titulo>
<especif type=”Directo”/>
</cd>
<cd>
<autor>Metallica</autor>
<titulo>Black Album</titulo>
<especif type=”Estudio”/>
</cd>
<cd>
<autor>U2</autor>
<titulo>Joshua Tree</titulo>
<especif type=”Estudio”/>
</cd>
</lista>
Podremos aplicar distintos templates a distintas partes del documento

<xsl:template match="/">
<html>
<body>
<xsl:for-each select="lista/cd">
<xsl:apply-templates select="."/>
</xsl:for-each>
</body>
</html>
</xsl:template>
<xsl:template match="cd">
<xsl:choose>
<xsl:when test="especif/@type='Directo'">
<h1>
<xsl:apply-templates select="*"/>
</h1>
</xsl:when>
<xsl:when test="especif/@type='Estudio'">
<h2>
</h2>
</xsl:when>
<xsl:otherwise>
<h3>
35 de 76
</h3>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="autor">
<b>Autor: <xsl:value-of select="."/></b>,
</xsl:template>
<xsl:template match="titulo">
Disco: <xsl:value-of select="."/>
</xsl:template>
</xsl:stylesheet>
Podemos ver otro ejemplo aplicado al mismo documento XML:

<html>
<body>
<h1>
<xsl:value-of
select="lista/@titulo"/>
</h1>
<br/>
<hr/>
<xsl:for-each select="lista/cd">
<xsl:apply-templates/>
</xsl:for-each>
</body>
</html>
</xsl:template>
<xsl:if test="especif[@type='Directo']">
Disco en Directo
<br/>
</xsl:if>
<xsl:if test="especif[@type='Estudio']">
Disco en Estudio
<br/>
</xsl:if>
</xsl:template>
<b>Autor: <xsl:value-of select="."/></b>,
</xsl:template>
Disco: <xsl:value-of select="."/><hr/>
</xsl:template>
</xsl:stylesheet>
Podemos ver un ejemplo más:
36 de 76
<html>
<title>
<xsl:value-of select="lista/@titulo"/>
</title>
<body>
<center><h3><xsl:value-of
select="lista/@titulo"/></h3></center>
<hr/>
<br/>
<center>
<table border="1">
<tr>
<td>Autor</td>
<td>Album</td>
<td>Tipo</td>
</tr>
<xsl:for-each
select="lista/cd">
<xsl:apply-templates
select="."/>
</xsl:for-each>
</table>
</center>
</body>
</html>
</xsl:template>
<tr>
</tr>
</xsl:template>
<td>
<b><xsl:value-of select="."/></b>
</td>
</xsl:template>
<td>
<xsl:value-of select="."/>
</td>
</xsl:template>
<xsl:template match="especif">
<td>
<xsl:value-of select="@type"/>
</td>
</xsl:template>
</xsl:stylesheet>
Vamos a realizar un ejemplo en el cual haciendo uso del parser Xalan y una hoja de
estilo XSL, se va a transformar un documento XML que sigue una determinada DTD en un
documento XML que sigue una DTD diferente.
Sean las siguientes definiciones de tipo de documento:
37 de 76
<!ELEMENT respuesta ((nif|cif),datos,asesor+)>

<!ATTLIST respuesta fecha CDATA #REQUIRED>
<!ELEMENT nif (#PCDATA)>
<!ELEMENT cif (#PCDATA)>
<!ELEMENT datos EMPTY>
<!ATTLIST datos nombre CDATA #REQUIRED>
<!ELEMENT asesor (nombre,ubicacion)>
Y el documento XML:

<!DOCTYPE respuesta SYSTEM "respuesta.dtd">
<respuesta fecha="16/10/2006">
<nif>78678765P</nif>
<datos nombre="Antonio" apellido1="Perez"
apellido2="Lopez"/>
<nombre>Jose Lopez</nombre>
</asesor>
<nombre>Luis Martinez</nombre>
</asesor>
</respuesta>
A través de la siguiente hoja de estilo, almacenada en el fichero “generador.xsl”:

<xsl:apply-templates select="respuesta"/>
</xsl:template>
<xsl:template match="respuesta">


<xsl:text disable-output-
escaping="yes"><!DOCTYPE respuesta SYSTEM
"respuesta1.dtd"></xsl:text>

escaping="yes"><</xsl:text>
<xsl:value-of select="name()"/>
escaping="yes">></xsl:text>

<xsl:choose>
<xsl:when test="count(nif)=1">
<xsl:apply-templates select="nif"/>
</xsl:when>
<xsl:otherwise>
38 de 76
<xsl:apply-templates select="cif"/>
</xsl:otherwise>
</xsl:choose>
<xsl:apply-templates select="datos"/>
<xsl:element name="fecha">
<xsl:value-of select="/respuesta/@fecha"/>
</xsl:element>
<xsl:apply-templates select="asesor"/>

escaping="yes"></</xsl:text>
<xsl:value-of select="name()"/>
</xsl:template>
<xsl:template match="nif">

escaping="yes"><identificacion tipo="fisica"</xsl:text>
escaping="yes"></identificacion</xsl:text>
</xsl:template>
<xsl:template match="cif">
escaping="yes"><identificacion tipo="juridica"</xsl:text>
escaping="yes"></identificacion</xsl:text>
</xsl:template>
<xsl:template match="datos">
<xsl:element name="datos">
<xsl:element name="nombre">
<xsl:value-of select="@nombre"/>
</xsl:element>
<xsl:element name="apellido1">
<xsl:value-of select="@apellido1"/>
</xsl:element>
<xsl:element name="apellido2">
<xsl:value-of select="@apellido2"/>
</xsl:element>
</xsl:element>
</xsl:template>
39 de 76
<xsl:template match="asesor">
<xsl:element name="asesor">
<xsl:attribute name="telefono">
<xsl:value-of select="@telefono"/>
</xsl:attribute>
<xsl:element name="nombre_asesor">
<xsl:apply-templates select="nombre"/>
</xsl:element>
<xsl:element name="ubicacion">
<xsl:apply-templates select="ubicacion"/>
</xsl:element>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
Y aplicando el parser Xalan, con la siguiente sintaxis:
java -cp <ruta>/xalan.jar;<ruta>/xercesImpl.jar

org.apache.xalan.xslt.Process -IN <ruta>\<entrada.xml> -XSL
<ruta>\<documento.xsl> -OUT <ruta>\<salida.xml>
Se obtiene el siguiente documento XML

<!DOCTYPE respuesta SYSTEM "respuesta1.dtd">
<respuesta>
<identificacion tipo="fisica">78678765P</identificacion>
<datos>
</datos>
<fecha>16/10/2006</fecha>
<nombre_asesor>Jose Lopez</nombre_asesor>
</asesor>
<nombre_asesor>Luis Martinez</nombre_asesor>
</asesor>
</respuesta>
Que sigue esta otra DTD:
<!ELEMENT respuesta (identificacion, datos, fecha, asesor+)>

<!ELEMENT identificacion (#PCDATA)>
<!ATTLIST identificacion tipo (fisica|juridica) #REQUIRED>
<!ELEMENT datos (nombre,apellido1?,apellido2?)>
<!ELEMENT fecha (#PCDATA)>
<!ELEMENT asesor (nombre_asesor,ubicacion)>
<!ELEMENT nombre_asesor (#PCDATA)>
40 de 76
5.3. XPath
5.3.1. Introducción y concepto

Todo el procesamiento realizado con fichero XML está basado en la posibilidad de
direccionar o acceder a cada una de las partes que lo componen, de modo que podamos tratar
cada uno de los elementos de forma diferenciada.
Mediante el uso de XPath se puede seleccionar y hacer referencia a texto, elementos,

atributos y cualquier otra información contenida dentro de un fichero XML.
XPath es una sintaxis para definir partes de documentos XML., que usa rutas para
navegar en documentos XML.
XPath es un estándar del W3C, que forma parte de XSLT, también de XQuery.
5.3.2. Sintaxis
La sintaxis básica de XPath esta basada en el uso de expresiones. Una expresión
puede aplicarse a cuatro tipos de objetos:
• Booleanos.
• Números.
• Cadenas de caracteres.
• Conjuntos de nodos.
Una de las expresiones más importantes de XPath es la ruta de selección, que

selecciona un conjunto de nodos partiendo de un nodo contextual.
5.3.2.1. Ruta de localización.

XPath utiliza rutas para seleccionar nodos en un documento XML. Las rutas pueden ser
absolutas o relativas. Si la ruta es absoluta comienza con el carácter /, que indica el elemento
raíz del documento XML. Si la ruta es relativa, el nodo origen es el nodo contextual actual.
La ruta se compone de tres elementos:
• Un eje, que define la relación entre el nodo actual y el conjunto de nodos a localizar.
• Un nodo, que especifica el conjunto de nodos a localizar.
• De 0 a n predicados que permiten refinar la búsqueda.
La sintaxis es la siguiente:
eje::nodo[predicado]
Ejes: Algunos de los ejes disponibles son:
• child: Contiene los hijos directos del nodo actual.

• descendant: Contiene los descendientes del nodo actual (hijos, nietos...).
• parent: Contiene el padre, si existe.
• ancestor: Contiene los ancestros, el padre, el padre del padre...
Sin embargo, a la hora de usar ejes en XPath, lo normal es usar abreviaturas, entre las
que cabe destacar:
• . : nodo actual
• .. : nodo padre
• // : descendiente, con profundidad arbitraria
41 de 76
• Si no se indica nada, nos referiremos a un nodo hijo del actual.
Predicados: Se usan para buscar un nodo específico o un nodo que contiene un valor
específico, su contenido es una expresión, que siempre va entre corchetes.
Estas expresiones se componen de una serie de funciones predefinidas, que podemos

clasificar en los siguientes tipos:
Funciones de nodo:
• name() : Se usa para obtener el nombre de un nodo

• node(): Retorna el propio nodo
• processing-instruction(): Retorna la instrucción de procesamiento que se este
usando.
• text(): Devuelve el contenido PCDATA de un determinado nodo
Funciones posicionales:
• position(): Se usa para obtener la posición de un nodo dentro de un conjunto de ellos.

• last(): Retorna la posición del último nodo.
• count(): Retorna el número de nodos de un determinado tipo.
Funciones numéricas:
• number(): Convierte texto PCDATA en valores numéricos.

• sum(): Suma los valores numéricos de un conjunto de nodos.
Funciones booleanas:
• boolean(): Evalúa una expresión XPath, para ver si es verdadera o falsa

• not(): Realiza la operación lógica NOT.
• true(): Devuelve siempre verdadero
• false(): Devuelve siempre falso.
Funciones de cadena
• string(): Convierte cualquier valor en cadena.

• string-length(): Devuelve la longitud de una cadena.
• concat(): Concatena dos o más cadenas.
• contains(): Indica si una cadena contiene a otra.
• starts-with():Indica si una cadena comienza con el contenido de otra cadena
• substring(): Devuelve una subcadena a partir de otra más larga, indicando la posición
de inicio y cuantos caracteres devolver.
• substring-after(): Retorna todos los caracteres que hay tras un carácter indicado
• substring-before(): Retorna todos los caracteres que hay antes de un carácter
indicado
5.3.3. Ejemplos.
La mejor manera de comprender el funcionamiento de XPath es viendo algunos
ejemplos. Sea el siguiente documento XML:
<?xml version="1.0" encoding="UTF-8"?>
<ProductDescription ProductModelId=”19”>
<Summary>Bicicleta de Montaña de Competición</Summary>
<Manufacturer>
<Name>AdventureWorks</Name>
42 de 76
<ProductURL>http://www.adventureworks.com</ProductURL
>
</Manufacturer>
<Features>
<Warranty>
<WarrantyPeriod>3 años</WarrantyPeriod>
<Description>Piezas y mano de
obra</Description>
</Warranty>
<Maintenance>
<NoOfYears>10 años</NoOfYears>
<Description>Contrato de mantenimiento
disponible durante...</Description>
</Maintenance>
</Features>
<Picture>
<Angle>frente</Angle>
<Size>pequeña</Size>
<ProductPhotoID>31</ProductPhotoID>
</Picture>
</ProductDescription>
Con estos datos origen, podemos ver los siguientes ejemplos:
• /ProductDescription/Summary: Selecciona todos los elementos <Summary> que son

hijos del elemento <ProductDescription>, que es el elemento raiz del elemento. Aplicando
esta expresión al anterior documento, obtenemos:
• //Summary: Selecciona todos los elementos <Summary> que se encuentran dentro del
documento. Con la doble barra indicamos profundidad arbitraria. El resultado de su
aplicación:
• //Warranty: Selecciona todos los elementos <Warranty> que se encuentran dentro del
documento. Con la doble barra indicamos profundidad arbitraria. El resultado de su
aplicación:
<Warranty>
<Description>Piezas y mano de obra</Description>
</Warranty>
• count(//Summary): Devuelve el número de elementos <Summary> que aparecen en el

documento.
• //Picture[Size = “pequeña”]: Devuelve todos los elementos <Picture>, de

profundidad arbitraria, que tengan un hijo de tipo <Size>, con valor “pequeña”. Su resultado
<Picture>
</Picture>
• //ProductDescription[@ProductModelID=”19”]: Devuelve todos los elementos

que contienen un atributo ProductModelID y su valor es 19. Como se ha comentado el
símbolo @ indica que el elemento que se busca es un atributo. El resultado:
43 de 76
<ProductDescription ProductModelID="19">
<Manufacturer>
<Name>AdventureWorks</Name>
<ProductURL>http://www.adventureworks.com</ProductURL
>
</Manufacturer>
<Features>
<Warranty>
<Description>Piezas y mano de
obra</Description>
</Warranty>
<Maintenance>
<NoOfYears>10 años</NoOfYears>
<Description>Contrato de mantenimiento disponible
durante...</Description>
</Maintenance>
</Features>
<Picture>
</Picture>
</ProductDescription>
• //ProductDescription[@ProductModelID]: Devuelve todos los elementos de ese

tipo que contengan un atributo, independientemente de su valor. El resultado de esta
expresión es el mismo que el de la anterior.
• /ProductDescription/@ProductModelID: Devuelve los valores de los atributos

ProductModelID. El resultado de esta expresión es:
ProductModelID="19"
• //Size[1]: Devuelve el primer nodo <Size> que se encuentra.
5.4. XSL-FO
5.4.1. Introducción.
Una de las ventajas del formato XML es que los datos pueden ser visualizados de
diferentes formas, como por ejemplo en forma de páginas HTML o WML. Existe una
transformación más rígida que la de los lenguajes de marcas, que es la que usan los
procesadores de texto o los formatos tipo PDF o PostScript.
XSL-FO es una implementación especifica de un determinado XSLT, que permite

transforma un documento XML a otro documento que, conteniendo la información original,
tenga un formato de visualización impresa. Esa es la principal diferencia entre FO y otros
XSLT: la orientación a una transformación más rígida.
Un documento XSL-FO es un documento XML en el que se especifica cómo se van a

formatear unos datos para presentarlos en pantalla, papel u otros medios. En el documento
XSL-FO figuran tanto los datos como el formato que se les va a aplicar.
44 de 76
Cuando se tiene el documento XSL-FO, puede ser procesado por un programa llamado
"procesador de XSL-FO" para obtener el documento final en distintos formatos. El formato final
más utilizado es el PDF.
Los procesadores XSL-FO libres más conocidos son FOP y PassiveTeX.
5.4.2. Características básicas.

El modelo utilizado por FO está basado en cajas rectangulares llamadas áreas, las
cuales pueden contener texto, espacio vacío u otros FO.
Cada área tiene borde y separación (padding) por cada uno de sus lados, así como
indentaciones (indent) que especifican su separación del área que la contiene. La mayoría de
los FO generan un único área, aunque a veces, debido a saltos de página, separación de
líneas, etcétera, pueden dar lugar a varias.
Los FO están divididos formalmente en cuatro tipo de áreas rectangulares:

contenedores, bloques, líneas e inline. Estas cuatro categorías forman una jerarquía muy
estricta.
Un contenedor es la estructura de más alto nivel. Puede ser colocado en coordenadas

precisas dentro del área que lo contiene. Puede contener otros contenedores, así como
secuencias de bloques y de espacios a visualizar. Por ejemplo, una página de un libro es un
contenedor que incluye otros cinco contendores: la cabecera, el cuerpo, el pie y los márgenes
derecho e izquierdo.
Un bloque representa estructuras como un párrafo o un apartado de una lista. Los

bloques son colocados secuencialmente dentro del contenedor que los incluye.
A su vez, los bloques pueden contener líneas, espacios a visualizar, una imagen y
otros bloques.
Una línea hace referencia a cada línea de texto dentro de un bloque. Pueden contener
inline.
Finalmente, las inline son partes de una línea, como por ejemplo cada carácter, la
referencia a una nota al pie o una expresión matemática. Cada inline puede contener otras
inline o inline de espacio.
5.4.3. Espacio de nombres Formatting Objects
FO no es más que una especificación XSL para visualizar el contenido de un

documento XML, por tanto hemos de indicar el espacio de nombres en el que se definen las
etiquetas especificas para él, al que se le suele asignar usualmente el prefijo fo.
El espacio de nombres FO es el siguiente:
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns:fo="http://www.w3.org/XSL/Format/1.0"
result-ns="fo">
5.4.4. Etiquetas FO.
5.4.4.1. Descripción de páginas

El elemento raíz de un documento formatting objects es <root>, que ha de contener
un <layout-master-set> y cero o más <page-sequence>.
45 de 76
En dicho elemento raíz hay que indicar un espacio de nombres con

xmlns:fo="http://www.w3.org/XSL/Formatt/1.0".
El <layout-master-set> contiene las diferentes <master-page> que se usan en

el documento. Siendo una master page un patrón para una página, en la que se definen los
márgenes que tiene, tamaños de cabecera y pie y otras características.
Las Simple Master Pages (que se representan con la etiqueta <simple-page-

master>) Definen el aspecto de cada página patrón especificando los tamaños de sus
regiones anterior, posterior, cuerpo, inicio y fin. Tiene tres atributos principales:
• page-master-name: Nombre del patrón.

• page-height: Altura de la página.
• page-width: Ancho de la página.
Podemos ver un ejemplo en el que se definen dos patrones de páginas:
<fo:layout-master-set>
<fo:simple-page-master page-master-name="impar"
height="29cm" width="21cm" margin-top="0.5cm" margin-
bottom="0.5cm" margin-left="1.0cm" margin-right="0.5cm">
<fo:region body/>
</fo:simple-page-master>
<fo:simple-page-master page-master-name="par" height="29cm"
width="21cm" margin-top="0.5cm" margin-bottom="0.5cm" margin-
left="0.5cm" margin-right="1.0cm">
<fo:region body/>
</fo:master-page-set>
Los documentos FO deben tener una o más <page-sequence>, las cuales deben
incluir una <sequence-specification> (indicando el orden en que las páginas patrón son
usadas), cero o más <static-content> con texto a incluir en todas las páginas, y un
<flow> con datos que se incluirán o no en la página según corresponda.
La Sequence specification lista el orden en que serán aplicadas las distintas páginas
patrón. Y podemos ver algunos ejemplos, tales como el incluir una misma página patrón para
todo el documento:
<fo:sequence-specification>
<fo:sequence-specifier-single page-master-name="par"/>
O incluir una misma página patrón para todo el contenido suponiendo que este ocupa 3
páginas:
<fo:sequence-specifier-single page-master-name="impar"/>
Distintas páginas patrón para todo el contenido suponiendo que va a ocupar dos
páginas
<fo:sequence-specifier-single page-master-name="par"/>
46 de 76
Normalmente no se conoce de antemano cuántas páginas va a ocupar el contenido del

documento se suelen usar las etiquetas: <sequence-specifier-repeating> y
<sequence-specifier-alternating>.
El primero permite especificar dos páginas patrones: una para la primera página y otra
para todas las demás y el segundo permite especificar hasta 6 páginas patrón: una para la
primera página, otra para las páginas pares con contenido, otra para las impares con
contenido, otra para páginas pares en blanco, para la última hoja par y la última hoja impar.
<fo:sequence-specifier-repeating page-master-
first="portada" page-master-repeating="pagina" />
</fo:sequence-specification>
<fo:sequence-specifier-alternating page-master-
first="cap_portada" page-master-even="cap_pares" page-master-
blank-even="cap_blanca" page-master-odd="cap_impares" page-
master-last-even="cap_ultima_par" page-master-last-
odd="cap_ultima_impar" page-master-repeating="cap_ultima_par" />
Los static-content especifican contenido que aparecerá en todas las páginas, tales
como pies de página, como podemos ver en el ejemplo siguiente:
<fo:static-content flow-name="region-after">
<fo:block>Consejería de Agricultura</fo:block>
</fo:static-content>
Los flow ubican contenido en páginas determinadas en función de los criterios que se
especifiquen.
Además de una secuencia de páginas patrón a usar, contenidos estáticos y contenidos

dinámicos, un page-sequence tiene atributos opcionales relativos a la numeración, que
permiten definir el formato de la numeración.
5.4.4.2. Contenido
El contenido se organiza en elementos de tipo bloque, tablas e inlines.
Se entiende por bloque un área rectangular separada por una línea de ruptura y un
espacio antes y después de su contenido, pudiendo contener otros bloques. Se definen
mediante la etiqueta <block>
Los bloques pueden estar contenidos en flow, static-content u otros bloques.
<display-graphic> sirve para insertar un gráfico a nivel de bloque y <display-

rule> es una línea, que podemos colocar tanto en horizontal como en vertical.
Un <list-block> es el contenedor de una serie de ítems que se enseñarán en forma

de lista.
Una inclusión es un área rectangular que puede contener texto u otras inclusiones. Se
suelen mostrar dentro de líneas y de izquierda a derecha.
5.4.5. Ejemplo.
Sea el documento XML:
47 de 76

<libro>
<titulo>Microsiervos</titulo>
<titulo>El Señor de los Anillos</titulo>
<titulo>La conjura de los necios</titulo>
</libro>
Que se encuentra almacenado en el fichero libro.xml
Y el documento XSL, que contiene una serie de sentencias XSL-FO para generar el
documento de salida:

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/XSL/Format/1.0" result-ns="fo" indent-
result="yes">
<fo:root xmlns:fo="http://www.w3.org/XSL/Format/1.0">
<fo:layout-master-set>
<fo:simple-page-master page-master-
name="only" height="29cm" width="21cm" margin-top="0.5cm" margin-
bottom="0.5cm" margin-left="0.5cm" margin-right="1.0cm">
<fo:region-body/>
</fo:layout-master-set>
<fo:page-sequence>
<fo:sequence-specifier-single page-
master-name="only"/>
<fo:flow>
<fo:block font-size="20pt" font-
family="serif">
LIBROS
select="/libro/titulo"/>
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
</xsl:template>
<fo:block>
Libro: <xsl:value-of select="."/>
</fo:block>
</xsl:template>
</xsl:stylesheet>
Si ejecutamos el siguiente comando:
java -cp <ruta>\fop_0_11_0.jar;<ruta>\ sax2.jar;<ruta>\

xp.jar;<ruta>\xt20051206.jar com.jtauber.fop.apps.XTCommandLine
<ruta>\libro.xml <ruta>\libro.xsl <ruta>\libro.pdf
Incluyendo las rutas de las aplicaciones FOP, SAX, XP y XT en el PATH
Obtenemos como resultado un documento PDF, con el contenido del documento XML
original.
48 de 76
Nótese que se indica en dos ocasiones el espacio de nombres fo, la primera indica al
documento XSL el espacio de nombres al que se refieren las etiquetas fo, y la segunda sirve
como entrada al programa FOP para que esta pueda ser transformada.
49 de 76
Capítulo 6: Analizadores
6.1. Introducción.
El procesado de documentos XML puede ser tedioso, por eso para realizar el mismo se
recurre a unas aplicaciones que ofrecen ayuda para analizar de forma automática la estructura
los documentos XML, que se denominan analizadores o parsers.
Los dos tipos de parsers más comunes son el SAX (Simple Api for XML – Interfaz de
acceso simple para XML) y el DOM (Document Object Model – Modelo de Objeto Documento),
que difieren sobre todo en su modo de funcionamiento a la hora de acceder a los datos
6.2. SAX
El SAX proporciona un mecanismo de acceso al XML de forma secuencial (similar a
una cinta de video), por lo que será ideal para aplicaciones cuyos documentos XML a analizar
vengan dados por comunicaciones entre procesos, tanto en transmisión como en recepción.
Este tipo de parser necesita poca memoria, ya que una vez procesada la sección de
documento pedida la abandona.
SAX comenzará a recibir el documento a analizar, y avisará de los elementos que se va

encontrando. En SAX, el programador debe ocuparse del código que gestione os eventos que
puedan acontecer al recorrer el documento, indicando el comportamiento para atributos,
elementos... Es por ello por lo que se le conoce también como parser orientado a evento.
6.3. DOM
El DOM es un parser más pesado que el SAX, pero tiene la ventaja de que no es
necesaria mucha de la programación que implica el SAX, además de tener mayor control sobre
la estructura del documento.
El DOM es un parser ideal para la lectura de ficheros almacenados en el disco duro. Lo

primero que hace es leer el documento en su totalidad generando un árbol, correspondiente a
la estructura del documento.
Debido a que se carga todo el documento en memoria, requiere más memoria que
SAX, pero el acceso al documento es por nodos, no secuencial. Estos nodos son de dos tipos,
nodos elemento, que pueden contener otros elementos, o nodos texto, que contienen solo
texto.
50 de 76
Capítulo 7: XML en ORACLE 9i.

7.1. SQLX, generando XML a partir de datos en SGBDR.
Se va a hacer uso de la librería DBMS_XMLSCHEMA, que deberá estar registrada en
el SGBD para trabajar con ella:
DBMS_XMLSCHEMA.registerSchema('http://www.oracle.com/PO.xsd',doc);
Esta librería proporciona cinco funciones del estándar SQLX (SQL to XML) para
obtener datos relacionales en formato XML: XMLElement, XMLForest, XMLConcat,
XMLAttribute y XMLAgg.
• XMLElement es una función que devuelve un elemento de tipo XMLType (que

podemos asemejar a un documento XML), proporcionándole como parámetros el
nombre del elemento, sus atributos y su contenido.
• XMLAttribute es una función que permite definir atributos, proporcionándole su
contenido y su nombre, y es usada por XMLElement para la definición de los atributos.
• XMLForest es una función que crea un árbol con los elementos que se le
proporcionan, ubicándolos al mismo nivel, partiendo del mismo nodo padre.
• XMLConcat es una función que dados una serie de documentos XML (u objetos
XMLType) los concatena en el orden en que aparecen como parámetros.
• XMLAgg es una función de agregado que produce un bosque de elementos XML dada
una colección de elementos, usándose normalmente en sentencias con GROUP BY.
Adicionalmente, ORACLE soporta otras funciones que no forman parte del estándar
SQLX, pero que tienen el mismo propósito.
7.2. Ejemplos.
Supongamos una base de datos compuesta por las siguientes tablas:
PUESTOS
Codigo Descripcion
1 Analista
2 Analista/Programador
3 Programador
EMPLEADOS
Codigo Nombre
1 Ana
2 Luis
3 Pedro
Queremos obtener un documento XML que tenga la estructura:
<!ELEMENT empleado (nombre,descripcion)>

<!ATTLIST empleado codigo CDATA #REQUIRED>
<!ELEMENT descripcion (#PCDATA)>
Lo haremos de la siguiente manera:
SELECT XMLELEMENT("empleado",
XMLATTRIBUTES(e.codigo AS codigo),
XMLELEMENT("nombre",e.nombre),
51 de 76
XMLELEMENT("puesto",p.descripcion)) AS
resultado
FROM PUESTOS p, EMPLEADOS e
WHERE e.Codigo =p.Codigo;
El resultado que se obtiene es:
resultado
-------------------
<empleado codigo="1">
<nombre>Ana</nombre>
<puesto>Analista</puesto>
</empleado>
<puesto>Analista/Programador</puesto>
</empleado>
<nombre>Pedro</nombre>
<puesto>Programador</puesto>
</empleado>
Otra forma de obtener el mismo documento sería:
SELECT XMLELEMENT("empleado",
XMLATTRIBUTES(e.codigo AS codigo),
XMLFOREST(e.nombre AS “nom”, p.descripcion AS
“puesto” ) AS resultado
La sentencia:
SELECT XMLCONCAT (XMLELEMENT("nombre",e.nombre),

XMLELEMENT("puesto",p.descripcion)) AS
resultado
Nos proporcionaría el siguiente resultado:
resultado
-------------------
<nombre>Ana</nombre>
<puesto>Analista</puesto>
<puesto>Analista/Programador</puesto>
<nombre>Pedro</nombre>
<puesto>Programador</puesto>
52 de 76
Capítulo 8: XQUERY
8.1. Introducción.
XQuery es un leguaje de consultas estándar, publicado por el W3C (World Wide Web
Consortium) que utiliza la notación XML para definir consultas y manejar los resultados.
XQuery es lo suficientemente flexible como para consultar un amplio espectro de orígenes de
datos, incluyendo bases de datos relacionales, documentos XML, Servicios Web, aplicaciones
y sistemas heredados.
XML ha significado mucho para el desarrollo de sistemas; cuestiones tales como la

posibilidad de comunicar de manera transparente sistemas pertenecientes a distintas
plataformas habrían sido impensables en otros tiempos. Aunque XML es un paso importante,
por sí solo no es de gran utilidad. Lo que realmente hace potente a esta tecnología es el
conjunto de estándares que se han desarrollado (y los que aun están en desarrollo) en torno a
la misma.
XQuery es un lenguaje que provee mecanismos para extraer información de bases de

datos XML nativas, así como de otro tipo de orígenes de datos (como bases de datos
relacionales). Entre otras cosas, permite la posibilidad de obtener datos de un archivo XML y
una tabla de la base de datos relacional con una sola consulta. XQuery se presenta como un
lenguaje funcional, en vez de ejecutar comandos como lo haría un lenguaje procedural, cada
consulta es una expresión a ser evaluada. Las expresiones se pueden combinar para hallar
nuevas expresiones.
XQuery hace un uso intensivo de XPath (un lenguaje utilizado para seleccionar
porciones de XML); de hecho algunos ven a XQuery como un súper conjunto de XPath. En el
gráfico que se muestra en la se puede visualizar algunas de las especificaciones del W3C,
ubicadas por orden de aparición. XPath en un principio fue parte de XSL 1.0 y luego se
desarrolló como una especificación separada. La nueva versión de XPath (XPath 2.0) está
siendo desarrollada de manera conjunta a XQuery, por el mismo grupo de trabajo.
En el modelo de datos XQuery, cada documento es representado como un árbol de

nodos. Los tipos de nodos posibles son:
• Document
53 de 76
• Element
• Attribute
• Text
• Namespace
• Processing Instruction
• Comment
Cada nodo en el modelo de datos es único e idéntico a sí mismo, y diferente a todos

los demás. Esto no implica que no puedan tener valores iguales, sino que conceptualmente se
los debe tomar como entidades diferentes. Podría trazarse una relación con el principio de
identidad existente en la teoría de objetos.
Además de los nodos, el modelo de datos permite valores atómicos (atomic values),
que son valores simples que se corresponden con los valores simples (simple types) definidos
en la recomendación XML Schema, Part 2 del W3C. Estos pueden ser string, boolean,
decimal, integer, float, double y date.
Un ítem es nodo simple o valor atómico. Una serie de ítems es conocida como
sequence (secuencia). En XQuery cada valor es una secuencia, y no hay distinción entre un
ítem simple y una secuencia de un solo ítem. Las secuencias solo pueden contener nodos o
valores atómicos, no pueden contener otras secuencias. El primer nodo en cualquier
documento es el "nodo documento" (document node). El nodo documento no se corresponde
con nada visible en el documento, éste representa el mismo documento.
Los nodos conectados forman un árbol, que consiste en un nodo "root" y todos los
nodos que cuelgan de él. Un árbol cuyo root es un nodo documento se denomina árbol
documento, todos los demás son denominados fragmentos.
8.2. Expresiones FLWOR

Las expresiones FLWOR (que en estos ámbitos suelen pronunciarse "flower") son al
XQuery lo que las distintas cláusulas dentro de una sentencia Select (el select, from, where,
etc) son al SQL. Es decir, son sus bloques principales. El nombre viene de For, Let, Where,
Order by y Return:
• FOR: asocia una o más variables a expresiones, creando un conjunto de tuplas en el

cual cada tupla vincula una variable dada a uno de los ítems a los cuales está asociada
la expresión evaluada.
• LET: vincula las variables al resultado de una expresión, agregando estos vínculos a
las tuplas generadas por la cláusula FOR.
• WHERE: filtra tuplas, quedando solo aquellas que cumplen con la condición.
• ORDER BY: ordena las tuplas en el conjunto de tuplas.
• RETURN: construye el resultado de la expresión FLWOR para una tupla dada.
Las cláusulas FOR y LET arman el conjunto de tuplas sobre el cual se evaluará la
sentencia FLWOR, al menos una de estas cláusulas tiene que existir en una consulta. Con
estas sentencias se consigue buena parte de la funcionalidad que diferencia a XQuery de
XPath. Entre otras cosas permite construir el documento que será la salida de la sentencia.
Vamos a ver unos ejemplos. Para lo cual vamos a usar el parser Xquery que incluye
Saxon.
Sea el documento XML, que se encuentra almacenado en el fichero “libros.xml”:
54 de 76
<?xml version="1.0" encoding="ISO-8859-1"?>
<tienda_libros>
<libro categoria="COCINA">
<titulo idioma="castellano">Cocina Italiana</titulo>
<autor>Giada De Laurentiis</autor>
<anyo>2005</anyo>
<precio>30.00</precio>
</libro>
<libro categoria="INFANTIL">
<titulo idioma="castellano">Harry Potter</titulo>
<autor>J K. Rowling</autor>
<anyo>2005</anyo>
</libro>
<libro categoria="WEB">
<titulo idioma="ingles">XQuery Quick Start</titulo>
<autor>James McGovern</autor>
<autor>Per Bothner</autor>
<autor>Kurt Cagle</autor>
<autor>James Linn</autor>
<autor>Vaidyanathan Nagarajan</autor>
<anyo>2003</anyo>
</libro>
<libro categoria="WEB">
<titulo idioma="castellano">Aprender XML</titulo>
<autor>Erik T. Ray</autor>
<anyo>2005</anyo>
</libro>
</tienda_libros>
Vamos a ejecutar una serie de consultas que nos permitirán obtener algunas partes de
este documento.
Primero vamos a obtener aquellos libros cuyo precio sea superior a 30 €, mediante la
siguiente sentencia FLWOR:
<resultado>
{
for $x in doc("libros.xml")/tienda_libros/libro
where $x/precio>30
return $x/titulo
}
</resultado>
Cuyo resultado será:

<resultado>
<titulo idioma="ingles">XQuery Quick Start</titulo>
<titulo idioma="castellano">Aprender XML</titulo>
</resultado>
Podemos lanzar una consulta que nos devuelva ordenados los libros cuyo precio es
inferior a 35 €:
55 de 76
<resultado>
{
where $x/precio<35
order by $x/titulo
return $x/titulo
}
</resultado>
Con el siguiente resultado:

<resultado>
<titulo idioma="castellano">Cocina Italiana</titulo>
<titulo idioma="castellano">Harry Potter</titulo>
</resultado>
Podemos obtener un documento HTML como salida de una consulta XQuery,

obteniendo en forma de lista todos los libros disponibles ordenados alfabéticamente:
<ul>
{
for $x in doc("libros.xml")/tienda_libros/libro/titulo
order by $x
return
<li>{data($x)}</li>
}
</ul>
Siendo el resultado:
<ul>
<li>Aprender XML</li>
<li>Cocina Italiana</li>
<li>Harry Potter</li>
<li>XQuery Quick Start</li>
</ul>
También se pueden aplicar sentencias condicionales a las consultas XQuery:
<resultado>
{
return if ($x/@categoria="INFANTIL")
then <infantil>{data($x/titulo)}</infantil>
else <adulto>{data($x/titulo)}</adulto>
}
</resultado>

<resultado>
<adulto>Cocina Italiana</adulto>
<infantil>Harry Potter</infantil>
<adulto>XQuery Quick Start</adulto>
<adulto>Aprender XML</adulto>
</resultado>
56 de 76
Podemos obtener aquellos libros que estén en castellano, y mostrar su titulo y su autor
en otro documento XML
<resultado>
{
for $x in doc(“libros.xml”)/tienda_libros/libro/titulo
where $x/titulo/@idioma = “castellano”
order by $x
return <titulo autor=”{data($x\autor)}”>{data($x)}</titulo>
}
</resultado>

<resultado>
<titulo autor="Erik T. Ray">Aprender XML</titulo>
<titulo autor="Giada De Laurentiis">Cocina Italiana</titulo>
<titulo autor="J K. Rowling">Harry Potter</titulo>
</resultado>
Para ejecutar las consultas basta lanzar el siguiente comando:
java -cp <ruta>/saxon8.jar net.sf.saxon.Query -t

<ruta>/consulta.xq > <ruta>/salida.<extension>
Con lo que se puede obtener como salida un documento HTML o XML, según se
desee.
57 de 76
Capítulo 9: Sindicación de contenidos y RSS
9.1. Introducción.
La sindicación de contenidos o redifusión es un proceso mediante el cual se puede
compartir la información de determinados sitios Web para usarla en otros que sitios o
programas. Es utilizada sobre todo en sitios Web que se actualizan con frecuencia.
El proceso de sindicación de contenidos esta basado en el uso de protocolos de la

familia de tecnologías XML, de los cuales el más popular es RSS.
RSS no es más que un sencillo formato de datos usado para sindicar (redifundir)
contenidos a suscriptores de un sitio Web. Las siglas RSS corresponden a distintos protocolos:
• Rich Site Summary (RSS 0.91)

• RDF Site Summary (RSS 0.9 y 1.0)
• Really Simple Syndication (RSS 2.0)
El proceso de sindicación consiste en que desde un sitio Web se puede distribuir

contenido sin necesidad de usar un navegador.
Así, cuando un sitio Web permite sindicación, cada vez que este sea actualizado,
generará un documento RSS que se enviará a todos aquellos usuarios “sindicados” o suscritos
al sitio en cuestión, y dicho documento será gestionado por unos programas especiales, que
leen y presentan la información RSS y que se denominan sindicadores o agregadores de
contenidos.
Gracias a estos agregadores o lectores de contenidos se puede obtener resúmenes de

todos los sitios que se desee, y a los que previamente se haya sindicado el usuario, desde el
escritorio del sistema operativo, mediante programas de correo electrónico o por medio de
aplicaciones Web que funcionan como agregadores. De esta forma no es necesario abrir el
navegador y visitar decenas de webs.
Algunos de los agregadores más populares son:
z Bloglines.
z NetNewsWire.
z iTunes.
z Firefox Live Bookmarks.
z iPodder.
z My Yahoo.
z FeedDemon.
z NewsGator Online.
z Pluck.
9.2. Usos de RSS.

El formato RSS tiene dos aplicaciones fundamentales:
z Recibir información desde otros sitios Web

z Ofrecer información desde nuestra Web
9.2.1. Cómo usar el RSS para recibir información

Para poder utilizar el RSS para recibir contenidos, el usuario debe disponer de un
agregador.
58 de 76
Existe una gran variedad de estos, pero todos ellos se pueden clasificar en tres
categorías:
z Agregadores de escritorio: Aplicaciones de escritorio que se instalan en el ordenador

del usuario.
z Agregadores en línea: No necesitan de instalación por parte del usuario. Suele bastar
con darse de alta en el sitio del agregador para poder utilizarlo.
z Agregadores como plug-ins: Algunos navegadores y gestores de correo como
Firefox, Nestcape, Opera, Thunderbird, etc. los incluyen en sus programas como
servicio de valor añadido al usuario.
Una vez que el usuario dispone del agregador que haya elegido, debe seleccionar
aquellos contenidos o archivos RSS (también denominados “feeds”) que sean de mayor interés
para él y realizar la sindicación de contenidos.
Los “feeds” suelen indicarse en las páginas Web mediante pequeños cuadros que
incluyen las siglas "RSS".
Al pulsar sobre dichos iconos aparecerá en el navegador del usuario una página en la
que se muestra el código del canal RSS. Este código solo es interpretado de forma correcta por
un agregador, mediante el cual se mostrará al usuario la información de forma que este pueda
leerla sin dificultad.
Para suscribirse a un “feed”, por lo general, el usuario debe copiar la dirección URI del
archivo RSS y escribirla en su agregador.
9.2.2. Cómo usar el RSS para ofrecer información

El otro uso fundamental de RSS es el de ofrecer información desde nuestro sitio Web.
El código necesario para crear un “feed” o documento RSS debe incluir tanto
información sobre el sitio Web del que procede y que, por tanto, será información no variable,
como datos sobre los contenidos que ofrece y que se actualizarán cada breve periodo de
tiempo. Esta será la información variable ofrecida en la sindicación.
Todos estos datos deben ir correctamente ordenados con sus correspondientes

etiquetas de principio y final según lo establecido en el lenguaje de marcado XML, y que se
explicará a continuación.
9.3. Como crear un RSS.

Como se ha comentado anteriormente, el formato RSS está basado en XML, y por
tanto, como todos los documentos XML debe incluir una declaración que lo determine como tal.
La primera línea de código RSS será, por tanto, la que define el lenguaje de marcado y
el tipo de caracteres que vamos a utilizar.
<?xml version="1.0" encoding="ISO-8859-1" ?>
La siguiente etiqueta del documento debe especificar a cual de las tres

especificaciones de RSS corresponde la sintaxis de este documento RSS en concreto. Para
ello se utiliza la etiqueta <rss> con su atributo version. En este ejemplo vamos a seguir las
reglas de sintaxis de "Really Simple Syndication (RSS 2.0)".
El aspecto del documento será, por tanto:

<rss version="2.0">
</rss>
59 de 76
Todos las demás etiquetas que se van a utilizar para crear el “feed” deben situarse
entre estas dos de <rss>, que son las que indican que estamos creando un documento RSS.
Dentro de este documento se debe crear un "canal", que es el elemento en el que se

introducirán los contenidos que se quieren mostrar a los demás usuarios.
Para ello bastará con utilizar el elemento <channel> dentro del elemento <rss>:

<rss version="2.0">
<channel>
</channel>
</rss>
Todo canal RSS se compone de dos partes esencialmente:
• Elementos no variables: Aquellos que proporcionan información relativa al sitio Web

del que procede la información:
• Elementos variables: Información relativa a cada una de las actualizaciones que se
realizan en el sitio Web.
Una vez creado el canal, es necesario definir los elementos no variables del mismo.
Existen distintos elementos no variables, pero sólo tres son obligatorios, a través de los
que se va a describir el canal RSS en general, y que son los siguientes:
• Título: Que se define mediante la etiqueta <title>, y que hará referencia al nombre
del “feed”.
• Enlace: Que se define mediante la etiqueta <link>, y que define la URL del sitio Web
desde el que se proporciona la información.
• Descripción: Que se define mediante la etiqueta <description>, y que informa al
usuario del tipo de contenidos que se van a incluir en el canal.
Así, si se incluyen los citados elementos en el canal que se creo anteriormente, el aspecto
del documento RSS será el siguiente:

<rss version="2.0">
<channel>
<title>Nombre del “feed”</title>

<link>Dirección Web en la que se encuentre el RSS</link>
<description>Contenido que se va a ofrecer a los
usuarios</description>
</channel>
</rss>
Tras la definición de los elementos no variables, ahí que definir los elementos variables.
Los elementos variables de un canal RSS se denominan "ítem", se definen mediante la

etiqueta <item> y pueden incluirse varios en un mismo canal. Se sitúan entre las etiquetas
<channel> justo después de los elementos no variables.
Obligatoriamente se deben incluir en el canal tres elementos variables, aunque, como

en el caso anterior, existen más.
60 de 76
Estos elementos obligatorios vuelven a ser:
z Título: Que se define mediante la etiqueta <title>, y que representa el titulo del
articulo que se esta enviando
z Enlace: Que se define mediante la etiqueta <link>, y que indica la dirección Web a la
que se puede ir para ampliar la información
z Descripción: Que se define con la etiqueta <description>, y que muestra el

contenido del articulo que se está enviando.
Así, si se incluye un elemento <item> en el canal que se había definido anteriormente, el

aspecto del documento será el siguiente:

<rss version="2.0">
<channel>
<title>Nombre del “feed”</title>
<link>Dirección Web en la que se encuentre el RSS</link>
<description>Contenido que se va a ofrecer a los
usuarios</description>
<item>
<title>Título del artículo</title>
<link>Dirección Web a la se puede ir para ampliar
esta información</link>
<description>Contenido de la
información</description>
</item>
</channel>
</rss>
Los ficheros creados se almacenan con extensión .rss o .xml.
61 de 76
Capítulo 10: SOAP (Simple Object Access Protocol)

10.1. Introducción.
Es un protocolo simple pero extensible, independiente de la plataforma y basado en
XML, para el intercambio de información entre aplicaciones mediante el envío de mensajes a
través de Internet, en un entorno distribuido y descentralizado. Es un método para que un
programa rodando en un sistema operativo concreto se comunique con otro programa rodando
en el mismo o en otro sistema operativo mediante el uso de protocolos como HTTP, SMTP,
FTP… y el lenguaje XML como mecanismo de intercambio de información. Especifica como
codificar y empaquetar una cabecera HTTP y un fichero XML de modo que un programa en un
ordenador pueda llamar a otro programa en un ordenador diferente y pasarle información,
especificando el mecanismo de respuesta. Sus llamadas pasan generalmente muy fácilmente
por un cortafuegos ya que las peticiones HTTP son normalmente algo permitido.
Consta de tres partes fundamentales:
• SOAP envelope: Marco general para expresar el contenido de un mensaje, quien debe
gestionarlo y si es opcional u obligatorio.
• SOAP encoding rules: Definen un mecanismo de serializacion que puede ser utilizado
para intercambiar instancias de tipos de datos definidos por aplicaciones particulares.
• La representación SOAP RPC define una convención que se puede utilizar para
representar llamadas a procedimientos remotos y sus correspondientes respuestas.
Uno de los mayores objetivos de SOAP es la simplicidad y la extensibilidad.
La estructura del mensaje SOAP es parecida a un documento HTML, componiéndose

de cabecera y cuerpo, ambas contenidas en el SOAP envelope.
10.2. Web Services.

Un Web Service es una interfaz, accesible por protocolos (estándar o no) usados en
Internet, que permite acceder a las funcionalidades de un objeto concreto, sin importar la
tecnología ni plataformas implicadas en la petición. Suele utilizar HTTP y la comunicación entre
los elementos del entorno requiere un lenguaje común estándar como XML.
Utiliza otros protocolos como SOAP, WSDL, UDDI o WSIL.
10.2.1. Lenguaje de descripción de servicios Web (WSDL – Web

Services Description Language).
Es el documento que servirá para realizar la descripción funcional y técnica del
Webservice. WSDL es un formato XML que describe los servicios de red como un conjunto de
puntos finales que procesan mensajes contenedores de información orientada a documentos y
procedimientos. WSDL es extensible, e independiente de los formatos de los mensajes o
protocolos utilizados para comunicarse (SOAP, HTTP, GET/POST o MIME)
La estructura de los documentos XML es la siguiente:
• <definitions>. El elemento <definitions> contiene la definición de uno o más servicios.

En la mayoría de los casos, un archivo WSDL define un servicio únicamente. Seguido
de la etiqueta de definición se encontrarán declaraciones de algunos atributos.
Dentro de la etiqueta <definitions> se encuentran tres secciones conceptuales:
o <message> y <portType>, describe qué operaciones provee el servicio.
o <binding>, describe cómo se invocan las operaciones.
o <service>, describe dónde se ubica el servicio.
o <documentation>, cualquier elemento WSDL puede contener información del
servicio para el usuario.
62 de 76
La mayoría de las herramientas incluyen una forma de generar WSDL a partir de una
componente, incluyendo el WSTK de IBM y el .NET Studio de Microsoft.
Un ejemplo en: http://www.xignite.com/xFutures.asmx?WSDL
10.2.2. UDDI (Universal Description, Discovery and Integration)

Es un registro de Web Services que contiene información a escala mundial de los
servicios prestados por cada una de las empresas registradas. UDDI es el protocolo usado
para la identificación del servicio buscado.
Es una base de datos a nivel mundial gestionada por una alianza de empresas para
obtener información de Web Services y de las empresas que los proporcionan.
La pila de protocolos en la pila de interoperabilidad de los servicios Web:
Pila de Interoperabilidad de UDDI (Universal Description, Forma de publicar y descubrir

Servicios Web Discovery and Integration). información acerca de
Servicios Web
SOAP (Simple Object Mecanismo ligero y sencillo
Access Protocol). para el intercambio de
información en un
ambiente descentralizado y
distribuido
XML (eXtensible Markup Estándar universal para el
Language). intercambio de datos
Protocolos Comunes de
Internet (HTTP, TCP/IP...).
ebXML ha sido también desarrollado para hacer lo mismo. UDDI/SOAP y ebXML son
tecnologías complementarias y se pueden utilizar a la vez.
UDDI provee un mecanismo para que los negocios se describan a si mismo y los tipos
de servicios que proporcionan y luego se puedan registrar y publicar en un registro UDDI.
10.2.3. WSIL (Web Service Inspection Language).

El lenguaje de inspección de servicios Web mantiene listas de enlaces a direcciones en
las que se halla presente un WSDL. El UDDI es un registro centralizado y WSIL son listas
distribuidas.
WSIL funciona de forma descentralizada, se apoya de manera importante en el fichero

de descripción WSDL, siendo una lista de punteros hacia documentos WSDL y al usar XML
como soporte base es extensible mediante el uso de namespaces.
10.2.4. Ejemplo de funcionamiento.

NOTA: Ver http://www.w3schools.com/webservices/tempconvert.asmx
Sea una función que convierte los grados Celsius a Fahrenheit, que se llama:
celsiusToFahrenheit:
public short celsiusToFahrenheit(short Celsius) {

short fahren;
fahren = celsius*1.8+32;
return fahren;
}
63 de 76
Dicha función debería ser publicada en un servidor de aplicaciones, que generaría su

WSDL
La petición SOAP será:
POST /webservices/tempconvert.asmx HTTP/1.1

Host: www.w3schools.com
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
<?xml version="1.0" encoding="utf-8"?>

<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
<soap12:Body>
<CelsiusToFahrenheit xmlns="http://tempuri.org/">
<Celsius>15</Celsius>
</CelsiusToFahrenheit>
</soap12:Body>
</soap12:Envelope>
Y la respuesta:
HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
<?xml version="1.0" encoding="utf-8"?>

<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
<soap12:Body>
<CelsiusToFahrenheitResponse
xmlns="http://tempuri.org/">
<CelsiusToFahrenheitResult>59</CelsiusToFahrenh
eitResult>
</CelsiusToFahrenheitResponse>
</soap12:Body>
</soap12:Envelope>
64 de 76
Capítulo 10: Casos Prácticos.

10.1. Caso práctico 1.
Se quiere recoger la información correspondiente a cada uno de los grupos que dan
clases en una academia mediante documentos XML, los requisitos que se piden para esos
documentos son los siguientes:
• En el documento se ha de recoger información acerca de los profesores, a los alumnos

y al material que se entrega a los mismos. Para cada grupo se almacenará el curso.
• Debe existir como mínimo un profesor, pudiendo existir muchos.
• Debe existir como mínimo un alumno, pudiendo existir muchos.
• Puede entregarse ninguna, una o mucha documentación
• De cada profesor se almacena el nombre y la asignatura que imparte.
• De cada alumno se almacena su nombre y su titulación.
• De cada alumno se almacenará además las asignaturas de las que se encuentra
matriculado.
• Un alumno puede estar matriculado en una o muchas asignaturas.
• De cada material se almacena su tipo, el nombre y la URI en la que se puede acceder
al mismo.
• El material puede ser de varios tipos: Tema, ejercicios y documentación adicional.
En base a los requisitos expuestos, se va a obtener:
• El DOM correspondiente al problema planteado.

• Una DTD para el mismo.
• Un XML Schema para el mismo.
• Un documento XML valido para la DTD
• Un documento XML valido para el XML Schema.
• Una hoja de transformación XSLT para obtener, a partir del documento XML original, lo
siguiente:
o Una pagina Web escrita con código XHTML.
Un modelo de objeto documento que corresponderá al problema planteado puede ser

el siguiente:
GRUPO
curso
PROFESORES ALUMNOS MATERIAL
tipo
nombre URI
profesor profesor
nombre asignatura alumno alumno
nombre
titulación
asignatura asignatura
65 de 76
Una DTD valida para este modelo puede ser:
<!ELEMENT grupo (profesores,alumnos,material*)>

<!ATTLIST grupo curso CDATA #REQUIRED>
<!ELEMENT profesores (profesor+)>
<!ELEMENT profesor EMPTY>
<!ATTLIST profesor nombre CDATA #REQUIRED>
<!ATTLIST profesor asignatura CDATA #REQUIRED>
<!ELEMENT alumnos (alumno+)>
<!ELEMENT alumno (asignatura+)>
<!ATTLIST alumno nombre CDATA #REQUIRED>
<!ATTLIST alumno titulacion CDATA #REQUIRED>
<!ELEMENT asignatura (#PCDATA)>
<!ELEMENT material EMPTY>
<!ATTLIST material tipo (Tema|Ejercicios|Documentacion)
#REQUIRED>
<!ATTLIST material nombre CDATA #REQUIRED>
<!ATTLIST material URI CDATA #REQUIRED>
Que se almacenará en el fichero “grupo.dtd”.
Un documento XML valido con respecto a esta DTD puede ser:
<?xml version=”1.0” encoding=”ISO-8859-1”?>

<!DOCTYPE grupo SYSTEM “grupo.dtd”>
<grupo curso=”2006/2007”>
<profesores>
<profesor nombre=”Carlos” asignatura=”Informática”/>
<profesor nombre=”Ana” asignatura=”Matemáticas”/>
<profesor nombre=”Luis” asignatura=”Lengua”/>
</profesores>
<alumnos>
<alumno nombre=”Pedro” titulacion=”ESO”>
<asignatura>Matematicas</asignatura>
<asignatura>Lengua</asignatura>
</alumno>
<alumno nombre=”Elena” titulacion=”Bachillerato”>
</alumno>
<alumno nombre=”Aurora” titulacion=”Magisterio”>
<asignatura>Informatica</asignatura>
</alumno>
</alumnos>
<material tipo=”Tema” nombre=”Tema 1”
URI=”http://www.academia.es/temas/tema1”/>
<material tipo=”Ejercicios” nombre=”Ejercicio 2” URI=”
http://www.academia.es/ejercicios/ejercicio2”/>
<material tipo=”Documentacion” nombre=”documento1” URI=”
http://www.academia.es/documentacion/documento1”/>
<material tipo=”Tema” nombre=”Tema2” URI=”
http://www.academia.es/temas/tema2”/>
</grupo>
Que se almacenará en el fichero “grupo1.xml”.
Un XML Schema que modelase el problema podría ser:

<xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema”>
66 de 76


<xs:element name=”asignatura” type=”xs:string”/>


<xs:element name=”alumno” >
<xs:complexType>
<xs:sequence>
<xs:element ref=”asignatura”
maxOccurs=”ubounded”/>
</xs:sequence>
<xs:attribute name=”nombre” type=”xs:string”
use=”required”/>
<xs:attribute name=”titulacion”
type=”xs:string” use=”required”/>
</xs:complexType>
</xs:element>
<xs:element name=”alumnos”>
<xs:complexType>
<xs:sequence>
<xs:element ref=”alumno”
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=”profesor” >

<xs:complexType>
<xs:attribute name=”asignatura”
type=”xs:string” use=”required”/>
</xs:complexType>
</xs:element>
<xs:element name=”profesores”>
<xs:complexType>
<xs:sequence>
<xs:element ref=”profesor”
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:simpleType name=”tipoMaterial”>
<xs:list base=”string”/>
<xs:length value=”3”/>
<xs:enumeration value=”Tema”/>
<xs:enumeration value=”Ejercicios”/>
<xs:enumeration value=”Documentacion”/>
</simpleType>
<xs:element name=”profesor” >

<xs:complexType>
<xs:attribute name=”tipo” type=”tipoMaterial”
<xs:attribute name=”URI” type=”xs:string”
67 de 76
</xs:complexType>
</xs:element>


<xs:element name=”grupo”>
<xs:complexType>
<xs:sequence>
<xs:element ref=”profesores”/>
<xs:element ref=”alumnos”/>
<xs:element ref=”material”
</xs:sequence>
<xs:attribute name="curso" type="xs:string"
use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Que se almacenará en el fichero “grupo.xsd”
Y un documento XML valido:

<grupo curso=”2006/2007”
xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
xs:schemaLocation="http://www.academia.es grupo.xsd">
<profesores>
<profesor nombre=”Carlos” asignatura=”Informática”/>
<profesor nombre=”Ana” asignatura=”Matemáticas”/>
<profesor nombre=”Luis” asignatura=”Lengua”/>
</profesores>
<alumnos>
<alumno nombre=”Pedro” titulacion=”ESO”>
</alumno>
<alumno nombre=”Elena” titulacion=”Bachillerato”>
</alumno>
<alumno nombre=”Aurora” titulacion=”Magisterio”>
<asignatura>Informatica</asignatura>
</alumno>
</alumnos>
<material tipo=”Tema” nombre=”Tema 1”
URI=”http://www.academia.es/temas/tema1”/>
<material tipo=”Ejercicios” nombre=”Ejercicio 2” URI=”
http://www.academia.es/ejercicios/ejercicio2”/>
<material tipo=”Documentacion” nombre=”documento1” URI=”
http://www.academia.es/documentacion/documento1”/>
<material tipo=”Tema” nombre=”Tema2” URI=”
http://www.academia.es/temas/tema2”/>
</grupo>
Que se almacenará en el fichero “grupo2.xml”.
Se va a obtener ahora una hoja de transformación XSLT que va a permitir transformar

el documento XML en un documento XHTML:
68 de 76

<html>
<title>
Curso Academico <xsl:value-of
select="/grupo/@curso"/>
</title>
<body>
<center><h2><b>Curso Academico
<xsl:value-of select="/grupo/@curso"/></b></h2></center>
<br/>
<hr/>
<br/>
<center><b>Profesores</b></center>
<br/>
<center><table border="1">
<tr>
<td>Nombre</td>
<td>Asignatura</td>
</tr>
select="grupo/profesores"/>
</table></center>
<br/>
<hr/>
<br/>
<center><b>Alumnos</b></center>
<br/>
<center>
select="grupo/alumnos"/>
</center>
<br/>
<hr/>
<br/>
<center><b>Materiales</b></center>
<br/>
<center>
select="grupo/material"/>
</center>
</body>
</html>
</xsl:template>
<xsl:template match="profesores">
<xsl:for-each select="profesor">
</xsl:for-each>
</xsl:template>
<xsl:template match="profesor">
<tr>
<td>
<xsl:value-of select="@nombre"/>
</td>
<td>
<xsl:value-of select="@asignatura"/>
</td>
69 de 76
</tr>
</xsl:template>
<xsl:template match="alumnos">
<xsl:for-each select="alumno">
</xsl:for-each>
</xsl:template>
<xsl:template match="alumno">
<b>Nombre:</b> <xsl:value-of select="@nombre"/>
<b> Titulación:</b> <xsl:value-of
select="@titulacion"/>
<b> Asignaturas:</b>
<xsl:for-each select="*">
<xsl:choose>
<xsl:when
test="//asignatura[position()=last()]">
<xsl:value-of select="."/>.
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="."/>,
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<br/>
</xsl:template>
<xsl:template match="material">
<b>Nombre:</b><i> <xsl:value-of select="@nombre"/>
</i>
<b> Tipo:</b><i> <xsl:value-of select="@tipo"/> </i>
<b> URI:</b><i> <xsl:value-of select="@URI"/> </i>
<br/>
</xsl:template>
</xsl:stylesheet>
Que se almacenará en el fichero “grupo1.xsl”.
Si le añadimos a la cabecera del documento “grupo.xml” la siguiente sentencia,

obtendremos la página deseada:
<?xml-stylesheet type=”text/xsl” href=”grupo1.xsl”?>
10.2. Caso práctico 2.

Se quiere recoger información correspondiente a las tiendas que forman parte de una
cadena de supermercados, con los siguientes requisitos:
• En el documento se ha de recoger información acerca de los empleados y del stock

disponible en la tienda. También se almacenará la ubicación de la misma.
• La tienda puede tener un único jefe de tienda, de uno a tres jefes de turno y uno o
varios cajeros.
• De cada empleado se almacena su nombre y su antigüedad
• El stock almacena información sobre los productos que hay en la tienda
• Existen varios productos
• De cada producto se almacena su tipo (congelado, fresco o seco), su descripción, su
precio y su estado (disponible o no disponible).
70 de 76
En base a los requisitos expuestos, se va a obtener:
• El DOM correspondiente al problema planteado.

• Una DTD para el mismo.
• Un XML Schema para el mismo.
• Un documento XML valido para la DTD
• Un documento XML valido para el XML Schema.
• Una hoja de transformación XSLT para obtener, a partir del documento XML original, lo
siguiente:
o Una pagina Web escrita con código XHTML.
Un modelo de objeto documento que corresponderá al problema planteado puede ser

el siguiente:
TIENDA
ubicación
EMPLEADOS STOCK
jefe_tienda cajero
producto producto
precio precio
id id estado estado
antigüedad antigüedad
tipo tipo
jefe_turno
id antigüedad
Una DTD valida para ese modelo puede ser:
<!ELEMENT tienda (empleados,stock)>

<!ATTLIST tienda ubicacion CDATA #REQUIRED>
<!ELEMENT empleados (jefe_tienda, jefe_turno+, cajero+)>
<!ELEMENT jefe_tienda (#PCDATA)>
<!ATTLIST jefe_tienda id CDATA #REQUIRED>
<!ATTLIST jefe_tienda antiguedad CDATA #REQUIRED>
<!ELEMENT jefe_turno (#PCDATA)>
<!ATTLIST jefe_turno id CDATA #REQUIRED>
<!ATTLIST jefe_turno antiguedad CDATA #REQUIRED>
<!ELEMENT cajero (#PCDATA)>
<!ATTLIST cajero id CDATA #REQUIRED>
<!ATTLIST cajero antiguedad CDATA #REQUIRED>
<!ELEMENT stock (producto+)>
71 de 76
<!ELEMENT producto (#PCDATA)>

<!ATTLIST producto tipo (congelado|fresco|seco) #REQUIRED>
<!ATTLIST producto estado (disponible|no_disponible) #REQUIRED>
<!ATTLIST producto precio CDATA #REQUIRED>
Que se almacenará en el fichero “tienda.dtd”.
Y un documento DTD valido con respecto a esa DTD:

<!DOCTYPE tienda SYSTEM "tienda.dtd">
<tienda ubicacion="C/ Comercio, 27">

<empleados>
<jefe_tienda id="1" antiguedad="4
años">Carmen</jefe_tienda>
<jefe_turno id="2" antiguedad="2
años">Luis</jefe_turno>
años">Maria</jefe_turno>
<jefe_turno id="4" antiguedad="1 año y 6
meses">Antonio</jefe_turno>
<cajero id="5" antiguedad="1 año">Eva</cajero>
<cajero id="6" antiguedad="6 meses">Pedro</cajero>
<cajero id="7" antiguedad="6 meses">Ana</cajero>
<cajero id="8" antiguedad="4
meses">Alejandro</cajero>
<cajero id="9" antiguedad="2 meses">Pilar</cajero>
</empleados>
<stock>
<producto tipo="congelado" precio="5"
estado="disponible">merluza</producto>
<producto tipo="fresco" precio="3"
estado="no_disponible">manzana</producto>
<producto tipo="seco" precio="2,5"
estado="disponible">pan</producto>
estado="disponible">pera</producto>
estado="no_disponible">helado</producto>
</stock>
</tienda>
Que se almacenará en el fichero “tienda1.xml”
Un XML Schema que modelase el problema podría ser:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">


<xs:simpleType name="tipos">
<xs:list base="xs:string"/>
<xs:length value="3"/>
<xs:enumeration value="fresco"/>
<xs:enumeration value="congelado"/>
<xs:enumeration value="seco"/>
</xs:simpleType>
<xs:simpleType name="estados">
<xs:list base="xs:string"/>
72 de 76
<xs:length value="2"/>
<xs:enumeration value="disponible"/>
<xs:enumeration value="no_disponible"/>
</xs:simpleType>


<xs:attributeGroup name="empleado">
<xs:attribute name="id" type="xs:int"
use="required"/>
<xs:attribute name="antiguedad" type="xs:string"
use="required"/>
</xs:attributeGroup>
<xs:element name="jefe_tienda">
<xs:complexType>
<xs:attribute ref="empleado"/>
</xs:complexType>
</xs:element>
<xs:element name="jefe_turno">
<xs:complexType>
</xs:complexType>
</xs:element>
<xs:element name="cajero">
<xs:complexType>
</xs:complexType>
</xs:element>
<xs:element name="empleados">
<xs:complexType>
<xs:sequence>
<xs:element ref="jefe_tienda"/>
<xs:element ref="jefe_turno"
maxOccurs="3"/>
<xs:element ref="cajero"
maxOccurs="ubounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="producto">
<xs:complexType>
<xs:attribute name="tipo" type="tipos"
use="required"/>
<xs:attribute name="precio" type="xs:float"
use="required"/>
<xs:attribute name="estado" type="estados"
use="required"/>
</xs:complexType>
</xs:element>
<xs:element name="stock">
<xs:complexType>
<xs:sequence>
<xs:element ref="producto"
maxOccurs="ubounded"/>
</xs:sequence>
</xs:complexType>
73 de 76
</xs:element>


<xs:element name="tienda">
<xs:complexType>
<xs:sequence>
<xs:element ref="empleados"/>
<xs:element ref="stock"/>
</xs:sequence>
<xs:attribute name=”ubicacion” type=”xs:string”
</xs:complexType>
</xs:element>
</xs:schema>
Que se almacenará en el fichero “tienda.xsd”
Y un documento XML valido:

<tienda ubicacion="C/ Comercio, 27"
xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
xs:schemaLocation="http://www.tienda.es tienda.xsd">
<empleados>
<jefe_tienda id="1" antiguedad="4
años">Carmen</jefe_tienda>
años">Luis</jefe_turno>
años">Maria</jefe_turno>
<jefe_turno id="4" antiguedad="1 año y 6
meses">Antonio</jefe_turno>
<cajero id="5" antiguedad="1 año">Eva</cajero>
<cajero id="6" antiguedad="6 meses">Pedro</cajero>
<cajero id="7" antiguedad="6 meses">Ana</cajero>
<cajero id="8" antiguedad="4
meses">Alejandro</cajero>
<cajero id="9" antiguedad="2 meses">Pilar</cajero>
</empleados>
<stock>
estado="disponible">merluza</producto>
estado="no_disponible">manzana</producto>
<producto tipo="seco" precio="2,5"
estado="disponible">pan</producto>
estado="disponible">pera</producto>
estado="no_disponible">helado</producto>
</stock>
</tienda>
Que se almacena en el documento “tienda2.xml”.
Se va a obtener ahora una hoja de transformación XSLT que va a permitir transformar

el documento XML en un documento XHTML:
74 de 76

<html>
<title>Tienda ubicada en <xsl:value-of
select="tienda/@ubicacion"/></title>
<body>
<center>
<h2>Descripción de la tienda
ubicada en <xsl:value-of select="tienda/@ubicacion"/></h2>
</center>
<br/>
<hr/>
<br/>
<center><b>Personal</b></center>
select="tienda/empleados"/>
<br/>
<hr/>
<br/>
<center><b>Stock</b></center>
select="tienda/stock"/>
<br/>
</body>
</html>
</xsl:template>
<xsl:template match="empleados">
<xsl:apply-templates select="jefe_tienda"/>
<b>Jefes de Turno: </b>
<br/>
<table border="0">
<tr>
<td><i>Nombre</i>
</td>
<td><i>Antigüedad</i>
</td>
</tr>
<xsl:apply-templates select="jefe_turno"/>
</table>
<br/>
<b>Cajeros: </b>
<br/>
<table border="0">
<tr>
<td><i>Nombre</i>
</td>
<td><i>Antigüedad</i>
</td>
</tr>
<xsl:apply-templates select="cajero"/>
</table>
</xsl:template>
<xsl:template match="jefe_tienda">
<b>Jefe de Tienda: </b><xsl:value-of select="."/>
<b>, Antiguedad: </b><xsl:value-of
select="@antiguedad"/>
75 de 76
<br/>
</xsl:template>
<xsl:template match="jefe_turno">
<tr>
<td><xsl:value-of select="."/></td>
<td><xsl:value-of select="@antiguedad"/></td>
</tr>
</xsl:template>
<xsl:template match="cajero">
<tr>
<td><xsl:value-of select="."/></td>
<td><xsl:value-of select="@antiguedad"/></td>
</tr>
</xsl:template>
<xsl:template match="stock">
<table border="0">
<tr>
<td><i>Descripción</i>
</td>
<td><i>Tipo</i>
</td>
<td><i>Precio</i>
</td>
<td><i>Estado</i>
</td>
</tr>
<xsl:apply-templates select="producto"/>
</table>
</xsl:template>
<xsl:template match="producto">
<tr>
<td><xsl:value-of select="."/>
</td>
<td><xsl:value-of select="@tipo"/>
</td>
<td><xsl:value-of select="@precio"/>
</td>
<td>
<xsl:if test="@estado='disponible'">
Stock suficiente
</xsl:if>
<xsl:if test="@estado='no_disponible'">
Stock agotado. Realizar Pedido.
</xsl:if>
</td>
</tr>
</xsl:template>
</xsl:stylesheet>
Que se almacenará en el fichero “tienda.xsl”.
Si le añadimos a la cabecera del documento “tienda.xml” la siguiente sentencia,

obtendremos la página deseada:
<?xml-stylesheet type=”text/xsl” href=”tienda.xsl”?>
76 de 76

XML Tecnologías y sus aplicaciones

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

XML Tecnologías y sus aplicaciones

Caricato da

Copyright:

Formati disponibili

Las Tecnologías XML y sus aplicaciones

Carlos J. Torrecilla Salinas

5.3.1. Introducción y concepto .............................................................. 41

Capitulo 1: ¿Qué es XML?

1.2. Origen de XML.

En febrero de 2004 se publicó la recomendación XML 1.1.

1.3. Características generales de XML.

Las características principales de XML son:

• Su formato es texto plano, usando caracteres Unicode (es decir de 16 bits).

XML Aplicación XML

1.4. Estructura del estándar XML.

• DTD (Document Type Definition): Definición de tipo de documento.

1.5. Uso de XML.

• Meta información: Uso de XML para describir meta-contenidos (información relativa al

Capítulo 2: Estructura y sintaxis de XML.

• Prólogo (o cabecera): En el se agrupan la declaración de documento XML, las

El texto de un documento XML esta compuesto por caracteres, usándose la

2.1.1. Documentos XML bien formados.

• Si no se usa DTD, el documento debe comenzar con un Declaración de Documento

2.1.2. Documentos XML validos.

Una documento validador proporciona la gramática para un tipo de documentos XML,

Para especificar cada tipo de documentos se utilizan unos lenguajes propios y

Los documentos que se ajustan a su DTD, se denominan "válidos". El concepto de

Resumiendo, los documentos XML podrán ser:

2.2. Sintaxis XML.

2.2.1. Cabecera XML.

En la cabecera XML se incluyen los siguientes elementos: la declaración XML,

Declaración XML: Indica que el documento es un documento XML, y tiene la siguiente

<?xml version=”1.0” encoding=”ISO-8859-1” standalone=”yes” ?>

Incluye tres atributos:

• version: Indica la versión de XML que se utilizará en el documento.

Instrucciones de procesamiento: Es una instrucción interpretada por la aplicación a

son la declaración de documento XML y la declaración de hoja de estilo. Tienen la siguiente

<?application atributo1=”valor” atributo2=”valor” ... ?>

Hay que aclarar algunos puntos sobre este tipo de marcas:

• No pueden existir espacios en blanco entre el carácter “<” y el carácter “?”.

Anteriormente hemos visto la declaración de documento XML, mientras que la

<?xml-stylesheet type=”text/xsl” href=”hoja.xsl” ?>

Una declaración usando DTD tiene la forma:

<!DOCTYPE elt.raiz declaraciones>

A continuación podemos ver un ejemplo de una declaración de tipo de documento

<!DOCTYPE definicion.dtd SYSTEM “definicion.dtd”>

Los comentarios se pueden introducir en cualquier parte del documento y pueden

Podemos ver algunos ejemplos:

Los elementos pueden ser de los siguientes tipos:

• Elementos sin atributos con datos.

2.2.3.1. Elementos sin atributos con datos.

Así en el caso de los siguientes ejemplos:

<etiqueta2>Texto asignado a la variable</etiqueta2>

etiqueta2 = “Texto asignado a la variable”.

2.2.3.2. Elementos con atributos y datos.

2.2.3.3. Elementos con atributos sin datos.

Podemos ver el siguiente ejemplo:

<elemento1 atributo=”valor” valor=”Datos”></elemento1>

Que será equivalente a:

<elemento1 atributo=”valor” valor=”Datos”/>

2.2.3.4. Elementos vacíos.

O bien, de modo abreviado:

Los atributos, de manera similar a HTML, se forman mediante un identificador, un signo

Un ejemplo de uso de atributos puede ser:

<elemento1 atributo=”valor” valor=”Datos”/>