ii curso online java-j2ee - bilib · mediante un fichero dtd (document type definition) o xsd (xml...

II Curso Online JAVA-J2EE

TEMA 8Desarrollo de aplicaciones con XML

Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La ManchaVersión: 1.0Fecha: Revisado 07-02-2008 11:46Licencia: CC-by-sa 2.5

0 LicenciaUsted 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

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


1 Características del XML

1.1 Introducción a XMLXML (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 XMLLas 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.


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.



1.3 Componentes XMLLos 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.


http://ceslcam.iformacion.es/mod/lesson/view.php?id=43

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> <titulo>Mi primer XML</titulo> <prod id="1" media="pdf"></prod> <capitulo>Introducción a XML <parrafo>Que es HTML</parrafo> <parrafo>Que es XML</parrafo> </capitulo> <capitulo>Sintaxis XML <parrafo>Los elementos deben tener etiqueta de cierre</parrafo> <parrafo>Los elementos deben estar correctamente anidados</parrafo> </parrafo></libro>

Libro es el elemento raiz.Titulo, prod y capitulo son elementos hijo de libro.Libro es el elemento padre de titulo, prod y capitulo.Titulo, prod y capitulo son siblings o elementos hermano porque tienen el mismo padre.

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



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"><persona sexo='hombre'>

<cliente nombre='Paco "el gato" '><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"> <nombre>Juan</nombre> <apellidos>Atienza García</apellidos></persona>

<persona> <sexo>female</sexo> <nombre>Juan</nombre> <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.


2 Validación: DTD y XSD

2.1 Validación XMLUn 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 DTDComo 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?><!DOCTYPE correo SYSTEM "ejemploDTD.dtd"><correo>

<!ELEMENT correo (para,de,resumen,cuerpo)><!ELEMENT para (#PCDATA)><!ELEMENT de (#PCDATA)><!ELEMENT resumen (#PCDATA)>


<para>Jesus</para> <de>Juan</de> <resumen>Recuerda</resumen> <cuerpo>El curso de Java empieza el 22 de septiembre</cuerpo></correo>

<!ELEMENT cuerpo (#PCDATA)>

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 tener contenido.

<!ELEMENT br EMPTY>

<br />

(#PCDATA) Texto parseable. <!ELEMENT de (#PCDATA)>

<de>Juan</de>

(hijo1, hijo2,...) Elementos con uno o más hijos.

<!ELEMENT note (to,from,heading,body)>

Véase ejemploXML.xml

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.


#IMPLIED El atributo no es obligatorio.

#FIXED valor El valor del atributo es fijo.

Veamos unos cuantos ejemplos de difinición de atributos:

DTD: <!ATTLIST person number CDATA #REQUIRED>XML Válido: <person number="5677" />XML Inválido:<person />

DTD: <!ATTLIST contact fax CDATA #IMPLIED>XML Válido: <contact fax="555-667788" />XML Inválido: <contact />

DTD: <!ATTLIST payment type (check|cash) "cash">Ejemplo XML: <payment type="check" /> o <payment type="cash" />

Entidades.

Son variables utilizadas para definir 'atajos' (shorcuts) a textos genéricos o caracteres especiales. Pueden ser internas o externas y su sintaxis es diferente:

Interna: <!ENTITY entity-name "entity-value"> Externa: <!ENTITY entity-name SYSTEM "URI/URL">

Para referenciar a la entidad en el documento XML se tiene que escribir '&<nombre_entidad>;'.

Un ejemplo de entidad interna:

Ejemplo DTD:<!ENTITY autor "Juan Atienza."><!ENTITY copyright "iformacion.com">Ejemplo XML:<author>&autor;&copyright;</author>

Un ejemplo de entidad externa:

Ejemplo DTD:<!ENTITY autor SYSTEM "http://www.iformacion.com/entidades.dtd"><!ENTITY copyright SYSTEM "http://www.iformacion.com/entidades.dtd">Ejemplo XML:<author>&autor;&copyright;</author>

2.3 XSDAl igual que un DTD, un XSD (XML Schema Definition) sirve para definir la estructura de un documento XML. Estos se pueden considerar los sucesores de los DTDs pues son más potentes en cuanto a la capacidad que presentan para describir XML. Entre las mejoras que presentan podemos destacar:

Soportan tipos de datos permitiendo describir el contenido del documento XML, validar la corrección de los datos, definir patrones del formato de datos e incluso conversiones entre diferentes tipos de datos.

Los esquemas XSD se escriben en formato XML.


http://www.iformacion.com/entidades.dtd

http://www.iformacion.com/entidades.dtd

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?><correo xmlns="http://www.iformacion.com"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.iformacion.com ejemploXSD.xsd"><para>Jesus</para><de>Juan</de><resumen>Recuerda</resumen><cuerpo>El curso de Java empieza el 22 de septiembre</cuerpo></correo>

<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.iformacion.com"xmlns="http://www.iformacion.com"elementFormDefault="qualified"><xs:element name="correo"> <xs:complexType> <xs:sequence> <xs:element name="para" type="xs:string"/> <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


http://www.iformacion.com/


http://www.w3.org/2001/XMLSchema

http://www.w3.org/2001/XMLSchema



http://www.w3.org/2001/XMLSchema-instance

http://www.w3.org/2001/XMLSchema-instance


definición XSD y en la derecha un ejemplo XML:

<xs:element name="nombre" type="xs:string"/><xs:element name="edad" type="xs:integer"/><xs:element name="fecha_nacimiento" type="xs:date"/>

<nombre>Juan Atienza</nombre><edad>31</edad><fecha_nacimiento>1975-01-01</fecha_nacimiento>

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>


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.


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"/>


<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


3 Estándar XSL: XPath, XSLT y XSL-FO

3.1 Introducción XSLXSL 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



.. 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


/libreria/libro[last()]

Selecciona el último elemento libro que es hijo del elemento libreria

//titulo[@idioma='es']

Selecciona todos los elementos titulo que tienen un atributo idioma con valor ‘es’

/libreria/libro[precio>35.00]

Selecciona todos los elementos libro del elemento libreria que tengan un 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 | //libro/precio

Selecciona los elementos titulo Y los elementos precio de todos los elementos 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


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::precio

Selecciona todos los nodos nieto ‘precio’ del nodo actual

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.


http://www.w3.org/2005/02/xpath-functions

3.4 XSLTXSLT 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. El atributo match se utiliza para asociar una plantilla con un elemento XML, el valor que toma este atributo es una ruta XPath.

<xsl:template match=”ruta_Xpath”>

VALUE-OF Este elemento se utiliza para extraer el valor de un elemento XML y añadirlo a fichero resultado.

<xsl:value-of select="elementoXML"/>

FOR-EACH Este elemento se utiliza para seleccionar todos los elementos XML de un conjunto de nodos. Se pueden seleccionar todos, o bien, se puede filtrar la salida añadiendo un criterio de selección al atributo select del elemento.

<xsl:for-each select="elementoXML">

SORT Se utiliza para ordenar la salida. Para ordenar, únicamente se debe añadir un elemento sort dentro de un elemento for-each en el fichero XSL.

<xsl:sort>

IF Se utiliza para añadir una sentencia condicional contra el contenido del documento XML.

<xsl:if>

CHOOSE Esta etiqueta se utiliza conjuntamente con WHEN y OTHERWISE para añadir una sentencia condicional múltiple.

<xsl:choose>

APPLY-TEMPLATES

Esta etiqueta aplica una plantilla (template) al 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.

<xsl:apply-templates>


3.5 XSL-FOXSL-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.


http://www.w3.org/1999/XSL/Format

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.


http://www.w3.org/1999/XSL/Format

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/).


http://xmlgraphics.apache.org/fop/

http://www.scriptura-xsl.com/

4 DOM y paquetes Java/XML

4.1 DOMEl 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:


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.


http://www.w3schools.com/dom/default.asp

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



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=ARTICLES&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=ARTICLES&onlypath=true.

- XSLT: http://www.programacion.com/java/tutorial/apis_xml/2/#xslt1. Servicios Web con J2EE


http://www.programacion.com/java/tutorial/apis_xml/2/#xslt

http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom_parte_2/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom_parte_2/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/xml_desde_java_hecho_fcil_jdom/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_2__final/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_2__final/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_1/?menuId=ARTICLES&onlypath=true

http://www.javahispano.org/contenidos/es/mapeo_de_xml_a_java_parte_1/?menuId=ARTICLES&onlypath=true

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


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 SOAPDefinició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/">


http://schemas.xmlsoap.org/soap/envelope/

<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 WSDLEl 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 UDDIUDDI (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


http://www.w3.org/TR/wsdl

http://www.w3.org/TR/soap12-part0/

http://warehouse.example.com/ws

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 / J2EELos 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).


http://java.sun.com/webservices/downloads/previous/webservicespack.jsp

http://www.uddi.org/specification.html

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)



http://www.systinet.com/products/ssj/overview

http://www.themindelectric.com/glue/index.html

http://ws.apache.org/axis/

ii curso online java-j2ee - bilib · mediante un fichero dtd (document type definition) o xsd (xml...

Documents