13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Web Services Description Language (WSDL)

Compartir servicios web

Nicholas Chase
Publicado en 08-08-2011

Contenido de la serie:

Este contenido es la parte 2 de 2 de la

serie: Comprender los servicios web

Antes de comenzar
Este tutorial está diseñado para que usted pueda comprender Web Services Description
Language (Lenguaje de descripción de servicios web - WSDL). Está pensando para
desarrolladores que desean exponer sus propios servicios al uso de otros utilizando WSDL y
también para desarrolladores que tengan el archivo WSDL para un servicio al que desean
acceder y necesitan crear un cliente.

Para poder interpretar este tutorial usted debería tener conocimientos básicos de SOAP, los
que puede obtener leyendo la Parte 1 de esta serie de tutoriales; y además conocimientos
básicos de XML. WSDL es un lenguaje de programación agnóstico, pero las muestras que
aparecen al final del tutorial usan Java y el proyecto Apache Axis2. Sin embargo, los conceptos
se aplican a cualquier lenguaje de programación y entorno. Asimismo, el tutorial se focaliza en
WSDL 1.1 que es la versión que más se implementa comúnmente, pero los conceptos son los
mismos para la próxima versión WSDL 2.0 y cubren las diferencias básicas.

Acerca de esta serie

Esta serie de tutoriales enseña los conceptos básicos de los servicios web a través de las
peripecias de un periódico de ficción, el Daily Moon, ya que los empleados usan los servicios

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 1/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

web para crear un sistema de flujo de trabajo para aumentar la productividad en estos tiempos
turbulentos.

La Parte 1 comienza simplemente explicando los conceptos básicos de los servicios web y le
muestra cómo usar SOAP, la especificación que sustenta gran parte de lo que está por ocurrir,
conectando al Departamento de Avisos Clasificados con el Sistema de Gestión de Contenidos.

En la Parte 2, el Departamento de Clasificados avanza un paso más, usando Web Services

Description Language para definir los mensajes generados y que se esperan de su propio
servicio web, permitiéndole al equipo de trabajo crear fácilmente servicios y clientes que se
conectan a ellos.

La Parte 3 encuentra al equipo de trabajo con una serie de servicios implementados y la

necesidad de ubicarlos fácilmente. En respuesta a ello Universal Description, Discovery and
Integration (UDDI) ofrece un registro de servicios disponibles que permite realizar búsquedas
como una forma de publicar sus propios servicios para otros.

Las Partes 4 y 5, WS-Security y WS-Policy plantean el objetivo de asegurar los servicios del
periódico y los cambios que deben realizar los equipos de trabajo para acceder a esos servicios
recientemente asegurados.

Interoperabilidad es la palabra clave en la Parte 6 ya que se debe acceder a servicios

provenientes de diferentes implementaciones a través de un único sistema. La parte seis cubre
los requisitos y las pruebas que involucra la certificación WS-I.

Por último, la Parte 7 muestra cómo usar Business Process Execution Language (WS-BPEL)
para crear aplicaciones complejas partiendo de servicios individuales.

Ahora analicemos más detalladamente los temas que abarca este tutorial.

Acerca de este tutorial

La Parte 1 de esta serie, Understanding web services: SOAP [Comprender los servicios web:
SOAP], presentó al personal del periódico de ficción llamado Daily Moon. Específicamente, se
conoció al Departamento de Avisos Clasificados. En ese tutorial, el Departamento de Avisos
Clasificados construyó un cliente para enviar y recibir mensajes SOAP al servicio web que
representa el Sistema de Gestión de Contenidos. Este tutorial, el Departamento de Avisos

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 2/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Clasificados impactado por lo que vieron, decide construir su propio servicio web para tomar y
administrar los avisos en la base de datos de clasificados. Sin embargo, para poder usar el
servicio necesitarán crear un archivo Web Services Description Language (WSDL). Este
archivo brinda las instrucciones a aquellos que construyen clientes para que puedan saber qué
mensajes espera y arroja el sistema.

En este tutorial aprenderá lo siguiente:

Por qué los archivos WSDL son importantes

Qué puede hacer con los archivos WSDL

Los conceptos básicos del esquema XML que se incluye en los archivos WSDL

Cómo estructurar un archivo WSDL

Las diferencias básicas entre WSDL 1.1 y WSDL 2.0

Cómo generar un archivo WSDL automáticamente a partir de una clase Java que
representa un servicio

Cómo generar una clase Java que represente un servicio a partir de un archivo WSDL

Cómo generar un cliente de servicios web a partir de un archivo WSDL

El Departamento de Avisos Clasificados construirá un servicio que tome avisos nuevos, edite y
visualice avisos existentes y cierre una edición para que ya no acepte más avisos. Usarán
mensajería unidireccional y también mensajes de solicitud y respuesta.

Herramientas y requisitos previos

La carga de este tutorial es conceptual, pero para seguir de manera correcta el código hasta el
final de este tutorial, necesitará contar con el siguiente software instalado:

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 3/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Apache Geronimo u otro servidor de aplicaciones-- El equipo crea un nuevo servicio web en
el transcurso de este tutorial y usted necesitará una aplicación en la cual ejecutarlo. Como se
supone que generalmente los servicios web son interoperables, no importa cuál de ellos use.
Este tutorial demuestra el uso de Apache Geronimo que también es la base para WebSphere
Community Edition de IBM. Usted también puede usar otros servidores de aplicaciones como
WebSphere application server. Puede descargar Apache Geronimo
desde http://geronimo.apache.org/downloads.html. Para obtener más información acerca de la
instalación de Geronimo, consulte el primer tutorial de esta serie, "Understanding web services
specifications, Part 1: SOAP (Comprender las especificaciones de los servicios web, Parte 1:
SOAP)."

Apache Axis2 versión 0.95 o superior -- Puede crear mensajes SOAP manualmente, y puede
interpretarlos manualmente, pero es mucho más fácil tener una implementación a mano. Este
tutorial demuestra el uso de Apache Axis2, el cual contiene implementaciones de varias API
relacionadas con SOAP para facilitarle significativamente la tarea. Puede descargar Apache
Axis2 en http://ws.apache.org/axis2/download.cgi. Este tutorial usa la versión 0.95, pero otras
versiones posteriores pueden funcionar. (Obsérvese que la Parte 1 de esta serie usó la versión
0.94, pero no se probó con el código en esta parte.)

Java 2 Standard Edition versión 1.4 o superior -- Todas estas herramientas se basan en
Java ya que éstos son los servicios y los clientes que usted creará en este tutorial. Puede
descargar J2SE SDK desde http://java.sun.com/j2se/1.5.0/download.jsp.

También necesitará un navegador Web y un editor de texto, pero seguramente ya los tenga. Si
lo desea, también puede usar un entorno de desarrollo integrado (IDE) como Eclipse, pero
como nos estamos concentrando en las tecnologías más que en las herramientas, sólo
usaremos un editor de texto y la línea de comandos para editar y compilar nuestros archivos.

Generalidades
Antes de profundizar en los detalles, analicemos el panorama general.

Actualización de servicios web

La ventaja principal de usar servicios web en lugar de métodos de programación tradicionales

es la interoperabilidad. Se puede crear un sistema distribuido en el cual las computadoras que
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 4/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

están física o geográficamente separadas se pueden comunicar, pero en la mayoría de los

casos, involucra middleware propietario que limita su flexibilidad. En otras palabras, tanto el
remitente como el destinatario deben usar el mismo software.

Los servicios web ofrecen un medio basado en texto (en realidad, basado en XML) para
transferir mensajes enviados y recibidos, esto significa que sus aplicaciones no sólo son
independientes de las máquinas, sino también del sistema operativo y del lenguaje de
programación. Siempre y cuando ambas partes sigan los estándares de servicios web, no
importa qué software se esté ejecutando en ambos extremos.

Existen varios estándares para transferir esta información, pero esta serie de tutoriales se basa
en SOAP debido a su flexibilidad y al uso de estándares más avanzados.

Actualización de SOAP

Un mensaje SOAP consta de tres partes principales: un Encabezado, el Cuerpo y la carga útil
que está incluida en el cuerpo. Consideremos el siguiente ejemplo:

Listado 1. Un mensaje SOAP de muestra

1 >SOAPenv:Envelope
2        xmlns:SOAPenv="http://schemas.xml
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  >SOAPenv:Body<
6   >req:getNumberOfArticles xmlns:req="ht
7      >req:category<classifieds>/req:cate
8   >/req:getNumberOfArticles<
9  
10  >/SOAPenv:Body<
11 >/SOAPenv:Envelope<

El mensaje general se llama Sobre, el contenido del cual consta de Encabezado y Cuerpo. El
Encabezado contiene información sobre el mensaje propiamente dicho, como información de
ruteo o información destinada al procesamiento por parte de “intermediarios SOAP”, o servicios
entre el remitente y el destinatario final, quien puede procesar el mensaje. El Cuerpo del
mensaje incluye la “carga útil” que a su vez incluye los datos reales que se transmitirán al
servicio web.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 5/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

En este caso, la carga útil es el elemento getNumberOfArticles y su contenido.

Para qué sirve WSDL

Cuando usted crea un servicio, comúnmente lo hace porque desea que la gente lo use. Para
que puedan hacerlo, necesitan saber qué información deben enviar al servicio, qué información
arrojará el servicio y dónde encontrar el servicio en primer lugar. Por supuesto que usted puede
poner esto en un documento de procesamiento de texto, pero es mucho más útil tener un
formato estándar para esta información, preferentemente que pueda ser leído por humanos y
por máquinas.

WSDL brinda este formato estándar. La ventaja principal, además de eliminar ambigüedad, es
el estándar de hecho y está en XML, puede ser leído por máquinas hasta tal punto que permite
crear clientes (e incluso hasta el esqueleto de un servicio) automáticamente. El Departamento
de Avisos Clasificados va a crear un servicio que acepte y administre avisos clasificados y para
permitir que otros como los Sitios Web de agregación de empleos usen más fácilmente el
servicio, también lo describirán usando un archivo WSDL.

Qué logrará este tutorial

Durante el transcurso de este tutorial, aprenderá sobre WSDL siguiendo al personal del
Departamento de Clasificados de Daily Moon a medida que creen su propio servicio y lo
expongan al uso de otros.

Primero, Christine toma esquemas XML, lo cual define los datos que pueden aparecer en el
mensaje SOAP. Luego, Larry arma la estructura de un archivo WSDL real para comprender qué
información enviarán y recibirán. Posteriormente, Gene toma el archivo WSDL y lo usa como
inspiración para una clase Java que representa al servicio y luego, sólo para estar seguro, usa
Axis2 para generar un archivo WSDL a través de la clase Java para observar las diferencias. A
partir de aquí, Francis toma el archivo WSDL y lo usa para generar el servicio web básico y un
cliente para acceder a ese servicio web.

Comience ya.

Una guía rápida sobre el esquema XML

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 6/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Daily Moon es un periódico muy pequeño y como tal el Departamento de Avisos Clasificados no
puede solventar un Administrador de Bases de Datos (DBA) exclusivo, por lo tanto, Christine
siempre consideró a la base de datos como a “su bebé”. Después de mirar las especificaciones
para WSDL, ella decide asumir la tarea de definir los datos que pueden ir en los mensajes
SOAP.

Validación y opciones

El personal ya está familiarizado con XML después de su incursión inicial en los servicios web,
así que el próximo paso lógico es que Christine aprenda sobre validación.

La validación XML es el proceso de verificar que tanto la estructura como el contenido de un

documento XML cumplan con cualquier requisito predefinido. Originariamente, esto significaba
cumplir con la Definición del tipo de documento (DTD), una estructura segregada de la raíces
de XML como un lenguaje SGML. Las definiciones DTD no eran particularmente difíciles, pero
sí presentaban desventajas importantes en términos de falta de flexibilidad, falta de soporte
para espacios de nombres XML y otros problemas, por lo tanto la comunidad XML pasó a otros
tipos de esquemas XML.

Obsérvese que la palabra “esquemas” no está con mayúscula en el párrafo anterior porque en
este caso estoy hablando sobre el uso general del término que significa la estructura específica
para un documento, a diferencia de cualquier idioma para documentar esa estructura. El
esquema que más comúnmente soporta estos esquemas XML es el lenguaje de Esquema
W3C XML que habitualmente se conoce simplemente como Esquema XML. (Obsérvese el uso
de mayúscula.)

Christine ve que usarán Esquema XML para construir su documento WSDL 1.1, pero nota que
WSDL 2.0 específicamente soporta otros esquemas, como RELAX NG y Schematron que se
pueden usar en su lugar.

El documento de prueba

Christine comienza con un documento de muestra que se aproxima a los datos que estima que
entrarán y saldrán del sistema. Toma un par de avisos existentes y crea el XML:

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 7/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Listado 2. El documento de prueba

1 Listing 2: the instance document

2 <?xml version="1.0"?>
3 <ClassifiedList>
4  
5    <ClassifiedAd adId="1138">
6       <content>Vintage 1963 T-Bird.  Les
7 Driven by my daughter until I took it aw
8 only. 555-3264 after 7 PM.</content>
9       <endDate>4/15/2007</endDate>
10  
11       <startDate>4/1/2007</startDate>
12    </ClassifiedAd>
13  
14    <ClassifiedAd adId="2187">
15       <content>30 ft ladder, only used o
16 go for half its worth. Has slight dent n
17 Harder than a human head. $150 OBO.</con
18  
19       <endDate>4/30/2007</endDate>
20       <startDate>4/10/2007</startDate>
21    </ClassifiedAd>
22  
23 </ClassifiedList>

Este documento se conoce como “documento de prueba”, representa los datos que serán
definidos por el esquema XML. En este caso, consta de dos elementos ClassifiedAd como
elemento secundario de ClassifiedList. Cada ClassifiedAd incluye un atributo adId que
corresponde a la clave primaria dentro de la base de datos, el contenido del aviso, y la fecha de
inicio y fecha de finalización del aviso.

Ella nombra a este documento classifieds.xml.

El esquema básico

El próximo paso de Christine consiste en crear los documentos de esquema básico para poder
probar el sistema. El esquema actual propiamente dicho también es un documento XML, así
que ella crea el archivo básico, classifieds.xsd, y un elemento de esquema único, como se
observa en el Listado 3:

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 8/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Listado 3. Elemento de esquema

1 <xsd:schema
2                     xmlns:xsd="http://www
3                     </xsd:schema>

Este elemento funcionará como el elemento principal para todas las definiciones que cree
Christine.

Validación del documento

El próximo paso, en la prueba del sistema, es armar una aplicación Java simple que validará el
documento de prueba comparándolo con el esquema. Todo lo que tiene que hacer la clase es
especificar la validación y analizar el documento, como se muestra en el Listado 4.

Listado 4. La clase ValidateWithSchema

1 import java.io.File;
2 import java.io.IOException;
3 import javax.xml.parsers.DocumentBuilder
4 import javax.xml.parsers.DocumentBuilder
5 import javax.xml.parsers.ParserConfigura
6 import org.w3c.dom.Document;
7 import org.xml.sax.SAXException;
8   
9 public class ValidateWithSchema {
10   
11     public static void main(String args[
12  
13         DocumentBuilderFactory dbf =
14                         DocumentBuilderF
15         dbf.setValidating(true);
16  
17         dbf.setAttribute(
18           "http://java.sun.com/xml/jaxp/
19           "http://www.w3.org/2001/XMLSch
20         dbf.setAttribute(
21           "http://java.sun.com/xml/jaxp/
22           "classifieds.xsd");
23  
24         Document doc = null;
25         try{       

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 9/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

26            DocumentBuilder parser = dbf.

27            doc = parser.parse("classifie
28         } catch (Exception e){
29            e.printStackTrace();
30         }
31     }
32 }

El método real de análisis no es demasiado importante; en este caso, Christine construye la

aplicación usando un analizador DOM. Primero, construye una fábrica y luego especifica que
cualquier analizador que se cree deberá ser un “analizador de validación”. (No todos los
analizadores son para validación. Algunos simplemente verifican que el documento esté “bien
formado", sin verificar su estructura real.)

Luego, especifica el lenguaje de esquema que se usará, y el documento de esquema

propiamente dicho. En este caso, Christine está usando un archivo local, pero usted puede usar
cualquier archivo al que pueda referirse mediante una URL.

Christine guarda el archivo y lo compila, y después de ejecutarlo, obtiene los siguientes datos
de salida, como se muestra en el Listado 5.

Listado 5. Ejecución del esquema vacío

1 Warning: validation was turned on but an

2 was not set, which is probably not what i
3 use a default ErrorHandler to print the f
4 the 'setErrorHandler' method to fix this.
5  
6 Error: URI=file:///E:/WSDLFiles/classifie
7 Cannot find the declaration of element 'C

La Advertencia no es importante; Christine sólo quiere saber si el archivo es válido o no, así
que no necesita ninguna función especial para administración de errores. El Error es
importante porque significa que el analizador en realidad está mirando el esquema y validando
el documento de prueba.

Ahora ella necesita agregar las definiciones reales.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 10/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Creación de un elemento simple

Es fácil definir los primeros elementos. Los elementos content, endDate y startDate constan
de cadenas simples, como se muestra en el Listado 6.

Listado 6. Agregar elementos simples

1 <xsd:schema xmlns:xsd="http://www.w3.org/
2  
3    <xsd:element type="xsd:string" name="c
4    <xsd:element type="xsd:string" name="e
5    <xsd:element type="xsd:string" name="s
6  
7 </xsd:schema>

En este caso, Christine definió tres elementos que sólo tienen texto (a diferencia de otros
elementos) como contenido. Además, ninguno de ellos tiene atributos. La Recomendación de
Esquema XML define una serie de tipos diferentes que usted puede usar para definir su
contenido. Por ejemplo, puede especificar que los valores endDate y startDate deben ser
valores datetime.

Creación de un elemento más complejo

Resulta obvio que si todos los elementos fueron tan simples, probablemente no habrá
necesitado un esquema en primer lugar. Christine avanza para definir el
elemento ClassifiedList (ver Listado 7).

Listado 7. Definición del elemento ClassifiedList

1 <xsd:schema xmlns:xsd="http://www.w3.org
2  
3 <xsd:element name="ClassifiedList">
4    <xsd:complexType>
5  
6       <xsd:sequence>
7          <xsd:element name="ClassifiedAd
8                                        t
9  
10       </xsd:sequence>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 11/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

11  
12    </xsd:complexType>
13 </xsd:element>
14  
15 <xsd:complexType name="ClassifiedAdType"
16    <xsd:sequence>
17        <xsd:element type="xsd:string" na
18  
19        <xsd:element type="xsd:string" na
20        <xsd:element type="xsd:string" na
21    </xsd:sequence>
22 </xsd:complexType>
23  
24 </xsd:schema>

Comenzando desde abajo, Christine crea ClassifiedAdType complexType. Es un tipo de

elemento que contiene, en orden, un elemento de contenido, un elemento endDate, y un
elemento startDate. Ascendiendo hasta la parte superior, ella define el
elemento ClassifiedList que tiene un elemento que a su vez contiene una secuencia de
elementos. En este caso, sin embargo, contiene cero o más elementos de
tipo ClassifiedAdType, todos llamados ClassifiedAd.

Hasta el momento, con tan solo estas dos definiciones, ella cubrió la mayor parte de la
estructura del documento. Ahora todo lo que necesita es agregar una definición para el
atributo adId.

Agregar atributos

Un atributo se define en un elemento complexType, como se muestra en el Listado 8.

Listado 8. Agregar atributos

1 <xsd:schema xmlns:xsd="http://www.w3.org
2  
3 <xsd:element name="ClassifiedList">
4    <xsd:complexType>
5       <xsd:sequence>
6          <xsd:element name="ClassifiedAd
7  type="ClassifiedAdType"/>
8       </xsd:sequence>
9  
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 12/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

10    </xsd:complexType>
11 </xsd:element>
12  
13 <xsd:complexType name="ClassifiedAdType"
14    <xsd:sequence>
15        <xsd:element type="xsd:string" na
16        <xsd:element type="xsd:string" na
17  
18        <xsd:element type="xsd:string" na
19    </xsd:sequence>
20    <xsd:attribute name="adId" type="xsd:
21 </xsd:complexType>
22  
23 </xsd:schema>

En este caso, Christine limitó el contenido del atributo adId a números enteros. Sin embargo,
podría crear un tipo más restrictivo.

Uso de simpleTypes

El Esquema XML ofrece una gran potencia cuando se trata de definir el contenido real que
puede tener su documento. Por ejemplo, Christine puede especificar que el atributo adId debe
contener sólo números enteros superiores o iguales a 1000 (ver Listado 9).

Listado 9. Restricción de valores

1 <xsd:schema xmlns:xsd="http://www.w3.org
2  
3 ...
4  
5 <xsd:complexType name="ClassifiedAdType"
6    <xsd:sequence>
7        <xsd:element type="xsd:string" na
8        <xsd:element type="xsd:string" na
9  
10        <xsd:element type="xsd:string" na
11    </xsd:sequence>
12    <xsd:attribute name="adId" type="thou
13 </xsd:complexType>
14  
15 <xsd:simpleType name="thousandOrGreater"
16   <xsd:restriction base="xsd:integer">

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 13/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

17  
18       <xsd:minInclusive value="1000"/>
19   </xsd:restriction>
20 </xsd:simpleType>
21  
22 </xsd:schema>

Esta definición no involucra a ningún elemento, así que Christine usa simpleType en lugar de
usar complexType. Ella está creando una restriction -- un límite en el tipo de datos -- con el
tipo de base de números enteros. Luego agrega una “faceta” para esa restricción,
especificando que el valor mínimo es 1000. El Esquema XML permite definir una gran cantidad
de facetas de este tipo para usar. Una vez que ella creó el tipo, puede hacer referencia al
mismo en la definición de atributo. Ahora que ya definió los datos, Christine transfiere el
esquema a Larry para que él pueda construir el WSDL real.

Creación de un documento WSDL

Mientas que Christine se encarga de los datos reales, Larry es responsable por el mensaje real
que va y viene entre el servicio y sus clientes. A través de estos mensajes, él crea el
documento WSDL.

Los mensajes

Los primeros pasos de Larry consisten en decidir qué funciones cumplirá realmente el servicio,
y luego definir los mensajes para los servicios. Después de consultar al resto del departamento,
él obtiene una lista de funciones y sus correspondientes mensajes, y en el resto de esta
sección analizaremos estas funciones.

createNewAd

Esta función toma el contenido del aviso y su fecha de finalización y obtiene la idea para el
aviso recientemente creado (ver Listado 10 y Listado 11).

Listado 10.createNewAdRequest(Input)

1 <env:Envelope
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 14/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6   <req:createNewAdRequest
7               xmlns:req="http://daily-mo
8      <req:content>Vintage 1963 T-Bird...
9      <req:endDate>4/30/07</req:endDate>
10  
11   </req:createNewAdRequest>
12  </env:Body>

Listado 11.createNewAdResponse(Output)

1 <br>
2 <env:Envelope
3        xmlns:env="http://schemas.xmlSOAP
4        xmlns:xsd="http://www.w3.org/2001
5        xmlns:xsi="http://www.w3.org/2001
6  <env:Body>
7   <res:createNewAdResponse
8               xmlns:res="http://daily-mo
9       <res:newAdId>1138</res:newAdId>
10   </res:createNewAdResponse>
11  
12  </env:Body>

editExistingAd

Esta función toma un aviso existente y reemplaza su contenido en la base de datos. Devuelve
un valor booleano indicando si la operación se realizó correctamente (ver Listado 12 y Listado
13).

Listado 12.editExistingAdRequest(Input)

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6   <req:editExistingAdRequest
7               xmlns:req="http://daily-mo
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 15/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

8       <req:ClassifiedAd>
9          <req:id>1138</req:id>
10  
11          <req:content>Vintage 1963 T-Bir
12          <req:startDate>4/1/2007</req:st
13          <req:endDate>4/30/2007</req:end
14       <req:ClassifiedAd>
15  
16   </req:editExistingAdRequest >
17  </env:Body>

Listado 13.editExistingAdResponse(Output)

1 <br>
2 <env:Envelope
3        xmlns:env="http://schemas.xmlSOAP
4        xmlns:xsd="http://www.w3.org/2001
5        xmlns:xsi="http://www.w3.org/2001
6  <env:Body>
7   <res:editExistingAdResponse
8               xmlns:res="http://daily-mo
9       <res:isOK>true</res:isOK>
10   </res:editExistingAdResponse>
11  
12  </env:Body>

getExistingAds

Esta función devuelve una lista de ClassifiedAds(avisos clasificados) existentes (ver Listado
14 y Listado 15).

Listado 14. getExistingAdsRequest (Input)

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP.
3        xmlns:xsd="http://www.w3.org/2001/
4        xmlns:xsi="http://www.w3.org/2001/
5  <env:Body>
6   <req:getExistingAdsRequest
7                   xmlns:req="http://daily
8   </req:getExistingAdsRequest>
9  </env:Body>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 16/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Listado 15. getExistingAdsResponse (Output)

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6   <res:getExistingAdsResponse
7               xmlns:res="http://daily-mo
8     <res:ClassifiedList>
9       <res:ClassifiedAd>
10          <res:id>1138</res:id>
11  
12          <res:content>Vintage 1963 T-Bir
13          <res:startDate>4/1/2007</res:st
14          <res:endDate>4/30/2007</res:end
15       </res:ClassifiedAd>
16  
17       <res:ClassifiedAd>
18          <res:id>2883</res:id>
19          <res:content>Championship playo
20  tickets...</res:content>
21          <res:startDate>4/1/2007</res:st
22  
23          <res:endDate>4/30/2007</res:end
24       </res:ClassifiedAd>
25     </res:ClassifiedList>
26   </res:getExistingAdsResponse >
27 </env:Body>

finalizeIssue

Esta función es una función "in only" (sólo de entrada) que toma una fecha de emisión y no
arroja ningún dato (ver Listado 16).

Listado 16.finalizeIssueRequest(Input)

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 17/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

5  <env:Body>
6   <req:finalizeIssueRequest
7                   xmlns:req="http://dail
8      <req:issueDate>4/10/06</req:issueDa
9   </req:FinalizeIssueRequest >
10  
11  </env:Body>

Munido de estos mensajes, Larry se aboca a crear el documento WSDL real.

Creación del documento básico

Larry comienza con el marco de un documento WSDL (ver Listado 17).

Listado 17. El documento WSDL básico

1 <wsdl:definitions xmlns:wsdl="http://sch
2        targetNamespace="http://ws.apache
3  
4 <wsdl:types>
5 </wsdl:types>
6  
7 <wsdl:message name="createNewAdRequestMe
8 </wsdl:message>
9  
10 <wsdl:portType name="ClassifiedServicePo
11  
12 </wsdl:portType>
13  
14 <wsdl:binding name="ClassifiedServiceBin
15 </wsdl:binding>
16  
17 <wsdl:service name="ClassifiedService">
18 </wsdl:service>
19  
20 </wsdl:definitions>

Como los mensajes SOAP que define, WSDL está compuesto por XML. Las definiciones
residen dentro del elemento definitions, como podrá ver aquí. Comenzando desde abajo,
defina el atributo service. El atributo service usa un binding(enlace) particular que es una
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 18/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

implementación de un atributo portType. El atributo portType define operaciones que están

compuestas por messages(mensajes). Los mensajes están formados por XML definido en la
sección types.

El elemento definitions define dos espacios de nombres. El primero, que usa el prefijo wsdl:,
brinda un espacio de nombres para los elementos reales que integran al WSDL. El
segundo, targetNamespace, define el espacio de nombres al que pertenecen los elementos
definidos por WSDL.

Larry comienza por definir los tipos.

Definición de los tipos

Larry toma las definiciones que le dio Christine y las coloca en el elemento types, creando un
esquema nuevo dentro del documento, como se muestra en el Listado 18.

Listado 18. Definición de los tipos

1 <wsdl:definitions xmlns:wsdl="http://sch
2        xmlns:ns1="http://org.apache.axis
3        targetNamespace="http://ws.apache
4  
5 <wsdl:types>
6   <xs:schema xmlns:xs="http://www.w3.org
7          targetNamespace="http://org.apa
8          elementFormDefault="unqualified
9          attributeFormDefault="unqualifi
10  
11     <xs:element type="ns1:ClassifiedAd"
12  
13     <xs:complexType name="ClassifiedAd">
14       <xs:sequence>
15         <xs:element type="xs:int" name="
16         <xs:element type="xs:string" nam
17         <xs:element type="xs:string" nam
18         <xs:element type="xs:string" nam
19  
20       </xs:sequence>
21     </xs:complexType>
22  
23     <xs:element type="ns1:ClassifiedList
24     <xs:complexType name="ClassifiedList
25       <xs:sequence>

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 19/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

26         <xs:element minOccurs="0" type="

27                         name="Classified
28  
29       </xs:sequence>
30     </xs:complexType>
31  
32     <xs:element name="createNewAdRequest
33       <xs:complexType>
34         <xs:sequence>
35           <xs:element type="xs:string" n
36  
37           <xs:element type="xs:string" n
38         </xs:sequence>
39       </xs:complexType>
40     </xs:element>
41  
42     <xs:element name="createNewAdRespons
43       <xs:complexType>
44  
45         <xs:sequence>
46           <xs:element type="xs:int" name
47         </xs:sequence>
48       </xs:complexType>
49     </xs:element>
50  
51     <xs:element name="editExistingAdRequ
52  
53       <xs:complexType>
54         <xs:sequence>
55           <xs:element type="ns1:Classifi
56 name="ClassifiedAd" />
57         </xs:sequence>
58       </xs:complexType>
59     </xs:element>
60  
61     <xs:element name="editExistingAdResp
62       <xs:complexType>
63         <xs:sequence>
64           <xs:element type="xs:boolean"
65         </xs:sequence>
66       </xs:complexType>
67  
68     </xs:element>
69  
70     <xs:element name="getExistingAdsRequ
71       <xs:complexType />
72     </xs:element>
73  
74     <xs:element name="getExistingAdsResp
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 20/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

75  
76       <xs:complexType>
77         <xs:sequence>
78           <xs:element type="ns1:Classifi
79                                    name=
80         </xs:sequence>
81       </xs:complexType>
82     </xs:element>
83  
84     <xs:element name="finalizeIssueReque
85       <xs:complexType>
86         <xs:sequence>
87           <xs:element type="xs:string" n
88         </xs:sequence>
89       </xs:complexType>
90  
91     </xs:element>
92  
93   </xs:schema>
94  
95 </wsdl:types>
96  
97 </wsdl:definitions>

Comenzando desde arriba, observe que tenemos dos secciones de espacios de nombres. La
primera está dentro del elemento schema propiamente dicho. Aquí Larry define dos espacios de
nombres. El primero con el prefijo xs:, es el espacio de nombres del Esquema XML. El
segundo, targetNamespace, define los espacios de nombres a los que pertenecen las
definiciones creadas por el esquema. En otras palabras, cuando la segunda definición crea un
atributo complexTypellamado ClassifiedAd, esa definición pertenece al espacio de
nombres http://org.apache.axis2/xsd. No obstante, para referirse a ese espacio de
nombres, Larry necesita crear otro alias. Puede ver ese alias en el elemento de definiciones,
con el prefijo ns1:. (Larry podría haber puesto fácilmente esa definición en el elemento de
esquema, pero posteriormente la necesitará fuera del elemento de esquema.) Los dos últimos
atributos, elementFormDefault y attributeFormDefault, indican si los elementos y los
atributos deben tener o no prefijos para espacios de nombres.

Las primeras cuatro definiciones son del esquema que Christine le dio a Larry, pero el resto
define los mensajes que Larry creó anteriormente.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 21/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Nota sobre espacios de nombres

En XML, como en muchos lenguajes de programación, frecuentemente se debe especificar un

"espacio de nombres" para varios elementos y atributos. Esto permite distinguir entre
elementos que tienen el mismo nombre, pero diferentes propósitos y tal vez diferentes
orígenes. XML hace referencia a un espacio de nombres mediante un identificador URI. Por
ejemplo, el espacio de nombres del esquema XML es http://www.w3.org/2001/XMLSchema.
Para facilitar la tarea, sin embargo, también se asigna un alias o un prefijo. Por ejemplo, aquí el
espacio de nombres de esquema tiene un prefijo xs:. Recuerde que el alias es tan solo eso: un
alias. El identificador URI es que realmente importa. Por ello, los elementos o los atributos que
forman parte del nombre de espacios ns1: también forman parte del nombre de
espacios targetNamespace del esquema.

Creación de los mensajes

Con los tipos ya establecidos, Larry puede definir los mensajes que se enviarán y recibirán en
el sobre SOAP (ver Listado 19).

Listado 19. Creación de los mensajes

1 <wsdl:definitions xmlns:wsdl="http://sch
2        xmlns:ns1="http://org.apache.axis
3        targetNamespace="http://ws.apache
4  
5 <wsdl:types>
6   <xs:schema xmlns:xs="http://www.w3.org
7          targetNamespace="http://org.apa
8          elementFormDefault="unqualified
9          attributeFormDefault="unqualifi
10 ...
11     <xs:element name="createNewAdRequest
12       <xs:complexType>
13         <xs:sequence>
14  
15           <xs:element type="xs:string" n
16           <xs:element type="xs:string" n
17         </xs:sequence>
18       </xs:complexType>
19     </xs:element>
20  

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 22/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

21     <xs:element name="createNewAdRespons
22  
23       <xs:complexType>
24         <xs:sequence>
25           <xs:element type="xs:int" name
26         </xs:sequence>
27       </xs:complexType>
28     </xs:element>
29  
30 ...
31   </xs:schema>
32  
33 </wsdl:types>
34  
35 <wsdl:message name="createNewAdRequestMe
36   <wsdl:part name="part1" element="ns1:c
37  />
38 </wsdl:message>
39  
40 <wsdl:message name="createNewAdResponseM
41  
42   <wsdl:part name="part1" element="ns1:c
43 </wsdl:message>
44  
45 <wsdl:message name="getExistingAdsRespon
46   <wsdl:part name="part1" element="ns1:g
47 </wsdl:message>
48  
49 <wsdl:message name="editExistingAdReques
50   <wsdl:part name="part1" element="ns1:e
51  
52 </wsdl:message>
53  
54 <wsdl:message name="getExistingAdsReques
55   <wsdl:part name="part1" element="ns1:g
56 </wsdl:message>
57  
58 <wsdl:message name="editExistingAdRespon
59   <wsdl:part name="part1" element="ns1:e
60 </wsdl:message>
61  
62 <wsdl:message name="finalizeIssueRequest
63   <wsdl:part name="part1" element="ns1:f
64 </wsdl:message>
65  
66 <wsdl:portType name="ClassifiedServicePo
67 </wsdl:portType>
68  
69 <wsdl:binding name="ClassifiedServiceBin
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 23/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

70 </wsdl:binding>
71  
72 <wsdl:service name="ClassifiedService">
73 </wsdl:service>
74  
75 </wsdl:definitions>

Cada mensaje tiene un name (nombre) para referirse al mismo posteriormente. Dentro de cada
mensaje, usted define una o más parts (partes). Obsérvese que WSDL 2.0 sólo permite
unapart(parte) por message (mensaje), así que Larry cumple aquí con esta pauta.

Cada part(parte) tiene un name (nombre) y el nombre del element (elemento) que compone
esa part (parte). El nombre del elemento se relaciona con los tipos definidos en el
elemento types(tipos). Obsérvese que el nombre del elemento tiene el prefijo ns1:, el prefijo
para los espacios de nombres que coincide con el atributo targetNamespace para el esquema.
En otras palabras, cuando Larry creó la definición para createNewAdResponse, esa definición
se registró en http://org.apache.axis2/xsd namespace, y como el prefijo ns1: también se
refiere también a ese espacio de nombres, usted puede referirse al mismo usando ese prefijo.

Definición de la interfaz (portType)

Los mensajes no funcionan por sí mismos, así que Larry debe asociarlos con operaciones
específicas. Estas operation s (operaciones) forman parte del atributo portType. El
atributo portType sólo contiene definiciones y no implementaciones. En ese sentido, se parece
mucho a una interfaz. Efectivamente, en WSDL 2.0, el nombre de portType se cambió
por interface. Larry crea una operación para cada una de las funciones (ver Listado 20).

Listado 20. Agregar operaciones

1 <wsdl:definitions xmlns:wsdl="http://sch
2        xmlns:tns=http://ws.apache.org/ax
3        xmlns:ns1="http://org.apache.axis
4        targetNamespace="http://ws.apache
5  
6 <wsdl:types>
7 ...
8 </wsdl:types>
9  
10 <wsdl:message name="createNewAdRequestMe

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 24/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

11  
12   <wsdl:part name="part1" element="ns1:c
13 </wsdl:message>
14  
15 <wsdl:message name="createNewAdResponseM
16   <wsdl:part name="part1" element="ns1:c
17 </wsdl:message>
18 ...
19 <wsdl:message name="finalizeIssueRequest
20   <wsdl:part name="part1" element="ns1:f
21  
22 </wsdl:message>
23  
24 <wsdl:portType name="ClassifiedServicePo
25  
26   <wsdl:operation name="finalizeIssue">
27     <wsdl:input message="tns:finalizeIss
28   </wsdl:operation>
29  
30   <wsdl:operation name="createNewAd">
31  
32     <wsdl:input message="tns:createNewAd
33     <wsdl:output message="tns:createNewA
34   </wsdl:operation>
35  
36   <wsdl:operation name="editExistingAd">
37     <wsdl:input message="tns:editExistin
38     <wsdl:output message="tns:editExisti
39  
40   </wsdl:operation>
41  
42   <wsdl:operation name="getExistingAds">
43     <wsdl:input message="tns:getExisting
44     <wsdl:output message="tns:getExistin
45   </wsdl:operation>
46  
47 </wsdl:portType>
48  
49 <wsdl:binding name="ClassifiedServiceBin
50 </wsdl:binding>
51  
52 <wsdl:service name="ClassifiedService">
53 </wsdl:service>
54  
55 </wsdl:definitions>

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 25/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Larry crea dos tipos de mensajes. Uno, comofinalizeIssue, es una operación "in-only" (sólo
de entrada) ya que tiene sólo un mensaje de entrada. Ese mensaje, finalizeIssueRequest,
se definió previamente, y como antes, creamos un prefijo nuevo, tns:, para referirnos al
espacio de nombres al que pertenece.

El segundo tipo de operación es una operación de solicitud/respuesta, como createNewAd. En

este caso, Larry define ambos, los mensajes de entrada y los de salida.

Definición de enlaces

Si el atributo portType es como una interfaz, el binding (enlace) es la implementación de esa

interfaz (ver Listado 21).

Listado 21. Creación del enlace

1 <wsdl:definitions
2 xmlns:soap="http://schemas.xmlsoap.org/
3        xmlns:wsdl="http://schemas.xmlso
4        xmlns:tns="http://ws.apache.org/
5        xmlns:ns1="http://org.apache.axi
6        targetNamespace="http://ws.apach
7  
8 <wsdl:types>
9 </wsdl:types>
10  
11 <wsdl:message name="createNewAdRequestM
12   <wsdl:part name="part1" element="ns1:
13  
14 </wsdl:message>
15 ...
16 <wsdl:portType name="ClassifiedServiceP
17  
18   <wsdl:operation name="finalizeIssue">
19     <wsdl:input message="tns:finalizeIs
20   </wsdl:operation>
21  
22   <wsdl:operation name="createNewAd">
23  
24     <wsdl:input message="tns:createNewA
25     <wsdl:output message="tns:createNew
26   </wsdl:operation>
27  
28   <wsdl:operation name="editExistingAd"
29     <wsdl:input message="tns:editExisti
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 26/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

30     <wsdl:output message="tns:editExist
31  
32   </wsdl:operation>
33  
34   <wsdl:operation name="getExistingAds"
35     <wsdl:input message="tns:getExistin
36     <wsdl:output message="tns:getExisti
37   </wsdl:operation>
38  
39 </wsdl:portType>
40  
41 <wsdl:binding name="ClassifiedServiceBi
42                          type="tns:Clas
43  
44   <soap:binding transport="http://schem
45                                        
46  
47   <wsdl:operation name="createNewAd">
48     <soap:operation soapAction="createN
49  
50     <wsdl:input>
51       <soap:body use="literal"
52                       namespace="http:/
53     </wsdl:input>
54     <wsdl:output>
55       <soap:body use="literal"
56                       namespace="http:/
57     </wsdl:output>
58  
59   </wsdl:operation>
60  
61   <wsdl:operation name="finalizeIssue">
62     <soap:operation soapAction="finaliz
63     <wsdl:input>
64       <soap:body use="literal"
65                       namespace="http:/
66     </wsdl:input>
67  
68   </wsdl:operation>
69  
70   <wsdl:operation name="editExistingAd"
71     <soap:operation soapAction="editExi
72     <wsdl:input>
73       <soap:body use="literal"
74                       namespace="http:/
75     </wsdl:input>
76  
77     <wsdl:output>
78       <soap:body use="literal"
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 27/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

79                       namespace="http:/
80     </wsdl:output>
81   </wsdl:operation>
82  
83   <wsdl:operation name="getExistingAds"
84     <soap:operation soapAction="getExis
85  
86     <wsdl:input>
87       <soap:body use="literal"
88                       namespace="http:/
89     </wsdl:input>
90     <wsdl:output>
91       <soap:body use="literal"
92                       namespace="http:/
93     </wsdl:output>
94  
95   </wsdl:operation>
96  
97 </wsdl:binding>
98  
99 <wsdl:service name="ClassifiedService">
100 </wsdl:service>
101  
102 </wsdl:definitions>

Primero, obsérvese que el enlace type (tipo) se refiere al

atributo ClassifiedServicePortTypeque Larry ya creó. Segundo, obsérvese que se agregó el
espacio de nombres soap:. Este binding(enlace) es para mensajes SOAP en HTTP, como
puede observar en el elemento soap:binding. Obsérvese el atributo transport. (No se
preocupe todavía por style (estilo); analizaremos eso en la sección siguiente).

Para cada operación, que comparta el nombre que tenía en el atributo portType, Larry ahora
agrega un elemento soap:operation. Este elemento cumple dos funciones: una, indica que
esto es en realidad una operación SOAP; la otra, es para especificar un atributo soapAction,
un encabezado de HTTP que se envíe al comienzo del mensaje SOAP real. El servidor puede
usar este encabezado para rutear la solicitud a la operación apropiada.

Obsérvese que el atributo soapAction siempre ha sido bastante problemático, y aunque

opcional en WSDL 1.1, se lo eliminó completamente de WSDL 2.0.

Cada operación también define un mensaje input(de entrada) y uno output (de salida), en el
caso de mensajes que sean exclusivamente de entrada, sólo definirán un mensaje input (de
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 28/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

entrada), pero ahora Larry también agrega información SOAP específica. Nuevamente, no se
preocupe por el atributo use; también lo analizaremos en un momento. Este elemento define
además el espacio de nombres para el contenido de la carga útil.

Definición del servicio

Habiendo definido tanto la interfaz como el enlace, es hora de definir el servicio (ver Listado
22).

Listado 22. Definición del servicio

1 ...
2 <wsdl:binding name="ClassifiedServiceBin
3                      type="tns:Classifie
4  
5 ...
6 </wsdl:binding>
7  
8 <wsdl:service name="ClassifiedService">
9   <wsdl:port name="ClassifiedServicePort
10                     binding="tns:Classif
11     <soap:address location=
12  "http://127.0.0.1:8080/axis2/services/C
13  
14   </wsdl:port>
15 </wsdl:service>
16  
17 </wsdl:definitions>

Un service(servicio) puede tener más de un punto final, cada uno definido por su propio
elemento port (puerto). El elemento port corresponde a un enlace en particular e incluye
información sobre la forma de acceder al mismo. En este caso, Larry especifica que se puede
acceder al puerto a través de SOAP
en http://127.0.0.1:8080/axis2/services/ClassifiedService.

Documentación del servicio

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 29/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Con el servicio ya definido, resta un paso más. Es optativo, pero debería hacerlo. WSDL le
permite agregar un elemento de documentación a cualquier elemento en el documento WSDL.
El Listado 23 ofrece un ejemplo.

Listado 23. Documentación del servicio

1 ...
2 <wsdl:portType name="ClassifiedServicePo
3  
4   <wsdl:document>The finalizeIssue opera
5          operation that tells the system
6          more ads for a particular date.
7  
8   <wsdl:operation name="finalizeIssue">
9     <wsdl:input message="tns:finalizeIss
10  
11   </wsdl:operation>
12 ...

Hay mucha información sobre WSDL, pero éstos son los conceptos básicos. Antes de avanzar,
sin embargo, demos un vistazo rápido a un par de situaciones más avanzadas que podría llegar
a enfrentar.

Otros enlaces que no sean SOAP en HTTP

Pese a que el uso más común de WSDL es definir SOAP en HTTP, de ninguna manera es la
única forma de especificar un servicio web. Por ejemplo, Larry puede crear un enlace que use
SOAP en correo electrónico y lo habilite sólo para la operación finalizeIssue (ver Listado 24).

Listado 24. Agregar un enlace adicional

1 ...
2 <wsdl:binding name="ClassifiedServiceEma
3                           type="tns:Clas
4  
5    <soap:binding style="document" transp
6  
7    <wsdl:operation name="finalizeIssue">
8      <wsdl:input message="tns:finalizeIs
9  
10          <soap:body parts="body" use="li

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 30/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

11       </wsdl:input>
12    </wsdl:operation>
13  
14 </wsdl:binding>
15  
16 <wsdl:service name="ClassifiedService">
17   <wsdl:port name="ClassifiedServicePort
18                     binding="tns:Classif
19  
20     <soap:address location=
21        "http://127.0.0.1:8080/axis2/serv
22   </wsdl:port>
23  
24   <wsdl:port name="ClassifiedServiceEmai
25                        binding="tns:Clas
26     <soap:address location="mailto:final
27   </wsdl:port>
28 </wsdl:service>
29  
30 </wsdl:definitions>

Aquí Larry agregó un segundo enlace,ClassifiedServiceEmailBinding. Como el

enlace ClassifiedServiceBinding, se base en el atributo ClassifiedServicePortType
portType. En este caso, sin embargo, él usa SMTP (el protocolo utilizado para enviar correo
electrónico) en lugar de HTTP. Entonces puede agregar un segundo puerto al servicio,
basándolo en el nuevo enlace y usando una URL de correo electrónico como la ubicación en
lugar de una URL de HTTP.

SOAP y Mime

Otro tópico para el cual la solución no es tan obvia, es el uso de SOAP con adjuntos. Como el
mensaje es más que un mero documento XML, ¿cómo lo especificará usando WSDL? La
respuesta implica el hecho de que el mensaje se envía usando "multipart MIME".
Afortunadamente, usted puede especificar esto en el documento WSDL. Por ejemplo, Larry
quiere especificar una operación en la cual los usuarios que editen un aviso existente, obtengan
un PDF como constancia del aviso (ver Listado 25).

Listado 25. Especificación de un mensaje multiparte

1 ...

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 31/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

2   <wsdl:operation name="editExistingAd">
3     <soap:operation soapAction="editExis
4 style="document" />
5     <wsdl:input>
6       <soap:body use="literal"
7                 namespace="http://daily-
8     </wsdl:input>
9     <wsdl:output>
10  
11       <soap:body use="literal"
12                 namespace="http://daily-
13       <mime:multipartRelated>
14           <mime:part>
15              <soap:body parts="body" use
16           </mime:part>
17           <mime:part>
18  
19               <mime:content part="docs"
20           </mime:part>
21           <mime:part>
22               <mime:content part="proof"
23               <mime:content part="proof"
24            </mime:part>
25  
26        </mime:multipartRelated>
27     </wsdl:output>
28 ...

En este caso, el mensaje que arroja incluye SOAP, un documento HTML y dos archivos de
imágenes.

Análisis de WSDL 2.0

En todas esta sección, intenté señalar algunos de los aspectos en los cuales WSDL 2.0 diferirá
de WSDL 1.1, por ejemplo el cambio de portTypes (tipos de puerto) potencialmente múltiples a
una única interface (interfaz), y el hecho de que los message s (mensajes) ya no pueden tener
más de una parte. También se vislumbran otros cambios.

Varios factores motivan estos cambios, pero la mayoría de ellos se deben a motivos de
interoperabilidad --construcciones que no son lícitas en WS-I's Basic Profile y por lo general
están prohibidas-- o para facilitar el uso de WSDL con especificaciones SOAP ampliadas. Por

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 32/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

ejemplo, WSDL 2.0 usa más de un modelo de "componente", lo cual se adapta mejor a la
integración con las demandas de especificaciones tales como WS-Choreography.

Otro cambio involucra la especificación formal de "patrones de intercambio de mensajes". En

lugar de esperar simplemente que los usuarios se fijen si hay o no mensajes entrantes o
salientes o sólo salientes, WSDL 2.0 le permite indicar específicamente qué patrón está usando
(ver el Litado 26).

Listado 26. Especificación de los patrones de intercambio de mensajes

1 ...
2   <wsdl:operation name="finalizeIssue"
3             pattern=http://www.w3.org/20
4     <wsdl:input message="tns:finalizeIss
5   </wsdl:operation>
6  
7   <wsdl:operation name="createNewAd"
8               pattern="http://www.w3.org
9  
10     <wsdl:input message="tns:createNewAd
11     <wsdl:output message="tns:createNewA
12   </wsdl:operation>
13 ...

Ahora pasemos a la parte inferior de los estilos WSDL.

Estilos WSDL
Una de las tareas más confusas para los desarrolladores que están aprendiendo a usar WSDL
es elegir un estilo para un documento. Analicemos las diferentes opciones y cómo afectan tanto
a WSDL, como al documento SOAP.

Programación de estilos y codificación

En el ámbito de XML, hay generalmente dos tipos de personas: aquellas que consideran a XML
como un formato de datos y aquellas que piensan en XML como marcado de documentos. En
general, estos dos extremos nunca se juntan. Esta separación se traslada, en cierta forma, a

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 33/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

los servicios web. Hay algunos que lo consideran una forma de Llamada a procedimiento
remoto (RPC) basada en XML y otros que lo consideran un medio de trasladar información
XML de un lugar a otro.

En términos de WSDL, esto se refleja en la elección del "estilo" del mensaje. Cuando cree el
enlace, podrá elegir el estilo del documento, como eligió Larry para el servicio de Avisos
Clasificados, o el estilo RPC. Ningún estilo es de por sí "correcto" o "incorrecto". Pero ambos
tienen ventajas y desventajas.

Cuando se use el estilo RPC, el nombre del método que se ejecutará es también el nombre del
elemento raíz de la carga útil. Pero usted dirá, un momento, ¿no es así como está estructurado
el WSDL de los Avisos Clasificados? Bueno, sí y no. Sí, el nombre del elemento raíz es el
mismo al nombre del método que queremos que aplique el servicio. Sin embargo, esto es, en
cierta forma, una coincidencia; Larry estructuró específicamente el servicio de esa manera.

Analicemos las diferentes opciones y cómo funcionan en términos de WSDL y SOAP.

Document/Literal

El estilo document/literal significa que la carga útil contiene sólo los datos reales que se
transmitirán al servicio. Cualquier ruteo necesario para que el mensaje llegue a su destino se
debe realizar de alguna otra forma, por ejemplo a través del encabezado soapAction o de una
URL específica para el servicio.

El mensaje es simple y directo (ver Listado 27).

Listado 27. Un mensaje con estilo document/literal

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5 <env:Body>
6      <req:content>Vintage 1963 T-Bird...
7      <req:endDate>4/30/07</req:endDate>
8 </env:Body>
9  
10 </env:Envelope>

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 34/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Obsérvese que no hay elemento raíz para la carga útil. En el archivo WSDL, usted define los
elementos directamente y los agrega al mensaje (ver Listado 28).

Listado 28. WSDL con estilo document/literal

1 <br>
2 ...
3 <wsdl:types>
4   <xs:schema xmlns:xs="http://www.w3.org
5          targetNamespace="http://org.apa
6          elementFormDefault="unqualified
7          attributeFormDefault="unqualifi
8  
9 ...
10     <xs:element type="xs:string" name="c
11     <xs:element type="xs:string" name="e
12 ...
13   </xs:schema>
14  
15 </wsdl:types>
16  
17 <wsdl:message name="createNewAdRequestMe
18   <wsdl:part name="part1" element="ns1:c
19   <wsdl:part name="part2" element="ns1:e
20 </wsdl:message>
21  
22 ...
23 <wsdl:portType name="ClassifiedServicePo
24  
25 ...
26   <wsdl:operation name="createNewAd">
27     <wsdl:input message="tns:createNewAd
28     <wsdl:output message="tns:createNewA
29   </wsdl:operation>
30  
31 ...
32 </wsdl:portType>
33 ...
34 <wsdl:binding name="ClassifiedServiceBin
35  type="tns:ClassifiedServicePortType">
36  
37   <soap:binding transport="http://schema
38     style="document" />
39  
40   <wsdl:operation name="createNewAd">
41     <soap:operation soapAction="createNe
42  
43     <wsdl:input>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 35/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

44       <soap:body use="literal" />

45     </wsdl:input>
46     <wsdl:output>
47       <soap:body use="literal" />
48  
49     </wsdl:output>
50   </wsdl:operation>
51  
52 ...
53 </wsdl:binding>
54 ...

Obsérvese que en el estilo de documento, todos los elementos que forman parte de la carga útil
también tienen definiciones en el esquema. También, obsérvese que el mensaje tiene dos
partes distintas, cada una de las cuales se refiere a un elemento específico.

Document/Literal/wrapped

Este tutorial usa el estilo document/literal/wrapped que es similar al estilo document/literal,

excepto que la carga útil tiene un elemento raíz. Esto ofrece la ventaja de incluir el nombre del
método que se ejecutará (aunque esto no es un requisito), así como el cumplimiento con los
requisitos de WS-I Basic Profile. Como recordatorio, aquí se incluye el mensaje simple (ver
Listado 29).

Listado 29. Un mensaje con estilo document/literal/wrapped

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6   <req:createNewAdRequest
7               xmlns:req="http://daily-mo
8      <req:content>Vintage 1963 T-Bird...
9      <req:endDate>4/30/07</req:endDate>
10  
11   </req:createNewAdRequest>
12  </env:Body>
13 </env:Envelope>

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 36/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Para completar el tema, aquí se incluye el respectivo WSDL (ver Listado 30).

Listado 30. WSDL con diseño Document/literal/wrapped

1 ...
2 <wsdl:types>
3   <xs:schema xmlns:xs="http://www.w3.org
4          targetNamespace="http://org.apa
5          elementFormDefault="unqualified
6          attributeFormDefault="unqualifi
7 ...
8     <xs:element name="createNewAdRequest
9       <xs:complexType>
10         <xs:sequence>
11           <xs:element type="xs:string" n
12  
13           <xs:element type="xs:string" n
14         </xs:sequence>
15       </xs:complexType>
16     </xs:element>
17 ...
18   </xs:schema>
19  
20 </wsdl:types>
21  
22 <wsdl:message name="createNewAdRequestMe
23   <wsdl:part name="part1" element="ns1:c
24  />
25 </wsdl:message>
26 ...
27 <wsdl:portType name="ClassifiedServicePo
28  
29   <wsdl:operation name="createNewAd">
30  
31     <wsdl:input message="tns:createNewAd
32     <wsdl:output message="tns:createNewA
33   </wsdl:operation>
34 ...
35 </wsdl:portType>
36 ...
37 <wsdl:binding name="ClassifiedServiceBin
38  type="tns:ClassifiedServicePortType">
39  
40   <soap:binding transport="http://schema
41  style="document" />
42  
43   <wsdl:operation name="createNewAd">
44     <soap:operation soapAction="createNe

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 37/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

45  />
46     <wsdl:input>
47       <soap:body use="literal"
48                         namespace="http:
49  
50     </wsdl:input>
51     <wsdl:output>
52       <soap:body use="literal"
53                         namespace="http:
54     </wsdl:output>
55   </wsdl:operation>
56 ...
57 </wsdl:binding>
58  
59 ...

Nuevamente, todos los elementos en la carga útil se definen en el esquema.

RPC/Literal

El estilo RPC maneja las cosas de manera levemente diferente. Es el nombre propio de WSDL
que define qué se incluye en el mensaje, y no el esquema. Por ejemplo, analice este mensaje
SOAP (ver Listado 31).

Listado 31. Un mensaje con estilo RPC/literal

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6  
7   <req:createNewAdRequest
8               xmlns:req="http://daily-mo
9      <req:content>Vintage 1963 T-Bird...
10      <req:endDate>4/30/07</req:endDate>
11  
12   </req:createNewAdRequest>
13  </env:Body>
14 </env:Envelope>

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 38/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

El mensaje en sí es idéntico al estilo document/literal/wrapped, pero el WSDL es muy diferente

(ver Listado 32).

Listado 32. El WSDL para un mensaje con estilo RPC/literal

1 ...
2 <wsdl:types>
3   <xs:schema xmlns:xs="http://www.w3.org
4          targetNamespace="http://org.apa
5          elementFormDefault="unqualified
6          attributeFormDefault="unqualifi
7 ...
8   </xs:schema>
9  
10 </wsdl:types>
11  
12 <wsdl:message name="createNewAdRequest">
13  
14   <wsdl:part name="content" element="xsd
15   <wsdl:part name="endDate" element="xsd
16 </wsdl:message>
17  
18 ...
19 <wsdl:portType name="ClassifiedServicePo
20  
21   <wsdl:operation name="createNewAd">
22     <wsdl:input message="tns:createNewAd
23     <wsdl:output message="tns:createNewA
24   </wsdl:operation>
25  
26 ...
27 </wsdl:portType>
28 ...
29 <wsdl:binding name="ClassifiedServiceBin
30  type="tns:ClassifiedServicePortType">
31  
32   <soap:binding transport="http://schema
33  style="document" />
34  
35   <wsdl:operation name="createNewAd">
36     <soap:operation soapAction="createNe
37  
38     <wsdl:input>
39       <soap:body use="literal"
40                         namespace="http:
41     </wsdl:input>
42     <wsdl:output>
43       <soap:body use="literal"
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 39/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

44                         namespace="http:
45  
46     </wsdl:output>
47   </wsdl:operation>
48 ...
49 </wsdl:binding>
50 ...

Primero, obsérvese que en el esquema no se definió nada realmente. En cambio,

el message(mensaje) lleva el nombre del método que se ejecutará, y las message part s
(partes del mensaje) directamente definen cada elemento. Obsérvese también que en el estilo
RPC, el nombre de la parte del mensaje es importante; es el nombre del elemento dentro de la
carga útil. Los tipos de mensaje se definen directamente. (Esto, por supuesto, significa que
usted no puede tener elementos complejos como parte de su carga útil, pero como este estilo
está diseñado para emular una llamada a procedimiento remoto, esto no representa un
problema).

En el atributo portType, cuando usted especifica el mensaje, directamente identifica al mensaje

como creado con estos elementos. Entonces, en el enlace, mediante la especificación del estilo
RPC, queda claro cómo se traduce todo esto al mensaje SOAP.

RPC/Encoded

El último estilo para analizar es RPC/encoded (RPC/codificado). Este estilo es similar a

RPC/literal, excepto que el mensaje SOAP define la información real del tipo (ver Listado 33).

Listado 33. Un mensaje SOAP con estilo RPC/encoded (RPC/codificado)

1 <env:Envelope
2        xmlns:env="http://schemas.xmlSOAP
3        xmlns:xsd="http://www.w3.org/2001
4        xmlns:xsi="http://www.w3.org/2001
5  <env:Body>
6    <req:createNewAdRequest
7               xmlns:req="http://daily-mo
8      <req:content xsi:type="xs:string">V
9                                         
10  
11      <req:endDate
12  xsi:type="xs:string">4/30/07</req:endDa
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 40/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

13     </req:createNewAdRequest>
14    </env:Body>
15 </env:Envelope>

El WSDL para definir el mensaje es el mismo que RPC/literal, pero se agrega información de
codificación adicional al enlace (ver Listado 34).

Listado 34. El WSDL con estilo RPC/encoded (RPC/codificado)

1 <wsdl:definitions xmlns:xs="http://www.w
2        xmlns:soap="http://schemas.xmlsoa
3        xmlns:wsdl="http://schemas.xmlsoa
4        xmlns:tns="http://ws.apache.org/a
5  
6        xmlns:axis2="http://ws.apache.org
7        xmlns:ns1="http://org.apache.axis
8   
9        targetNamespace="http://ws.apache
10  
11 <wsdl:types>
12   <xs:schema xmlns:xs="http://www.w3.org
13          targetNamespace="http://org.apa
14          elementFormDefault="unqualified
15          attributeFormDefault="unqualifi
16 ...
17   </xs:schema>
18  
19 </wsdl:types>
20  
21 <wsdl:message name="createNewAdRequest">
22   <wsdl:part name="content" element="xsd
23   <wsdl:part name="endDate" element="xsd
24 </wsdl:message>
25 ...
26  
27 <wsdl:portType name="ClassifiedServicePo
28  
29   <wsdl:operation name="createNewAd">
30     <wsdl:input message="tns:createNewAd
31     <wsdl:output message="tns:createNewA
32   </wsdl:operation>
33  
34 ...
35 </wsdl:portType>
36  

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 41/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

37 <wsdl:binding name="ClassifiedServiceBin
38  type="tns:ClassifiedServicePortType">
39  
40   <soap:binding transport="http://schema
41 style="rpc" />
42  
43   <wsdl:operation name="createNewAd">
44     <soap:operation soapAction="createNe
45  
46     <wsdl:input>
47       <soap:body use="encoded"
48 encodingStyle=http://schemas.xmlsoap.org
49   namespace="http://ws.apache.org/axis2"
50     </wsdl:input>
51     <wsdl:output>
52  
53       <soap:body use="literal" namespace
54 "http://ws.apache.org/axis2" />
55     </wsdl:output>
56   </wsdl:operation>
57  
58 ...
59 </wsdl:binding>
60 ...

Cuando cree un archivo WSDL manualmente, deberá manejar todo esto usted mismo.
Afortunadamente, no siempre tiene que crearlo manualmente.

Generación de código usando WSDL

Gene y Francis son los programadores del grupo en el periódico, convocados por el
departamento de TI cuando el departamento de Avisos Clasificados los puede sacar de sus
propios proyectos. Ellos van a trabajar en la generación de código WSDL abordándolo de dos
maneras; Gene se concentrará en generar código de Java a WSDL y Francis generará el
código de WSDL a Java.

Cómo funciona la generación de código

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 42/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

En los comienzos de WSDL, las dos primeras aplicaciones que aparecieron fueron Java2WSDL
y WSDL2Java. Después de todo, de qué sirve un formato automatizado si no se puede usar
para automatizar algo. Por supuesto que en esos momentos las opciones eran bastante
limitadas. El código se orientaba al estilo RPC y era difícil generar automáticamente un sistema
con cargas útiles complejas.

Rápidamente hasta llegar al día de hoy, estos problemas se solucionaron de manera

contundente. Axis2 puede generar código Java desde virtualmente cualquier documento WSDL
y WSDL desde cualquier clase Java. Esto se logra usando el enlace de datos, en el cual una
estructura XML se convierte en un objeto Java y viceversa. El proceso de generación crea el
código que después se puede alterar, ajustar, compilar y ejecutar.

Primero, Gene comienza con una clase Java y la usa para generar un documento WSDL.
Francis luego toma ese documento y lo usa para generar el servicio y el cliente. Para el
servicio, el proceso de generación crea un esqueleto en el cual usted puede agregar su propio
código para efectuar las acciones que desee que realice el servicio. Para el cliente, crea un
stub que usted puede usar para invocar un método de servicio web como si fuera un método
Java.

Preparación

El primer paso es asegurarse que su entorno esté listo. Descargue la versión 0.95 de Apache
Axis2, desempaquételo y verifique que todos los archivos *.jar en el directorio de la biblioteca
estén en CLASSPATH.

Para ejecutar el servicio web, instale Apache Geronimo (si aún no lo hizo) e inícielo. (Ver la
Parte 1 para conocer las instrucciones). Descargue la distribución de Axis2 v0.95 War y cópiela
al directorio <GERONIMO_HOME>/deploy. Geronimo implantará a Axis2 automáticamente.

Las clases Java

Gene comienza con la clase ClassifiedService, la cual intenta usar como el servicio de
asistencia doméstica y también como una forma de probar que todo funcione como se espera
(ver Listado 35).

Listado 35. ClassifiedService.java

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 43/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

1 package org.dailymoon.classifieds;
2  
3 public class ClassifiedService {
4     
5    public static int createNewAd(String
6  
7       ClassifiedAd newAd = new Classifie
8       newAd.setEnd(endDate);
9       newAd.setContent(content);
10       newAd.save();
11  
12       return 1;
13  
14    }
15  
16    public static boolean editExistingAd(
17  
18       //Do stuff with the ad here
19       return true;
20  
21    }
22  
23  
24    public static ClassifiedList getExist
25  
26        ClassifiedAd[] listOfAds = {new C
27  ClassifiedAd(), new ClassifiedAd()};
28        ClassifiedList listToReturn = new
29        return listToReturn;
30    }
31  
32    public static void finalizeIssue(Stri
33        //Don't return anything.
34        System.out.println(dateToFinalize
35    }
36  
37    public static void main (String args[
38  
39          ClassifiedService.createNewAd(
40            "Eclipse experts needed.  Con
41                                         
42  
43          ClassifiedAd adToEdit = new Cla
44          adToEdit.setId(1);
45          adToEdit.setStart("4/8/2006");
46          adToEdit.setEnd("4/30/2006");
47          adToEdit.setContent(
48              "Geronimo experts needed. 

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 44/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

49  
50          ClassifiedService.editExistingA
51  
52          ClassifiedList adList = Classif
53          System.out.println(adList.toStr
54  
55    }
56  
57  
58 }

La aplicación propiamente dicha es bastante sencilla, aporta un ejemplo de creación de aviso

nuevo, edición de un aviso existente y listado de los avisos existentes, brinda limitaciones
básicas para cuatro métodos que Gene desea
exponer, createNewAd, editExistingAd, getExistingAds y finalizeIssue.

(Asegúrese de convertir en comentario el método principal antes de generar el WSDL. No

dañará nada, pero generará código extra innecesario.)

La case a su vez se refiere a otras dos clases, ClassifiedAd y ClassifiedList. Para que el
proceso de generación comprenda cómo estructurar estos objetos como XML, Gene los crea
como clases separadas (ver Listado 36).

Listado 36. ClassifiedAd.java

1 package org.dailymoon.classifieds;
2  
3 public class ClassifiedAd {
4  
5    private int id;
6    private String startDate;
7    private String endDate;
8    private String content;
9  
10    public void setId(int newId){
11       id = newId;
12    }
13  
14    public void setStartDate(String newSt
15       startDate = newStart;
16    }
17  
18    public void setEndDate(String newEnd)

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 45/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

19       endDate = newEnd;
20    }
21  
22    public void setContent(String newCont
23       content = newContent;
24    }
25  
26    public void save(){
27        //Save data here
28        System.out.println("Ad saved.");
29    }
30  
31 }

Nuevamente, la clase propiamente dicha no está completa, pero la estructura está

implementada (ver Listado 37).

Listado 37. ClassifiedList.java

1 package org.dailymoon.classifieds;
2  
3 public class ClassifiedList {
4  
5     public ClassifiedAd[] listOfAds;
6  
7     public ClassifiedList(ClassifiedAd[]
8         listOfAds = newListOfAds;
9     }
10  
11     public ClassifiedAd[] getRawAds(){
12          return listOfAds;
13     }
14  
15     public String toString(){
16          return "This is a string of res
17     }
18  
19 }

Aquí Gene especifica que ClassifiedList está compuesto por una variedad de
objetos ClassifiedAd.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 46/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Con todas estas clases implementadas, él puede generar el WSDL.

Generación y preparación de WSDL

Generar el WSDL es un proceso sencillo. Desde la línea de comandos, Gene emite el

comando, como se muestra en el Listado 38:

Listado 38. Comando para generar el WSDL

1 java org.apache.axis2.wsdl.Java2WSDL -cn

2                    org.dailymoon.classifi

(Obsérvese que esto deberá aparecer en una línea.)

El switch -cn especifica la clase que forma la base para el servicio. El switch -o especifica el
directorio de los datos de salida. Suponiendo que no hubiera problemas, la clase se ejecuta
tranquilamente, dejando al archivo ClassifiedService.wsdl en el directorio de los datos de salida.
Este archivo es muy parecido al que generó Larry anteriormente —por diseño, ya que todos
funcionan en el mismo servicio— pero se debe realizar algunos pequeños cambios para
acomodar los elementos que fueron nombrados genéricamente por el proceso de generación.
Específicamente, los parámetros no se traducen bien y probablemente deban renombrarse.

Aquí está el archivo WSDL generado, con los ajustes en negrita (ver Listado 39).

Listado 39. El archivo WSDL

1 <wsdl:definitions xmlns:xs="http://www.
2        xmlns:soap="http://schemas.xmlso
3        xmlns:wsdl="http://schemas.xmlso
4        xmlns:tns="http://ws.apache.org/
5        xmlns:ns1="http://org.apache.axi
6        targetNamespace="http://ws.apach
7  
8 <wsdl:types>
9   <xs:schema xmlns:xs="http://www.w3.or
10          targetNamespace="http://org.ap
11          elementFormDefault="unqualifie
12          attributeFormDefault="unqualif
13  
14     <xs:element type="ns1:ClassifiedAd"
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 47/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

15  
16     <xs:complexType name="ClassifiedAd"
17       <xs:sequence>
18         <xs:element type="xs:int" name=
19         <xs:element type="xs:string" na
20         <xs:element type="xs:string" na
21         <xs:element type="xs:string" na
22  
23       </xs:sequence>
24     </xs:complexType>
25  
26     <xs:element type="ns1:ClassifiedLis
27     <xs:complexType name="ClassifiedLis
28       <xs:sequence>
29         <xs:element minOccurs="0" type=
30                         name="Classifie
31 maxOccurs="unbounded" />
32  
33       </xs:sequence>
34     </xs:complexType>
35  
36     <xs:element name="createNewAdReques
37       <xs:complexType>
38         <xs:sequence>
39           <xs:element type="xs:string"
40  
41           <xs:element type="xs:string"
42         </xs:sequence>
43       </xs:complexType>
44     </xs:element>
45  
46     <xs:element name="createNewAdRespon
47  
48       <xs:complexType>
49         <xs:sequence>
50           <xs:element type="xs:int" nam
51         </xs:sequence>
52       </xs:complexType>
53  
54     </xs:element>
55  
56     <xs:element name="editExistingAdReq
57       <xs:complexType>
58         <xs:sequence>
59           <xs:element type="ns1:Classif
60 name="existingAd" />
61  
62         </xs:sequence>
63       </xs:complexType>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 48/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

64     </xs:element>
65  
66     <xs:element name="editExistingAdRes
67       <xs:complexType>
68         <xs:sequence>
69  
70           <xs:element type="xs:boolean"
71 wasSuccessful"/>
72         </xs:sequence>
73       </xs:complexType>
74     </xs:element>
75  
76     <xs:element name="getExistingAdsReq
77  
78       <xs:complexType />
79     </xs:element>
80  
81     <xs:element name="getExistingAdsRes
82       <xs:complexType>
83         <xs:sequence>
84           <xs:element type="ns1:Classif
85 name="ClassifiedList" />
86  
87         </xs:sequence>
88       </xs:complexType>
89     </xs:element>
90  
91     <xs:element name="finalizeIssueRequ
92       <xs:complexType>
93         <xs:sequence>
94  
95           <xs:element type="xs:string"
96  />
97         </xs:sequence>
98       </xs:complexType>
99     </xs:element>
100  
101   </xs:schema>
102  
103 </wsdl:types>
104  
105 <wsdl:message name="createNewAdRequestM
106   <wsdl:part name="part1" element="ns1:
107 </wsdl:message>
108  
109 <wsdl:message name="createNewAdResponse
110   <wsdl:part name="part1" element="ns1:
111  
112 </wsdl:message>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 49/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

113  
114 <wsdl:message name="getExistingAdsRespo
115   <wsdl:part name="part1" element="ns1:
116 </wsdl:message>
117  
118 <wsdl:message name="editExistingAdReque
119   <wsdl:part name="part1" element="ns1:
120 </wsdl:message>
121  
122 <wsdl:message name="getExistingAdsReque
123   <wsdl:part name="part1" element="ns1:
124 </wsdl:message>
125  
126 <wsdl:message name="editExistingAdRespo
127   <wsdl:part name="part1" element="ns1:
128 </wsdl:message>
129  
130 <wsdl:message name="finalizeIssueReques
131   <wsdl:part name="part1" element="ns1:
132 </wsdl:message>
133  
134 <wsdl:portType name="ClassifiedServiceP
135  
136   <wsdl:operation name="finalizeIssue">
137     <wsdl:input message="tns:finalizeIs
138  
139   </wsdl:operation>
140  
141   <wsdl:operation name="createNewAd">
142     <wsdl:input message="tns:createNewA
143     <wsdl:output message="tns:createNew
144   </wsdl:operation>
145  
146   <wsdl:operation name="editExistingAd"
147     <wsdl:input message="tns:editExisti
148     <wsdl:output message="tns:editExist
149   </wsdl:operation>
150  
151   <wsdl:operation name="getExistingAds"
152     <wsdl:input message="tns:getExistin
153  
154     <wsdl:output message="tns:getExisti
155   </wsdl:operation>
156  
157 </wsdl:portType>
158  
159 <wsdl:binding name="ClassifiedServiceBi
160  type="tns:ClassifiedServicePortType">
161  
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 50/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

162   <soap:binding transport="http://schem

163  style="document" />
164  
165   <wsdl:operation name="createNewAd">
166     <soap:operation soapAction="createN
167     <wsdl:input>
168       <soap:body use="literal"
169                  namespace="http://dail
170     </wsdl:input>
171     <wsdl:output>
172  
173       <soap:body use="literal"
174                  namespace="http://dail
175     </wsdl:output>
176   </wsdl:operation>
177  
178   <wsdl:operation name="finalizeIssue">
179     <soap:operation soapAction="finaliz
180     <wsdl:input>
181  
182       <soap:body use="literal"
183                   namespace="http://dai
184     </wsdl:input>
185   </wsdl:operation>
186  
187   <wsdl:operation name="editExistingAd"
188     <soap:operation soapAction="editExi
189     <wsdl:input>
190  
191       <soap:body use="literal"
192                    namespace="http://da
193     </wsdl:input>
194     <wsdl:output>
195       <soap:body use="literal"
196                    namespace="http://da
197     </wsdl:output>
198   </wsdl:operation>
199  
200   <wsdl:operation name="getExistingAds"
201     <soap:operation soapAction="getExis
202     <wsdl:input>
203       <soap:body use="literal"
204                    namespace="http://da
205     </wsdl:input>
206     <wsdl:output>
207  
208       <soap:body use="literal"
209                    namespace="http://da
210     </wsdl:output>
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 51/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

211   </wsdl:operation>
212  
213 </wsdl:binding>
214  
215 <wsdl:service name="ClassifiedService">
216   <wsdl:port name="ClassifiedServicePor
217                             
218  binding="tns:ClassifiedServiceBinding"
219  
220     <soap:address location=
221          "http://127.0.0.1:8080/axis2/s
222   </wsdl:port>
223 </wsdl:service>
224  
225 </wsdl:definitions>

Muchos de estos cambios se realizan por una cuestión de conveniencia y también de utilidad,
es mucho más fácil recordar "content" que "param0". Dos de estos cambios --el espacio de
nombres que aparece en la parte superior y el prefijo de espacio de nombres en la parte
inferior-- se deben a pequeños errores en el proceso de generación que existen en Axis2
versión 0.95 y tal vez al momento de leer esto ya no sean necesarios.

Generación del servicio a desde el WSDL

Una vez que ya existe el archivo WSDL, Francis puede usarlo para generar el servicio y el
cliente. (En realidad, Francis podría haber usado fácilmente la versión generada por Larry.)

Francis comienza por generar el código del lado del servidor, como se muestra en el Listado 40:

Listado 40. El código del lado del servidor

1 java org.apache.axis2.wsdl.WSDL2Java -uri

2 -ss -sd -p org.dailymoon.classifieds -d x

(Nuevamente, ingrese este comando en una sola línea.)

El primer parámetro es la URL para el archivo WSDL. Sí, usted puede acceder a un archivo
remoto usando esta aplicación. El segundo switch, -ss, le pide a la aplicación que genere el
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 52/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

servicio y no el cliente. El switch -sd le indica a la aplicación que genere el descriptor de

servicio XML, facilitando la implantación del servicio una vez que ha sido generado. El próximo
parámetro es, obviamente, el paquete, seguido por el método de enlace de datos. Los métodos
disponibles son adb, xmlbeans y jaxme. Por último, para dejar las cosas ordenadas, Francis
genera el servicio en un nuevo directorio llamado fuente.

Esto implica literalmente cientos de archivos. Afortunadamente, usted sólo necesita manejarse
con uno de ellos.

Implementación del servicio

Aunque en este caso el servicio fue generado por un archivo WSDL que a su vez fue generado
a partir de una clase Java, no hay una lógica real en el código generado, sólo aparece la
estructura. Para lograr que el servicio haga realmente algo, usted debe editar el archivo del
esqueleto.

En esta estructura, el archivo en cuestión se muestra en el Listado 41:

Listado 41. Archivo generado a partir de una clase Java

1 service\src\org\dailymoon\classifieds\Cla
2 java

El código tiene un comentario extenso que puede ser útil cuando trata de descifrarlo para usted
mismo, pero puede distraer mucho al intentar explicarlo. Aquí se transcribe la versión limpia
junto con el código agregado para implementar parte del servicio (ver Listado 42).

Listado 42. ClassifiedServicePortTypeSkeleton.java

1 package org.dailymoon.classifieds;
2  
3 public class ClassifiedServicePortTypeSk
4  
5    public  axis2.apache.org.xsd.CreateNe
6                                         
7       (axis2.apache.org.xsd.CreateNewAdR
8                                         
9  
10       //Todo fill this with the necessar

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 53/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

11       //throw new  java.lang.Unsupported

12  
13       System.out.println("New ad request
14                   param0.getCreateNewAdR
15       System.out.println(
16                   param0.getCreateNewAdR
17  
18       axis2.apache.org.xsd.CreateNewAdRe
19                                         
20           axis2.apache.org.xsd.CreateNew
21                                         
22  
23       axis2.apache.org.xsd.CreateNewAdRe
24                                .CreateNe
25                         responseDoc.addN
26  
27       response.setNewAdId(1138);
28       return responseDoc;
29  
30    }
31       
32    public  void finalizeIssue
33            (axis2.apache.org.xsd.Finaliz
34                                         
35  
36         //Todo fill this with the necess
37                  
38    }
39       
40    public  axis2.apache.org.xsd.EditExis
41                                         
42         (axis2.apache.org.xsd.EditExisti
43                                         
44  
45       //Todo fill this with the necessar
46       throw new  java.lang.UnsupportedOp
47  
48    }
49       
50    public  axis2.apache.org.xsd.GetExist
51                                         
52         (axis2.apache.org.xsd.GetExistin
53                                         
54  
55       //Todo fill this with the necessar
56       throw new  java.lang.UnsupportedOp
57  
58    }
59       
https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 54/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

60 }

Cada método se inicia arrojando un parámetro UnsupportedOperationException, hasta que

usted realmente implementa el método. Para acceder a los datos enviados al servicio,
comience con el parámetro y obtenga la solicitud propiamente dicha. A partir de allí, podrá
extraer miembros individuales usando métodos captadores.

Obviamente, en un servicio real, usted querrá hacer algo más que simplemente texto de datos
de salida, pero Francis sólo está interesada en comprobar que esté funcionando. Para crear la
respuesta, comience con el documento de respuesta apropiado, adquiriendo una instancia a
través del parámetro Factory de la clase. (Las clases propiamente dichas son bastante
complejas, contienen una cantidad de clases internas, pero conviene ver cómo están
estructuradas). Una vez que tenga el documento, cree la respuesta real propiamente dicha y
agréguela a ese documento.

Usando métodos establecedores, usted puede configurar directamente valores en la respuesta.

Simplemente la devolución del documento de respuesta y las clases de soporte se ocuparán de
volverlo a enviar al solicitante.

Implantación del servicio

Para implantar el servicio necesitará compilarlo y convertirlo en un archivo Axis2. Comience por
compilar y empaquetar el servicio, como se muestra en el Listado 43.

Listado 43. Empaquetado del servicio

1 set ANT_HOME=e:\apache-ant-1.6.5
2 PATH=%PATH%;%ANT_HOME%\bin;
3 set AXIS2_HOME=e:\axis2
4 cd service
5 ant jar.service

Ajuste adecuadamente su sintaxis para instalaciones que no sean con Windows y asegúrese
de usar sus ubicaciones de archivos reales.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 55/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Este trabajo de Ant compila todos los archivos apropiados y crea dos archivos,
ClassifiedService.aar y XBeans-packaged.jar, ambos en el directorio build/lib.

Para implantar el servicio, asegúrese que Geronimo esté ejecutándose y señale su navegador
como se muestra en el Listado 44:

Listado 44. Implantación del servicio

1 java org.apache.axis2.wsdl.WSDL2Java -uri

2  org.dailymoon.classifieds -d xmlbeans -o

Inicie sesión con las credenciales admin/axis2 y haga clic en Upload Service (Cargar
servicio)>Browse (Navegar). Navegue hasta el archivo ClassifiedService.aar y haga clic en
OK (Aceptar). Haga clic en Upload (Cargar) para completar el proceso.

Si hace clic en View Services (Ver servicios), debería ver el nuevo servicio en la lista.

Generación del stub de cliente desde WSDL

Ahora sólo falta generar el cliente para acceder al nuevo servicio. Para hacer esto, ejecute el
siguiente comando desde la línea de comandos:

Listado 45. Comando para generar el cliente

1 java org.apache.axis2.wsdl.WSDL2Java -uri

2  org.dailymoon.classifieds -d xmlbeans -o

Como siempre, éste es un comando único, destinado a una sola línea. Los parámetros son
virtualmente idénticos a aquellos usados para la generación del lado del servidor, excepto que
usted no necesita un descriptor de servicio. Además, para mantener las cosas en orden,
Francis pone los archivos nuevos en un directorio, cliente, separado.

Esta clase debería ejecutarse tranquilamente, dejando cientos de archivos a su paso, pero
usted no necesita ocuparse de ninguno de ellos directamente.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 56/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Creación del cliente

El proceso de generación de código en realidad no crea un cliente, sino una clase que usted
puede usar fácilmente para crear un cliente. Para simplificar la compilación, Francies crea un
archivo de clase nueva llamado Client.java en el directorio client\src\org\dailymoon\classifieds.
De esta manera, Ant tomará el archivo .java y lo compilará con el resto de la fuente.

Francis agrega el código en el Listado 46.

Listado 46. El cliente

1 package org.dailymoon.classifieds;
2  
3 import axis2.apache.org.xsd.*;
4  
5 public class Client{
6  
7    public static void main(java.lang.Str
8  
9       try{
10          ClassifiedServicePortTypeStub s
11               new ClassifiedServicePortT
12      "http://localhost:8080/axis2/servic
13              
14          CreateNewAdRequestDocument cnaD
15                CreateNewAdRequestDocumen
16  
17          CreateNewAdRequestDocument.Crea
18                               cnaDoc.add
19          cnaReq.setContent("Vintage 1963
20          cnaReq.setEndDate("7/4/06");
21  
22          CreateNewAdResponseDocument cna
23                                        s
24          System.out.println("New ad ID n
25                 cnaResDoc.getCreateNewAd
26  
27       } catch(Exception e){
28          e.printStackTrace();
29       }
30    }
31 }

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 57/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

La clase ClassifiedServicePortTypeStubrepresenta el servicio real y usted lo inicia con el

atributo AXIS_HOME (aquí a la izquierda del valor predeterminado) y con la ubicación del
servicio real. Luego, cree el documento de solicitud, una vez más haciendo referencia a
su Factory, y úselo para crear una nueva solicitud CreateNewAdRequest, agregándola al
documento de solicitudes en el proceso. Así como en el servicio propiamente dicho, luego
puede establecer atributos directamente usando métodos establecedores.

Para obtener la respuesta, use el stub para ejecutar el método createNewAd(), pasándolo al
documento de solicitudes como un parámetro. Una vez que tenga el documento de respuestas,
o mejor dicho el parámetro CreateNewAtResponseDocument, puede usarlo para extraer la
respuesta propiamente dicha y el atributo de esa respuesta.

Ahora ejecutémoslo.

Ejecución del cliente

Para ejecutar un cliente, Francis primero necesita compilarlo. Ejecute los siguientes pasos (ver
Listado 47).

Listado 47. Compilación de cliente

1 >>set ANT_HOME=e:\apache-ant-1.6.5
2 >>PATH=%PATH%;%ANT_HOME%\bin;
3 >>set AXIS2_HOME=e:\axis2
4 >>cd client
5 >>ant jar.client
6 Buildfile: build.xml
7  
8 init:
9  
10 pre.compile.test:
11      [echo] Stax Availability= true
12      [echo] Axis2 Availability= true
13  
14 compile.src:
15  
16 compile.test:
17  
18 jar.client:
19  
20 BUILD SUCCESSFUL
21 Total time: 2 seconds

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 58/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Primero, asegúrese que el entorno tenga las variables apropiadas. (Esto supone que usted ya
agregó todos los archivos JAR de AXIS2_HOME\lib). Luego, cambie al directorio de cliente (o
cualquier directorio que use los datos de salida para el proceso de generación) y ejecute Ant
contra el jar.client de destino. Debería ver resultados similares a los que se muestran en cursiva
(ver Listado 47). Para ejecutar el cliente, primero corrija CLASSPATH para que incluya el
directorio de los recursos y el directorio que alberga todas las clases creadas por el proceso de
enlace de datos (ver Listado 48).

Listado 48. Ejecución del cliente

1 >>set CLASSPATH=E:\WSDLFiles\client\resou
2 ld\classes\axis2\apache\org\xsd\;%CLASSPA
3 >>cd build\classes
4 >>java org.dailymoon.classifieds.Client

Debería ver resultados similares a los que se muestran en el Listado 49:

Listado 49. Número de ID del aviso nuevo

1 Nuevo de ID del aviso nuevo: 1138

Bueno, esto es todo.

Resumen
En la Parte 1 de esta serie, el Departamento de Avisos Clasificados del periódico Daily Moon
aprendió cómo usar los servicios web SOAP para conectarse con el Sistema de Gestión de
Contenidos del periódico. En este tutorial, el personal aprendió a usar Web Services
Description Language (WSDL) para describir sus propios servicios de manera tal que otros
pudieran usarlo. El tutorial cubrió los conceptos básicos del esquema XML, sumado a la
estructura de un archivo WSDL para que se lo pueda construir manualmente. También
describió las diferencias entre los distintos estilos y codificaciones disponibles. El tutorial
también explicó cómo usar las herramientas Java2WSDL y WSDL2Java que vienen con
Apache Axis2 para generar automáticamente WSDL a partir de archivos Java files y viceversa.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 59/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

La Parte 3 de esta serie se abocará a analizar la construcción de registros de servicios web

usando UDDI.

Recursos para Descargar

PDF de este contenido

Sample Perl scripts (ws-understand-web-services2-WSDL.zip | 300KB)

Temas relacionados

En la Parte 1 de esta serie, Understanding web Services specifications, Part 1: SOAP

(Comprender las especificaciones de servicios web, Parte 1: SOAP) aprenderá más sobre
los servicios web en general y sobre los servicios web SOAP en particular.
Acceda a la especificación de WSDL 1.1.
La recomendación WSDL 2.0 (Candidato) consta de tres documentos: Parte 0: Primer
nivel, Parte 1: Lenguaje principal y Part 2: Adjuntos. También puede indicar dos documentos
relacionados, SOAP 1.1 Binding y RDF Mapping.
Marque el sitio Web Apache Axis2 para acceder a vínculos relacionados con la
documentación específica de su versión.
El sitio Web Apache Geronimo ofrece detalles sobre Apache Geronimo, el proyecto de
servidor J2EE de Apache Software Foundation.
Which style of WSDL should I use? [¿Qué estilo de WSDL debo usar?] es un artículo
excelente que explica la diferencia entre documento y RPC; y codificado y literal, también
incluye las ventajas y desventajas de cada uno.
Supercharging WSDL with RDF [Sobrealimentar WSDL con RDF] explica cómo aprovechar
al máximo a WSDL mediante la incorporación de Marco de Descripción de Recursos (RDF),
el formato oficial del Consorcio World Wide Web (W3C) para definir los metadatos de
objetos XML.
Puede agregar más potencia y flexibilidad a su WSDL importando e incluyendo datos, pero
esto puede ser complicado. Web services Programming Tips and Tricks: WSDL file imports
[Consejos y recursos útiles para la programación de servicios web: importaciones de
archivos WSDL] explica cómo hacerlo correctamente.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 60/61
13/2/2019 Comprender los servicios web, Parte 2: Web Services Description Language (WSDL)

Processing WSDL documents with XSLT [Procesamiento de documentos WSDL con

XSLT] presenta los enfoques que se pueden usar para comprender profundamente los
documentos WSDL en una hoja de estilo XSL así como los errores comunes que se deben
evitar.
En la zona developerWorks Open Source puede aprender todo sobre Apache Geronimo.
Obtenga Apache Geronimo.
Obtenga Apache Axis2. Este tutorial usa la versión 0.95, pero las versiones posteriores
deberían funcionar.
Obtenga J2SE SDK.
Obtenga Apache Ant.

https://www.ibm.com/developerworks/ssa/webservices/tutorials/ws-understand-web-services2/index.html 61/61