Este documento proporciona una introducción al desarrollo de aplicaciones con XML. Explica las características básicas del XML como la sintaxis, elementos, atributos y datos. Además, describe las herramientas de validación DTD y XSD y los estándares XPath, XSLT y XSL-FO para transformar documentos XML. Por último, introduce las APIs DOM y JAXP de Java para el procesamiento de XML y los servicios web basados en XML.
1. II Curso Online JAVA-J2EE
TEMA 8
Desarrollo de aplicaciones con XML
Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La Mancha
Versión: 1.0
Fecha: Revisado 07-02-2008 11:46
Licencia: CC-by-sa 2.5
2. 0 Licencia
Usted es libre de:
Copiar, distribuir y comunicar públicamente la obra
Hacer obras derivadas
Bajo las condiciones siguientes:
Reconocimiento. Debe reconocer los créditos de la obra de la manera especificada por el
autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan el
uso que hace de su obra).
Compartir bajo la misma licencia. Si altera o transforma esta obra, o genera una obra
derivada, sólo puede distribuir la obra generada bajo una licencia idéntica a ésta.
• Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia
de esta obra.
• Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de
los derechos de autor
• Nada en esta licencia menoscaba o restringe los derechos morales del autor.
Para ver la licencia visite:
http://creativecommons.org/licenses/by-sa/2.5/es/legalcode.es
6 de febrero de 2008 Tema 8 2
3. UNIDAD VIII. DESARROLLO DE APLICACIONES CON XML
0 Licencia............................................................................................................................................2
1 Características del XML................................................................................................................4
1.1 Introducción a XML..................................................................................................................4
1.2 Sintaxis XML............................................................................................................................4
1.3 Componentes XML...................................................................................................................5
2 Validación: DTD y XSD.................................................................................................................8
2.1 Validación XML........................................................................................................................8
2.2 DTD...........................................................................................................................................8
2.3 XSD.........................................................................................................................................10
3 Estándar XSL: XPath, XSLT y XSL-FO....................................................................................16
3.1 Introducción XSL....................................................................................................................16
3.2 XPath (I)..................................................................................................................................16
3.3 XPath (II).................................................................................................................................18
3.4 XSLT.......................................................................................................................................20
3.5 XSL-FO...................................................................................................................................21
4 DOM y paquetes Java/XML........................................................................................................24
4.1 DOM........................................................................................................................................24
4.2 Java API para XML (JAXP)....................................................................................................26
5 Servicios web con J2EE................................................................................................................28
5.1 Introducción a los servicios Web.............................................................................................28
5.2 SOAP.......................................................................................................................................29
5.3 WSDL......................................................................................................................................30
5.4 UDDI.......................................................................................................................................30
5.5 Web Services y Java / J2EE.....................................................................................................31
6 de febrero de 2008 Tema 8 3
4. 1 Características del XML
1.1 Introducción a XML
XML (Extensible Markup Language o Lenguaje de Marcas Extensible) es un lenguaje de etiquetas
diseñado para describir los datos. El XML es una recomendación de la W3C (World Wide
Consortium).
XML <> HTML
XML está enfocado en los datos. Pretende describir la información.
HTML está enfocado en presentar los datos. Pretende mostrar la
información.
En XML las etiquetas no se encuentran predefinidas sino que te puedes definir tus propias etiquetas.
XML utiliza un DTD (Document Type Definition) o un XSD (XML Schema) para describir los
datos y definir unas reglas de validación de los mismos.
Con XML únicamente se definen los datos, para presentarlos se utiliza XSLT que permite
transformar dichos datos en otros formatos para presentarlos (por ejemplo, XHTML o FO).
Es importante dejar claro que el XML no hace nada. XML ha sido creado para estructurar,
almacenar y enviar información. A continuación podemos ver un sencillo ejemplo de XML que
presenta un correo de Juan a Jesús:
<correo>
<para>Jesus</para>
<de>Juan</de>
<resumen>Recuerda</resumen>
<cuerpo>El curso de Java empieza el 22 de septiembre</cuerpo>
</correo>
Este documento XML define un correo que tiene un resumen y un cuerpo. Además, también se
indica el destinatario y el remitente. Aun así, este documento XML no hace nada, simplemente
presenta la información agrupada con etiquetas. Se podría realizar una aplicación que envíe y reciba
correos pero eso ya no es parte del XML.
1.2 Sintaxis XML
Las reglas sintácticas del XML son muy sencillas pero también muy estrictas. A continuación
listamos dichas reglas:
1. Los documentos XML tienen que tener un único par de etiquetas que sean el elemento raíz.
El resto de etiquetas o elementos deben estar dentro del raíz y pueden ir anidándose.
2. Todos los elementos tienen que tener la etiqueta de cierre.
3. Las etiquetas distinguen entre mayúsculas y minúsculas (case sensitive).
4. Todos los elementos tienen que encontrarse debidamente anidados.
5. Los valores de los atributos que tengan las etiquetas deben ir siempre entre comillas.
6 de febrero de 2008 Tema 8 4
5. Veamos un ejemplo donde podemos comprobar la anterior lista de reglas.
<?xml version="1.0" encoding="ISO-8859-1"?>
<buzon_salida>
<correo id=”100”>
<para>Jesus</para>
<de>Juan</de>
<resumen>Recuerda</resumen>
<cuerpo>El curso de Java empieza el 22 de septiembre</cuerpo>
</correo>
<correo id=”111”>
<para>Alumnos</para>
<de>Juan</de>
<resumen>Importante</resumen>
<cuerpo>XML solo describe los datos</cuerpo>
</correo>
</buzon_salida>
La primera línea del documento se denomina declaración XML y define la versión del XML y la
codificación de caracteres utilizada. Esta línea no es obligatoria pero si recomendable.
El elemento raíz en éste documento es <buzon_salida>…</buzon_salida>. Comprueba como tanto
esta etiqueta como el resto tienen SIEMPRE una etiqueta de cierre.
El único atributo que se presenta en éste ejemplo es el ‘id’ de la etiqueta correo. En este ejemplo
queda claro que es un identificador numérico de cada correo y que, como hemos dicho, el valor que
toma se encuentra entre comillas.
La sintaxis para escribir comentarios dentro de los documentos XML es igual
que para el caso de HTML.
<!-- Esto es un comentario -->
1.3 Componentes XML
Los componentes que nos encontramos dentro de cualquier fichero XML son tres:
1. Elementos XML: son las etiquetas. Estos elementos son definidos por el creador del XML y
se pueden extender. Además, se encuentran relacionados entre ellos formando un árbol
jerárquico.
2. Atributos XML: los elementos XML pueden tener atributos en la etiqueta de inicio. Estos
atributos se utilizan para añadir información adicional sobre los elementos.
3. Datos: es la información que realmente se quiere guardar con el fichero XML.
6 de febrero de 2008 Tema 8 5
6. Elementos XML.
Vamos a resumir las características que definen a los elementos:
Los elementos XML son extensibles: cualquier documento XML puede añadir más
etiquetas para guardar más información y aquellas aplicaciones que usan dichos documentos
deberían seguir funcionando igualmente.
Los elementos XML se encuentran relacionados como padres e hijos formando un árbol
jerárquico. En la siguiente tabla se muestra con un ejemplo las relaciones entre los
elementos y como se denominan dichas relaciones en XML.
Los elementos pueden tener varios tipos de contenido. Pueden contener otros elementos,
contenido mixto, contenido simple o estar vacios. En el ejemplo 'libro' contiene otros
elementos, 'capitulo' tiene contenido mixto porque contiene tanto texto como otros
elementos, 'parrafo' tiene contenido simple o contenido de texto únicamente, 'prod' es un
elemento vacio y es el único elemento que tiene atributos (id y media).
<libro> Libro es el elemento raiz.
<titulo>Mi primer XML</titulo> Titulo, prod y capitulo son elementos
<prod id="1" media="pdf"></prod> hijo de libro.
<capitulo>Introducción a XML Libro es el elemento padre de titulo,
<parrafo>Que es HTML</parrafo> prod y capitulo.
<parrafo>Que es XML</parrafo> Titulo, prod y capitulo son siblings o
</capitulo> elementos hermano porque tienen el
<capitulo>Sintaxis XML mismo padre.
<parrafo>Los elementos deben tener
etiqueta de cierre</parrafo>
<parrafo>Los elementos deben estar
correctamente anidados</parrafo>
</parrafo>
</libro>
Reglas para el nombrado de los elementos:
1. Los nombres pueden contener letras, números u otros caracteres.
2. Los nombres no pueden empezar con número o un signo de puntuación.
3. Los nombres no pueden empezar con las letras xml (o sus variantes
mayúsculas y minúsculas, es decir, XML, Xml, XMl, etc).
4. Los nombres no pueden contener espacios.
5. Se recomienda que se den nombres descriptivos a los elementos y utilizar el
subrayado como separador (por ejemplo, primer_apellido, segundo_apellido)
Atributos XML.
Veamos las características que definen a los atributos:
Los atributos sólo pueden aparecer en la etiqueta de inicio de los elementos XML y
proporcionan información adicional sobre los elementos.
El valor que tengan dichos atributos es obligatorio que vaya entre comillas pero pueden
6 de febrero de 2008 Tema 8 6
7. utilizarse tanto comillas simples como dobles (sólo en el caso de que el valor de atributo
contenga un tipo de comillas se utilizaría la otra para encerrar dicho valor). A continuación
tenemos ejemplos de utilización de las comillas.
<persona sexo="hombre"> <cliente nombre='Paco "el gato" '>
<persona sexo='hombre'> <cliente nombre="Paco 'el gato' ">
¿Cuándo utilizar los atributos o cuando definir elementos?. Como vemos en el siguiente
ejemplo, los datos se pueden guardar en atributos o en elementos hijo.
<persona sexo="hombre"> <persona>
<nombre>Juan</nombre> <sexo>female</sexo>
<apellidos>Atienza García</apellidos> <nombre>Juan</nombre>
</persona> <apellidos>Atienza García</apellidos>
</persona>
No existen reglas para saber cuando utilizar atributos o elementos aunque en XML se debería evitar
utilizar los atributos y utilizar los elementos hijos. En la siguiente lista se presentan los problemas
que se dan cuando se utilizan atributos y por lo que se recomienda utilizar elementos:
Los atributos no pueden contener valores múltiples.
Los atributos no se pueden extender fácilmente.
Los atributos no pueden describir estructuras.
Los atributos son más difíciles de manipular por los programas.
Los atributos no se pueden validar con DTDs.
6 de febrero de 2008 Tema 8 7
8. 2 Validación: DTD y XSD
2.1 Validación XML
Un documento XML se dice que es válido si está 'bien formado' y, además, está escrito
conforme a las reglas que se definan en el fichero DTD o XSD asociado al mismo.
Un documento XML está 'bien formado' si está escrito siguiendo las reglas sintácticas que hemos
visto en la lección anterior:
Un documento XML debe tener un único elemento raíz.
Los elementos XML deben tener etiqueta de cierre.
Las etiquetas son case sensitive.
Los elementos XML deben estar correctamente anidados.
Los atributos XML deben tener sus valores encerrados entre comillas.
Mediante un fichero DTD (Document Type Definition) o XSD (XML Schema Definition) se
define la lista de elementos permitidos en los documentos XML junto con la estructura o
interrelación que deben presentar dichos elementos. En los siguientes apartados vamos a estudiar
con detalle ambos tipos de documentos.
2.2 DTD
Como hemos dicho anteriormente, un fichero DTD (Document Type Definition) define la lista de
elementos y la estructura que puede tener un documento XML.
Existen dos formas de relacionar un documento XML con su DTD:
1. Dentro del documento XML, se utiliza la etiqueta DOCTYPE con la sintaxis: <!DOCTYPE
elemento_raiz [declaracion_elementos]>
2. Como un fichero externo, se utiliza la etiqueta DOCTYPE con la sintaxis: <!DOCTYPE
elemento_raiz SYSTEM "nombre_fichero">
Tanto si es interno como externo los bloques para construir un fichero DTD son:
Elementos: son los bloques principales de construcción de los ficheros XML.
Atributos: proporcionan información adicional sobre los elementos.
Entidades: variables utilizadas para definir shorcuts a textos genéricos o caracteres
especiales.
PCDATA (Parsed Carácter Data): es texto que será parseado por el parseador. El parseador
buscará etiquetas y entidades dentro de este texto.
CDATA (Carácter data): es texto que NO será parseado por el parseador. Las etiquetas o
entidades que contenga dicho texto no serán tratadas.
Antes de definir más detalladamente cada uno de los bloques, vamos a recordar un ejemplo de
documento XML junto con su DTD que ya hemos visto:
ejemploXML.xml ejemploDTD.dtd
<?xml version="1.0?> <!ELEMENT correo (para,de,resumen,cuerpo)>
<!DOCTYPE correo SYSTEM <!ELEMENT para (#PCDATA)>
"ejemploDTD.dtd"> <!ELEMENT de (#PCDATA)>
<correo> <!ELEMENT resumen (#PCDATA)>
6 de febrero de 2008 Tema 8 8
9. <para>Jesus</para> <!ELEMENT cuerpo (#PCDATA)>
<de>Juan</de>
<resumen>Recuerda</resumen>
<cuerpo>El curso de Java empieza el 22 de
septiembre</cuerpo>
</correo>
Elementos.
Son los bloques principales de construcción. Se declaran utilizando la siguiente sintaxis:
<!ELEMENT nombre_elemento CATEGORIA>
La siguiente tabla presenta los valores que puede tomar la clave CATEGORIA:
CATEGORIA Descripción Ejemplo DTD Ejemplo XML
EMPTY Elemento que no va a <!ELEMENT br <br />
tener contenido. EMPTY>
(#PCDATA) Texto parseable. <!ELEMENT de <de>Juan</de>
(#PCDATA)>
(hijo1, hijo2,...) Elementos con uno o <!ELEMENT note Véase
más hijos. (to,from,heading,bod ejemploXML.xml
y)>
Se puede definir la cardinalidad u opcionalidad de los elementos mediante los siguientes caracteres
especiales:
Una única vez: <!ELEMENT nombre_elemento (elemento_hijo)>
Una o más veces: <!ELEMENT nombre_elemento (elemento_hijo+)>
Cero o más veces: <!ELEMENT nombre_elemento (elemento_hijo*)>
Cero o una vez: <!ELEMENT nombre_elemento (elemento_hijo?)>
Opcionalidad: <!ELEMENT nombre_elemento (elemento_hijo1|elemento_hijo2)>
Atributos.
Definen información adicional sobre los elementos. Se declaran utilizando la siguiente sintaxis:
<!ATTLIST nombre_elemento nombre_atributo tipo_atributo valor_defecto>
La siguiente tabla presenta los valores más normales que puede tomar el tipo de atributo:
TIPO DE ATRIBUTO Descripción
CDATA El valor es una cadena de caracteres.
(en1|en2|..) El valor pertenece a una lista enumerada.
ID El valor es un id único.
IDREF El valor es el id de otro elemento.
IDREFS El valor es una lista de otros ids.
El valor por defecto puede tener los siguientes valores:
VALOR Descripción
valor El valor por defecto del atributo.
#REQUIRED El atributo es obligatorio.
6 de febrero de 2008 Tema 8 9
11. Los esquemas son extensibles por estar escritos mediante XML, lo que permite reutilizar
esquemas, definir tipos de datos derivados de tipos de datos estándares, etc.
Antes de definir más detalladamente cada uno de los bloques que componen un XSD, vamos a ver
el fichero XSD que describe el ejemplo de documento XML que ya hemos visto anteriormente para
DTD:
ejemploXML.xml ejemploXSD.xsd
<?xml version="1.0?> <?xml version="1.0"?>
<correo <xs:schema
xmlns="http://www.iformacion.com" xmlns:xs="http://www.w3.org/2001/XMLSchem
xmlns:xsi="http://www.w3.org/2001/XMLSche a"
ma-instance" targetNamespace="http://www.iformacion.com"
xsi:schemaLocation="http://www.iformacion.co xmlns="http://www.iformacion.com"
m ejemploXSD.xsd"> elementFormDefault="qualified">
<para>Jesus</para> <xs:element name="correo">
<de>Juan</de> <xs:complexType>
<resumen>Recuerda</resumen> <xs:sequence>
<cuerpo>El curso de Java empieza el 22 de <xs:element name="para"
septiembre</cuerpo> type="xs:string"/>
</correo> <xs:element name="de" type="xs:string"/>
<xs:element name="resumen"
type="xs:string"/>
<xs:element name="cuerpo"
type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Como podemos ver en este ejemplo el elemento raíz de un fichero XSD es la etiqueta
<xs:schema> donde los atributos indican los servidores de donde proceden la definición de los
elementos y tipos de datos (namespace) utilizados en el fichero.
A continuación definimos el resto de elementos que se utilizan para definir un XML Schema.
Elementos simples.
Un elemento simple es un elemento XML (etiqueta) que únicamente contiene texto, es decir,
no puede contener otros elementos ni atributos. Cuando se dice texto no se refiere solamente a
cadenas de caracteres, también se incluyen los tipos de datos definidos en los XML Schema
(bolean, string, date, etc) o nuevos tipos definidos por los usuarios. Además, a los elementos
simples se le pueden añadir restricciones (facets) para delimitar el tipo de contenido o para que los
datos incluidos sigan un patrón determinado.
La sintaxis que se utiliza para definir los tipos simples es: <xs:element name="nombre_elemento"
type="tipo_dato"/>
Los esquemas XML tienen muchos tipos de datos predefinidos, los tipos más usuales son string,
decimal, integer, bolean, date y time.
En la siguiente tabla vemos varios ejemplos de elementos simples, en la izquierda podemos ver la
6 de febrero de 2008 Tema 8 11
12. definición XSD y en la derecha un ejemplo XML:
<xs:element name="nombre" <nombre>Juan Atienza</nombre>
type="xs:string"/> <edad>31</edad>
<xs:element name="edad" <fecha_nacimiento>1975-01-
type="xs:integer"/> 01</fecha_nacimiento>
<xs:element name="fecha_nacimiento"
type="xs:date"/>
Elementos complejos.
Un elemento complejo es un elemento XML (etiqueta) que contiene otros elementos y/o
atributos. Existen cuatro tipos de elementos complejos:
elementos vacios,
elementos que contienen solo otros elementos,
elementos que contienen solo texto,
elementos que contienen otros elementos y texto.
Todos los tipos definidos pueden contener también atributos.
Veamos, mediante un ejemplo, las diferentes maneras en que podemos definir los elementos
complejos. Vamos a definir el elemento XML ‘empleado’ que únicamente contiene otros elementos:
<empleado>
<nombre>Juan</nombre>
<apellidos>Atienza García</apellidos>
</empleado>
La primera forma de definir el elemento complejo ‘empleado’ es declarándolo directamente:
<xs:element name=”empleado”>
<xs:complexType>
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name="apellidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Definiendo el ‘empleado’ de la forma anterior, únicamente dicho elemento puede utilizar el tipo
complejo definido. A continuación, vamos a redefinir el elemento ‘empleado’ para que dicho tipo
complejo se pueda reutilizar:
<xs:element name="empleado" type="persona"/>
<xs:complexType name="persona">
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name="apellidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
6 de febrero de 2008 Tema 8 12
13. Definiendo el elemento del modo anterior, podemos reutilizar el tipo complejo ‘persona’ en
diferentes elementos:
<xs:element name="empleado" type="persona"/>
<xs:element name="estudiante" type="persona"/>
<xs:element name="cliente" type="persona"/>
<xs:complexType name="persona">
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name="apellidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
Incluso podemos utilizar dicho elemento complejo definido ‘persona’ como base para otros
elementos añadiéndole nuevos elementos:
<xs:element name="empleado" type="persona_completa"/>
<xs:complexType name="persona">
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name="apellidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="persona_completa">
<xs:complexContent>
<xs:extension base="persona">
<xs:sequence>
<xs:element name="edad" type="xs:integer"/>
<xs:element name="direccion" type="xs:string"/>
<xs:element name="telefono" type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
Dentro de los elementos complejos se utilizan etiquetas especiales que sirven de indicadores para
controlar como se definen los elementos en el documento XML. Existen siete tipos de indicadores
agrupados en:
Indicadores de orden:
All: los elementos pueden aparecer en cualquier orden.
Choice: elección entre varios elementos.
Sequence: los elementos deben aparecer en el orden indicado.
Indicadores de ocurrencias:
maxOccurs: indica el máximo número de veces que puede aparecer un elemento.
minOccurs: indica el mínimo número de ocurrencias.
Indicadores de grupo:
Grupo de Elementos: agrupa un conjunto de elementos bajo el mismo nombre.
Grupo de atributos: agrupa un conjunto de atributos bajo el mismo nombre.
6 de febrero de 2008 Tema 8 13
14. Atributos.
Los elementos simples no pueden tener atributos, si un elemento tiene atributos se considera un
elemento complejo. Pero los atributos por si mismo se declaran como tipos simples. La sintaxis para
definir atributos es: <xs:attribute name="nombre_atributo" type="tipo_dato"/>
Los tipos de datos más comunes prefijados por el XML Schema son string, decimal, integer, bolean,
date y time.
A continuación tenemos un ejemplo de elemento XML con un atributo:
<apellidos idioma="EN">Smith</apellidos>
Y la correspondiente definición del atributo:
<xs:attribute name="idioma" type="xs:string"/>
Restricciones.
Las restricciones se utilizan para definir valores aceptables para los elementos XML y los
atributos. Las restricciones sobre los elementos XML se denominan facets.
La siguiente tabla enumera los tipos de restricciones que se pueden definir:
Restricción Descripción
enumeration Define una lista de valores aceptables
fractionDigits Especifica el número máximo de dígitos decimales permitidos
length Especifica el número exacto de caracteres o items de una lista
permitidos
maxExclusive Especifica el límite superior un valor numérico
maxInclusive Especifica el límite superior de un valor numérico (valor de límite
incluido)
maxLength Especifica el número máximo de caracteres o items de una lista
permitidos
minExclusive Especifica el límite inferior un valor numérico
minInclusive Especifica el límite inferior de un valor numérico (valor de límite
incluido)
minLength Especifica el número mínimo de caracteres o items de una lista
permitidos
pattern Define un patrón para una cadena de caracteres
totalDigits Especifica el número exacto de digitos permitidos
whiteSpace Indica como tratar los espacios en blanco
En el siguiente ejemplo se define el elemento edad con una restricción de tipo numérico dentro del
rango [0,120]:
<xs:element name="edad">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
6 de febrero de 2008 Tema 8 14
15. <xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Tipos de datos.
Los tipos de datos que se pueden utilizar para definir los contenidos y se agrupan en cuatro clases:
1. String: este tipo de dato se compone de caracteres, tabuladores y retornos de carro.
2. Date y Time: especifican un tipo de fecha (<xs:date>), hora (<xs:time>) o fecha y hora
(<xs:datetime>).
3. Numeric: especifican un tipo numérico (decimal, integer, long, etc).
4. Misc: otro tipo de datos, entre estos nos encontramos bolean, flota, double, anyURI,
base64Binary, etc
6 de febrero de 2008 Tema 8 15
16. 3 Estándar XSL: XPath, XSLT y XSL-FO
3.1 Introducción XSL
XSL son las siglas de Extensible Stylesheet Language. La W3C empezó a desarrollar este
lenguaje por la necesidad de definir una página de estilos para los documentos XML.
Cuando decimos página de estilos el alumno debería recordar el tema 2 donde estudió CSS que es la
forma de definir los estilos para los documentos HTML. XSL se puede considerar algo parecido
aunque el alumno tiene que tener en cuenta que es más complejo, pues en HTML las etiquetas son
fijas y predefinidas y se puede definir de una forma sencilla la forma de ‘dibujarlas’ y en cambio en
XML las etiquetas no son estándares sino que cada documento define las suyas propias y eso
implica mayor complejidad para poder definir la forma de representarlas.
En XSL se distinguen tres partes:
XPath: un lenguaje para navegar por los nodos de los documentos XML.
XSLT: un lenguaje para transformar los documentos XML.
XSL-FO: un lenguaje para formatear los documentos XML.
En los siguientes apartados de esta lección estudiamos más a fondo dichos lenguajes.
3.2 XPath (I)
XPath es el lenguaje para buscar información dentro de un documento XML. XPath se utiliza
para navegar a través de los elementos y los atributos. Además, proporciona una librería de
funciones estándares para tratar dicha información.
En XPath se distinguen siete tipos de nodos: elementos, atributos, texto, namespace, instrucciones,
comentarios y nodo raíz (document). Los documentos XML se consideran como un árbol de nodos.
El nodo raíz del árbol se denomina document.
Los nodos se encuentran relacionados y las relaciones tienen la siguiente denominación:
Padre: cada elemento y atributo tiene un solo padre.
Hijo: los nodos pueden tener cero, uno o más hijos.
Siblings (hermanos): nodos que tiene el mismo padre.
Antecesor: el padre de un nodo, el abuelo, etc.
Descendiente: el hijo de un nodo, el nieto, etc.
Sintaxis.
Xpath utiliza expresiones en forma de ruta (path expressions) para seleccionar nodos o conjuntos
de nodos de un documento XML. Estas rutas son muy parecidas a las rutas utilizadas en los
sistemas de ficheros. La siguiente tabla muestra las expresiones más utilizadas:
Expresión Descripción
nombreNodo Selecciona todos los nodos hijo del nodo indicado
/ Selecciona desde el nodo raíz
// Selecciona nodos del documento desde el nodo actual sin importar
donde se encuentran
. Selecciona el nodo actual
6 de febrero de 2008 Tema 8 16
17. .. Selecciona el padre del nodo actual
@ Selecciona atributos
En XPath podemos buscar un nodo específico o un nodo que contenga un valor específico, este tipo
de expresiones se denomina predicado. Los predicados se escriben entre corchetes
(/libreria/libro[0]). También podemos usar caracteres comodín (wildcards) para seleccionar
elementos XML desconocidos.
Wildcard Descripción
* Identifica cualquier nodo de tipo elemento
@* Identifica cualquier nodo de tipo atributo
node() Identifica cualquier nodo de cualquier tipo
Además, en las expresiones tenemos operadores de diversos tipos que podemos utilizar
(aritméticos, lógicos y de igualdad). Por ejemplo, con el operador | podemos seleccionar varias rutas
a la vez.
Veamos distintos ejemplos de selección con XPath, para ello utilizamos el siguiente documento
XML:
<?xml version="1.0" encoding="ISO-8859-1"?>
<libreria>
<libro>
<titulo idioma="es">Don Quijote de la Mancha</titulo>
<precio>39.95</precio>
</libro>
<libro>
<titulo idioma="eng">Harry Potter</titulo>
<precio>29.99</precio>
</libro>
</libreria>
A continuación vemos los ejemplos de selección con Xpath:
Expresión Resultado
libreria Selecciona todos los nodos hijo del elemento libreria
/libreria Selecciona el elemento raiz libreria.
Nota: Si la ruta empieza con barra / se indica siempre una ruta absoluta a un
elemento
libreria/libro Selecciona todos los elementos libro que son hijo de libreria
//libro Selecciona todos los elementos libro sin importar donde se encuentren dentro
del documento XML
libreria//libro Selecciona todos los elementos libro que sean descendientes del elemento
libreria sin importar donde se encuentre bajo el elemento libreria
//@idioma Selecciona todos los atributos con nombre idioma
/libreria/libro[0] Selecciona el primer elemento libro que es hijo del elemento libreria
6 de febrero de 2008 Tema 8 17
18. /libreria/libro[last( Selecciona el último elemento libro que es hijo del elemento libreria
)]
//titulo[@idioma=' Selecciona todos los elementos titulo que tienen un atributo idioma con valor
es'] ‘es’
/libreria/libro[prec Selecciona todos los elementos libro del elemento libreria que tengan un
io>35.00] elemento precio con un valor mayor de 35.00
/libreria/* Selecciona todos los nodos hijo del elemento libreria
//* Selecciona todos los elementos del documento XML
//titulo[@*] Selecciona todos los elementos titulo que tengan algún atributo
//libro/titulo | Selecciona los elementos titulo Y los elementos precio de todos los elementos
//libro/precio libro
3.3 XPath (II)
Ejes (Axes).
Un eje identifica un conjunto de nodos relativo al nodo actual.
Nombre del Eje Resultado obtenido
Ancestor Selecciona todos los antecesores (padre, abuelo, etc) del nodo actual
Ancestor-or-self Selecciona todos los antecesores del nodo actual y el nodo actual incluido
Attribute Selecciona todos los atributos del nodo actual
Child Selecciona todos los hijos del nodo actual
Descendant Selecciona todos los descendientes (hijos, nietos, etc) del nodo actual
descendant-or-self Selecciona todos los descendientes (hijos, nietos, etc) del nodo actual y el nodo
actual incluido
Following Selecciona todo lo que queda de documento desde la etiqueta de cierre del
nodo actual
following-sibling Selecciona todos los hermanos (siblings) despues del nodo actual
Namespace Selecciona todos los nodos namespace del nodo actual
Parent Selecciona el padre del nodo actual
Preceding Selecciona todo lo que exista en el documento precediendo a la etiqueta de
6 de febrero de 2008 Tema 8 18
19. inicio del nodo actual
preceding-sibling Selecciona todos los hermanos (siblings) anteriores al nodo actual
Self Selecciona el nodo actual
Los ejes son la base de un paso. Un paso consiste en:
un eje (define la relación entre los nodos seleccionados y el nodo actual),
un nodo de chequeo (identifica un nodo dentro de un eje),
cero o más predicados (para realizar un refinamiento del conjunto de nodos seleccionados).
La sintaxis para un paso es: eje::nodo_chequeo[predicado]
Una ruta de localización se compone de uno o más pasos separados por barras (/). Puede ser
absoluta o relativa:
Absoluta: /paso1/paso2/….
Relativa: paso1/paso2/…
Veamos ejemplos de ejes, pasos y rutas de localización:
Ejemplo Resultado obtenido
child::libro Selecciona todos los nodos libro que son hijo del nodo actual
attribute::idioma Selecciona el atributo idioma del nodo actual
child::* Selecciona todos los hijos del nodo actual
attribute::* Selecciona todos los atributos del nodo actual
child::text() Selecciona todos los nodos hijo texto del nodo actual
child::node() Selecciona todos los hijos nodo del nodo actual
child::*/child::prec Selecciona todos los nodos nieto ‘precio’ del nodo actual
io
Funciones.
Xpath incluye más de 100 funciones predefinidas. Con estas funciones podemos realizar
tratamiento de cadenas y números, comparaciones de fechas, manipulación de nodos, secuencias,
boléanos, etc.
La dirección URL donde se pueden consultar todas las funciones disponibles es
http://www.w3.org/2005/02/xpath-functions.
6 de febrero de 2008 Tema 8 19
20. 3.4 XSLT
XSLT se utiliza para transformar un documento XML en otro documento XML u otro tipo de
documento que se pueda reconocer por un navegador como HTML o XHTML. Con XSLT se
pueden añadir y borrar elementos y atributos del documento XML de origen al de destino, incluso
se pueden reordenar los elementos y añadir instrucciones de control que permitan ocultar o mostrar
los elementos.
Se suele decir que el proceso de transformación con XSLT convierte un árbol de origen XML a un
árbol resultado XML.
En el proceso de transformación, XSLT va a utilizar XPath para definir partes del documento origen
que deben coincidir con uno o más plantillas (templates) predefinidas. Cuando se encuentra una
coincidencipixelsa, XSLT transformará la parte que coincida del documento origen en el documento
resultado.
Veamos en detalle los elementos que componen un fichero XSLT.
Etiqueta Descripción Sintaxis
TEMPLATE Este elemento se utiliza para construir plantillas. <xsl:template
El atributo match se utiliza para asociar una match=”ruta_Xpath”>
plantilla con un elemento XML, el valor que
toma este atributo es una ruta XPath.
VALUE-OF Este elemento se utiliza para extraer el valor de <xsl:value-of
un elemento XML y añadirlo a fichero resultado. select="elementoXML"/>
FOR-EACH Este elemento se utiliza para seleccionar todos <xsl:for-each
los elementos XML de un conjunto de nodos. Se select="elementoXML">
pueden seleccionar todos, o bien, se puede filtrar
la salida añadiendo un criterio de selección al
atributo select del elemento.
SORT Se utiliza para ordenar la salida. Para ordenar, <xsl:sort>
únicamente se debe añadir un elemento sort
dentro de un elemento for-each en el fichero
XSL.
IF Se utiliza para añadir una sentencia condicional <xsl:if>
contra el contenido del documento XML.
CHOOSE Esta etiqueta se utiliza conjuntamente con <xsl:choose>
WHEN y OTHERWISE para añadir una
sentencia condicional múltiple.
APPLY- Esta etiqueta aplica una plantilla (template) al <xsl:apply-templates>
TEMPLATES elemento actual o a los nodos hijo del elemento
actual. Si añadimos el atributo select a esta
etiqueta se procesarán únicamente los elementos
hijos que coincidan con el valor de dicho
atributo. También se puede usar el atributo select
para especificar el orden en que serán procesados
los nodos hijo.
6 de febrero de 2008 Tema 8 20
21. 3.5 XSL-FO
XSL-FO es un lenguaje de marcas que permite describir la forma de formatear un documento XML
para generar la salida en pantalla, papel u otro medio de salida.
Los documentos XSL-FO se guardan en documentos con la extensión .fo o .fob. También es posible
encontrar estos documentos con la extensión .xml para poder hacer más accesible la edición de
dichos documentos con los editores XML. Tienen la siguiente estructura genérica:
<?xml version="1.0" encoding="ISO-8859-1"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="MiPagina">
<!— La plantilla de la página está aquí -->
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="MiPagina">
<!— El contenido de la página viene aquí -->
</fo:page-sequence>
</fo:root>
Veamos el significado de las etiquetas que componen esta estructura:
<fo:root> es el elemento raíz de todos los documentos XSL-FO, declara el namespace.
<fo:layout-master-set> dentro de esta etiqueta se declaran una o más plantillas con el
formato de las páginas.
<fo:simple-page-master> este elemento contiene la plantilla de una página. Cada plantilla
tiene que tener un nombre único.
<fo-page-sequence> describe el contenido de la página. El atributo master-reference hace
referencia al nombre de la plantilla (<simple-page-master>) con dicho nombre.
XSL-FO realiza una división en cajas rectangulares (áreas) de los documentos. Toda la salida que se
pueda generar (texto, imágenes, etc) debe ser formateada dentro de éstas áreas. Se distinguen los
siguientes tipos de áreas:
Páginas: todo el contenido se incluye dentro de una o más páginas. Las páginas pueden
referenciar a plantillas que definan su layout. Entre la información a definir de una página
nos encontramos con el tamaño, los márgenes y las regiones.
Regiones: las páginas contienen regiones (region-body, region-before, region-after, region-
start, region-end). A continuación, podemos ver una imagen que nos aclararán donde se
encuentra cada región.
Bloques: las regiones se componen de bloques. Cada bloque es un pequeño elemento como
párrafos, tablas o listas. Los bloques pueden contener otros bloques aunque normalmente
contienen líneas.
Líneas: son las áreas de texto que se incluyen dentro de los bloques.
6 de febrero de 2008 Tema 8 21
22. Veamos el clásico ejemplo de Hola Mundo realizado con XSL-FO.
<?xml version="1.0" encoding="ISO-8859-1"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="A4">
<fo:region-body />
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="A4">
<fo:flow flow-name="xsl-region-body">
<fo:block>Hola Mundo</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
La etiqueta <fo:flow> contiene todos los elementos que van a ser impresos en la página. El atributo
flow-name define en que región de la página se va a escribir el contenido.
6 de febrero de 2008 Tema 8 22
23. XSL-FO necesita software específico que formatee y genere la salida, estos programas se
denominan procesadores XSL-FO. La mayoría de estos programas generan la salida como
documentos PDF. Entre los más conocidos se encuentran los siguientes:
XSL Formatter de Antena House (http://www.antennahouse.com).
Xinc Beta Release de Lunasil LTD (http://www.lunasil.com).
Scriptura de Inventive Designers (http://www.scriptura-xsl.com).
Apache FOP (http://xmlgraphics.apache.org/fop/).
6 de febrero de 2008 Tema 8 23
24. 4 DOM y paquetes Java/XML
4.1 DOM
El XML Document Object Model (XML DOM) define el modo estándar para acceder y manipular
los documentos XML.
Definición de DOM por la W3C: “El Document Object Model (DOM) es una interface
independiente del lenguaje o la plataforma que permite a los programas el acceso y actualización
de forma dinámica del contenido, estructura y estilo de un documento”.
El DOM presenta un documento XML como una estructura en forma de árbol (árbol de nodos)
compuesto de elementos, atributos y textos. El contenido de dicho documento puede ser consultado,
modificado, borrado o se pueden crear nuevos nodos. El DOM define:
El documento completo es el nodo documento.
Cada etiqueta XML es un nodo elemento.
El texto que contiene cada elemento XML son nodos de texto.
Cada atributo XML es un nodo atributo.
Los comentarios son nodos comentario.
Los textos se almacenan también en nodos. Un error normal programando con
DOM es navegar hasta un nodo elemento y esperar que contenga el texto. Por
ejemplo, en <dia>21</dia> hay un nodo elemento (dia) y un nodo de tipo texto bajo
él (21).
Todos los nodos en el árbol DOM están interrelacionados. Los nodos del árbol siguen las siguientes
reglas y la siguiente denominación:
Dentro del árbol de nodos, el nodo más alto es el nodo raíz.
Cada nodo, excepto el raíz, tiene un único nodo padre.
Un nodo puede tener cero, uno o más nodos hijo.
Un nodo hoja es un nodo sin hijos.
Los nodos hermano (sibling) son nodos con el mismo padre.
En la siguiente imagen podemos ver un documento XML como árbol DOM y la relación entre los
diferentes nodos:
6 de febrero de 2008 Tema 8 24
25. A continuación, vamos a ver dos formas para navegar y acceder a los nodos de un documento XML
con DOM. Para consultar que métodos existen para modificar, borrar o crear nodos podéis hacerlo
en la siguiente dirección http://www.w3schools.com/dom/default.asp.
La primera forma de acceder a los elementos es mediante el método
getElementsByTagName(“nombreNodo”). Este método devuelve todos los elementos (como una
estructura nodeList) con el nombre especificado como parámetro que son descendientes del
elemento sobre el que nos encontremos (independientemente del nivel al que se encuentren).
La segunda manera de navegar entre los nodos es utilizando las relaciones que existen entre ellos.
Para ello utilizamos las siguientes propiedades de los nodos de tipo elemento:
parentNode, childNodes, firstChild, lastChild, nextSibling y previousSibling. En la siguiente
imagen podemos ver como se relacionan los nodos con las propiedades anteriores.
6 de febrero de 2008 Tema 8 25
26. Además, existe una propiedad especial (document.documentElement) que devuelve el nodo raíz del
documento XML.
4.2 Java API para XML (JAXP)
El API que proporciona Java para procesar XML (JAXP) incluye las facilidades básicas para
trabajar con XML. JAXP contiene los analizadores SAX (Simple API for XML Parsing) y DOM
(Document Object Model) para que podamos elegir entre analizar nuestro documento XML como
streams de eventos o construir una representación de objetos (el árbol de nodos DOM visto en el
apartado anterior). JAXP también soporta el estándar XSLT (XML Stylesheet Language
Transformations), dándonos control sobre la representación de los datos y permitiéndonos
convertir los datos a otros documentos XML o a otros formatos, como a HTML.
API SAX.
SAX define un API para un analizador basado en eventos. Estar "basado en eventos" significa que
el analizador lee un documento XML desde el principio hasta el final, y cada vez que reconoce una
sintaxis de construcción, se lo notifica con un evento a la aplicación que lo está ejecutando.
El analizador SAX notifica a la aplicación llamando a los métodos del interface ContentHandler.
Por ejemplo, cuando el analizador encuentra un símbolo ("<"), llama al método startElement;
cuando encuentra caracteres de datos, llama al método characters; y cuando encuentra un símbolo
("</"), llama al método endElement, etc.
El programador debe sobreescribir estos métodos para poder procesar los datos de las etiquetas de
la forma que su aplicación necesite, por ejemplo, guardando estos datos en la base de datos.
API DOM.
El API "Document Object Model" (DOM), definido por la W3C y visto en el apartado anterior, es
un conjunto de interfaces para construir una representación de objeto, en forma de árbol, del
documento XML analizado.
Una vez que hemos construido el DOM, podemos manipularlo con métodos DOM como insert y
remove, igual que manipularíamos cualquier otra estructura de datos en forma de árbol. Así, al
contrario que un analizador SAX, un analizador DOM permite acceso aleatorio al documento XML.
Otra diferencia es que con un analizador SAX, sólo podemos leer un documento XML, mientras
que con un analizador DOM, podemos construir una representación en forma de objeto del
documento XML y manipularlo en memoria, añadiendo, modificando o eliminando elementos.
API XSLT.
XSLT (XSL Transformations), definido por el grupo de trabajo XSL de la W3C, describe un
lenguaje para transformar documentos XML en otros documentos XML o en otros formatos. Para
realizar la transformación, normalmente necesitamos suministrar una hoja de estilo, que está escrita
en "XML Stylesheet Language" (XSL). La hoja de estilo XSL específica como se mostrarán los
datos XML. XSLT usa las instrucciones de formateo de la hoja de estilo para realizar la
6 de febrero de 2008 Tema 8 26
27. transformación. El documento convertido puede ser otro documento XML o un documento en otro
formato, como HTML.
JAXP soporta XSLT con el paquete javax.xml.transform, que nos permite enchufar un transformer
XSLT para realizar las transformaciones. Los subpaquetes tienen APIs de streams espeficicos, de
SAX-, y de DOM-, que nos permiten realizar transformaciones directamente desde árboles DOM y
eventos SAX.
Para poder profundizar en estos APIs podeís leer los árticulos y tutoriales de los siguientes links:
- SAX:
http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_1/?menuId=ARTICLES&
onlypath=true y
http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_2__final/?menuId=ARTIC
LES&onlypath=true.
- DOM:
http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom/?menuId=ARTICLES
&onlypath=true y
http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom_parte_2/?menuId=AR
TICLES&onlypath=true.
- XSLT: http://www.programacion.com/java/tutorial/apis_xml/2/#xslt1. Servicios Web con J2EE
6 de febrero de 2008 Tema 8 27
28. 5 Servicios web con J2EE
5.1 Introducción a los servicios Web
Un Web Service (WS) o Servicio Web es una aplicación que puede ser descripta, publicada,
localizada, e invocada a través de una red, generalmente Internet. Los WS desde el punto de
vista del cliente son componentes que se encuentran dentro de una caja negra, que pueden ser
utilizados sin preocuparse de como fueron implementados, y ser accedidos utilizando XML
(SOAP), generalmente sobre HTTP.
La arquitectura básica del modelo de WS describe un consumidor, un proveedor y ocasionalmente
un corredor (broker) y relacionados con estos agentes están las operaciones de publish (publicar),
find (encontrar) y bind (enlazar).
Las tecnologías necesarias para desarrollar o consumir un WS son:
XML ( eXtensible Markup Language): una forma estándar de representar los datos.
SOAP (Simple Object Access Protocol): un formato común y extensible de mensaje.
WSDL (Web Services Definition Language): un lenguaje común y extensible para
describir los servicios, basado en XML.
UDDI (Universal Description Discovery and Integration): una forma de descubrir los
servicios en Internet, basado en XML.
A continuación voy a copiar la definición que realizada en una presentación de los servicios web
por lo claridad con que explica dicho concepto:
"Un Web Service es un componente de software que se comunica con otras aplicaciones
codificando los mensaje en XML y enviando estos mensaje a través de protocolos estándares de
Internet tales como el Hypertext Transfer Protocol (HTTP). Intuitivamente un Web Service es
similar a un sitio web que no cuenta con un interfaz de usuario y que da servicio a las aplicaciones
en vez de a las personas. Un Web Service, en vez de obtener solicitudes desde el navegador y
retornar páginas web como respuesta, lo que hace es recibir solicitudes a través de un mensaje
formateado en XML desde una aplicación, realiza una tarea y devuelve un mensaje de respuesta
también formateado en XML.
Microsoft y otras empresas líderes están promocionando SOAP como estándar de los mensajes
para los Web Services. Un mensaje SOAP se parece mucho a una carta : es un sobre que contiene
6 de febrero de 2008 Tema 8 28
29. una cabecera con la dirección del receptor del mensaje , un conjunto de opciones de entrega (tal
como la información de encriptación), y un cuerpo o body con la información o data del mensaje.
Microsoft y otros proveedores líderes promocionan los Web Services como un modelo de
programación para la comunicación entre aplicaciones. Estas compañías piensan que la conexión
de aplicaciones a través de la Internet mejorará la capacidad de las empresas para trabajar
conjuntamente con sus socios de negocio, proveedores y clientes. Creando una capa de Web
Services sobre una aplicación corporativa existente, las organizaciones podrán permitir que
sistemas externos puedan invocar las funciones de la aplicación a través de Internet (o una intranet
corporativa) sin tener que modificar la aplicación misma. Por ejemplo, varias compañías están hoy
en día creando Web Services que actúan como front end para aplicaciones de entrada de órdenes
que están residentes internamente en un mainframe. Estas compañías permiten a los sistemas de
compras de sus clientes enviar órdenes de compra a través de la Internet. Poner una capa de web
services sobre las aplicaciones existentes es una solución muy interesante para integrar las
aplicaciones desarrolladas por los diferentes departamentos y así reducir los costos de
integración."
5.2 SOAP
Definición de wikipedia de SOAP: “SOAP (siglas de Simple Object Access Protocol) es un
protocolo estándar creado por Microsoft, IBM, JoEve y otros, está actualmente bajo el auspicio de
la W3C, que define cómo dos objetos en diferentes procesos pueden comunicarse por medio de
intercambio de datos XML. SOAP es uno de los protocolos utilizados en los servicios Web”.
¿Qué es SOAP?
Un protocolo para el intercambio de información en un entorno descentralizado y
distribuido.
Utilizado, generalmente, sobre el protocolo HTPP.
Un estándar para el envío de datos XML.
Básicamente, define un estándar de cómo representar la invocación de métodos utilizando
un sistema de petición y respuesta como es HTTP.
Los mensajes en SOAP siguen la siguiente estructura:
Como ejemplo, veamos la forma en que un cliente solicitaría información de un producto
(getProductDetails) a un proveedor de servicios Web utilizando SOAP:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
6 de febrero de 2008 Tema 8 29
30. <soap:Body>
<getProductDetails xmlns="http://warehouse.example.com/ws">
<productId>827635</productId>
</getProductDetails>
</soap:Body>
</soap:Envelope>
Para obtener una información más detallada podéis consultar la documentación de la W3C
(http://www.w3.org/TR/soap12-part0/).
5.3 WSDL
El WSDL (Lenguaje de Descripción de Servicios Web) nos permite describir en formato XML
un servicio Web. Un documento WSDL proporciona la información necesaria al cliente para
interaccionar con el servicio Web. WSDL es extensible y se pude utilizar para describir,
prácticamente, cualquier servicio de red, incluyendo SOAP sobre HTTP e incluso protocolos que no
se basan en XML como DCOM sobre UDP.
Un documento WSDL utiliza los siguientes elementos en la definición los servicios:
<definitions name="serviceName">
<types> … </ types>
<message name="myMsg"> … </ message>
<portType name="myPort">
<operation name="myOperation"> … </operation>
</portType>
<binding name="myBinding" type="myPort"> … </ binding>
<service name="mySvc">
<port name="myPort"> ... </port>
</ service>
</definitions>
donde nos encontramos las siguientes partes:
types: contenedor de definiciones del tipo de datos que utiliza algún sistema de tipos (por
ejemplo XSD).
message: definición abstracta y escrita de los datos que se están comunicando.
portType: conjunto abstracto de operaciones admitidas por uno o más puntos finales.
operation: descripción abstracta de una acción admitida por el servicio.
binding: especificación del protocolo y del formato de datos para un tipo de puerto
determinado.
service: colección de puntos finales relacionados.
port: punto final único que se define como la combinación de un enlace y una dirección de
red.
Para obtener una información más detallada podéis consultar la documentación de la W3C
(http://www.w3.org/TR/wsdl).
5.4 UDDI
UDDI (Universal Description, Discovery and Integration) es uno de los estándares básicos de los
servicios Web cuyo objetivo es ser accedido por los mensajes SOAP y dar paso a documentos
6 de febrero de 2008 Tema 8 30
31. WSDL, en los que se describen los requisitos del protocolo y los formatos del mensaje solicitado
para interactuar con los servicios Web del catálogo de registros. UDDI es una iniciativa industrial
abierta, sufragada por la OASIS.
Definido con otras palabras, UDDI es un registro público diseñado para almacenar de forma
estructurada información sobre empresas y los servicios que éstas ofrecen. A través de UDDI,
se puede publicar y descubrir información de una empresa y de sus servicios. Se puede utilizar
sistemas taxonómicos estándar para clasificar estos datos y poder encontrarlos posteriormente en
función de la categorización. Lo más importante es que UDDI contiene información sobre las
interfaces técnicas de los servicios de una empresa. A través de un conjunto de llamadas a API XML
basadas en SOAP, se puede interactuar con UDDI tanto en tiempo de diseño como de ejecución
para descubrir datos técnicos de los servicios que permitan invocarlos y utilizarlos.
Para obtener una información más detallada podéis consultar la documentación de OASIS
(http://www.uddi.org/specification.html).
5.5 Web Services y Java / J2EE
Los siguientes APIs son los estándares que existen en Java para el tratamiento con XML, SOAP,
UDDI:
JAXP: Java API para el procesamiento XML
JAXM: Java API para mensajería XML (SOAP).
JAX-RPC: Java API para XML RPC.
JAXR: Java API para registros XML (acceso a UDDI).
JAXB: Java API para XML Data Binding.
Dentro del entorno J2EE, los Servicios Web se pueden considerar como otra posible interfaz de
acceso a los servicios ofrecidos por una aplicación. La mayoría de las herramientas existentes para
generar los WS en Java se basan en los Servlets.
A continuación vamos a enumerar varios entornos para la implementación de Servicios Web en
Java:
Sun’s Web Services Developer Pack
(http://java.sun.com/webservices/downloads/previous/webservicespack.jsp).
6 de febrero de 2008 Tema 8 31
32. Apache SOAP.
Apache Axis (http://ws.apache.org/axis/).
Mind Electric’s Glue (http://www.themindelectric.com/glue/index.html).
Systinet Server for Java (http://www.systinet.com/products/ssj/overview).
Servidores de Aplicaciones J2EE (Jboss, Weblogic).
Java IDEs (Eclipse, Netbeans, IDEA)
6 de febrero de 2008 Tema 8 32