How-to: Crear un Servicio Web JAX-RPC con IBM Websphere Integration Developer

Una nueva sección en el blog! Dejamos temporalmente la retórica académica para bajar al llano. En esta primera entrega trataremos de dejar funcionando un servicio web en un servidos IBM Websphere Application Server (a partir de ahora WAS), haciendo uso del IBM Websphere Integration Developer (a partir de ahora WID) para facilitarnos las cosas. Dicho esto, empezamos:

Existen dos "enfoques" en la creación de Servicios Web: Con el enfoque ascendente, comenzamos con la construcción de las clases java y es base a estas clases que la herramienta nos genera la interfaz WSDL del servicio web. Si es que conoces mucho Java y poco XML, esta es tu opción. Por otro lado, en el enfoque descendente empezamos por definir la interfaz WSDL y es en base a este documento que la herramienta nos genera las clases Java en las que incluiremos la funcionalidad que necesitamos. Si es que te llevas bien con XML, este debe ser tu enfoque. Personalmente no es mi caso, pero es lo que utilizaremos en este tutorial xD.

El primer paso es definir una biblioteca donde crearemos nuestro documento WSDL y demás artefactos XML que podamos requerir. Vamos a File->New->Library, y le ponemos un nombre bonito a nuestra biblioteca :

Con la biblioteca creada, podemos empezar la construcción de nuestra interfaz WSDL. Uno de los puntos fuertes del WID es que puedes crear este documento siendo un total analfabeto de XML. Lógicamente ese no es nuestro caso, pero definir el WSDL mediante Wizards es más rápido y menos propenso a errores (además, XML no es de mis tópicos favoritos xD).

Entonces, comencemos con esto. Un servicio Web ofrece una serie de operaciones a sus clientes, y cada una de estas operaciones tiene parámetros de entrada y de salida. Empezaremos definiendo la estructura de nuestros parámetros de entrada, mediante Business Objects del WID. Clic derecho en nuestra biblioteca->new->Business Object. Le ponemos un nombre a nuestro objeto de negocio, y si queremos le asignamos una carpeta en la biblioteca:

El Business Object que hemos definido nos servirá para encapsular los parámetros de entrada que necesitará una de las operaciones de nuestro servicio web. Mediante el WID, asignamos como campos del Business Object la información que necesitamos como entrada a nuestra operación (Y hasta ahora, no hemos visto una sóla línea de XML) :

El WID nos permite definir el tipo de dato de cada campo, así como el número de ocurrencias y otras cosillas más. Pero, ¿que está haciendo el WID tras bambalinas? Pues toma la información que le entregamos y convierte nuesto colorido diagrama en una definición de esquema XML. Si no me creen, hagan clic derecho en el Business Object ->Open With->Text Editor para que puedan verlo con sus propios ojos:

Una definición de esquema XML puede ser utilizada para definir tipos en un documento WSDL, pero eso ya lo veremos luego xD. Ahora, es necesario crear otro Business Object que represente el resultado de la operación que definiremos luego. Procedemos de manera similar que con nuestro parámetro de entrada:

Ahora tenemos también una definición de esquema XML para los resultados de nuestra operación. Por si acaso, las definiciones de esquema XML son un estándar independiente y bastante complejo: soporta herencia, tipos compuestos y agrupaciones de diversa índole que pueden transformar nuestro modesto diagramita de un Business Object en algo mucho más monstruoso. Para efectos de simplicidad y compatibilidad se recomienda mantener nuestros esquemas sencillos, en el desarrollo de web service las incompatibilidades ("Mi cliente no soporta eso que está usando tu servicio") son pan de cada día.

Tenemos definidos los parámetros, el resultado, ahora estamos listos para la interfaz. Clic derecho en la biblioteca->New->Interface. Le colocamos un nombre y le asignamos una carpeta:

Tenemos ya la interfaz de nuestro servicio web, y necesitamos agregarle las operaciones que va a soportar. Definimos una operación de solicitud-respuesta (la otra opción son las operaciones de una vía, donde el cliente no espera una respuesta del servicio), le asignamos un nombre y asignamos como tipos de entrada y de salida instancias de los esquemas XML que hemos definido en los pasos anteriores. Deberían ver algo así:

Una vez más, es momento de la pregunta:¿Y qué está haciendo en realidad el WID? Pues está construyendo un documento WSDL para nosotros, haciendo referencia a los esquemas XML que definimos anteriormente. Para los incrédulos, pueden hacer clic derecho en la interfaz->Open with text editor:

Como ven, tenemos un WSDL convencional con elementos "import" que hacen referencia a los esquemas XML que ya teníamos. Pero,si ya han visto un WSDL antes, se habrán dado cuenta que le faltan dos cosas importantes: el elemento service y el elemento binding. Para terminar nuestro WSDL, necesitamos crear un Módulo de Mediación en WID. Seleccionamos File->New->Mediation Module. Le ponemos un nombre, seleccionamos Next y hacemos referencia a la biblioteca (Library) que habíamos creado antes:

El WID nos muestra un diagrama de ensamblado con un solitario Flujo de Mediación al medio. Es momento de agregarle a ese Flujo una interfaz, que es el WSDL a medias que tenemos en nuestra biblioteca: Clic al Export->Add Interface y ya:

Ahora que nuestro Flujo de Mediación tiene ya una interfaz, podemos generar el Export. Clic derecho en el Export->Generate Export, y predeciblemente seleccionamos "Web Service Binding". Escogemos SOAP como estándar de mensajería y HTTP como medio de transporte. Terminado esto, se observa que ha aparecido un nuevo elemento en nuestra biblioteca, bajo la categoría de Web Service Port: ese es nuestro WSDL completito. Vamos a echarle un ojo dándole clic derecho->open with->XML Editor. Lo primero que salta a la vista es que mediante un elemento import hace referencia al WSDL incompleto que creamos al inicio. También notamos que ya se han incluido los elementos binding y service, y que aún no hemos redactado una línea de XML :D

Con esto damos por terminado el tema de WSDL, para construir la aplicación Java que hará todo lo que nuestra interfaz dice (en teoría xD). Primero, necesitamos una aplicación Web Dinámica: Seleccionamos File->New->Other->Dynamic Web Project. Le ponemos un nombre al proyecto, un nombre al EAR que la contendrá y sobretodo seleccionamos donde pensamos desplegar nuestra aplicación. En nuesto caso, optamos por nuestro viejo y fiel WAS 6:

*

Y el WID generosamente nos proporciona la estructura básica de una aplicación Web en Java. Ahora se viene lo bueno: clic derecho en el proyecto Web->New->Other-> Web Service para configurar lo que será nuestro servicio Web. Lo primero es el tipo de Servicio Web, para esto JAX-RPC (que es la tecnología que usaremos) nos da dos alternativas: usar un Java Bean como Endpoint o un EJB. Por simplicidad usamos el primero, y como ya tenemos nuestro WSDL preparado el desarrollo va a ser Descedente. Por lo expuesto, seleccionamos "Top Down Java Bean Web Service". Al tratarse de un desarrollo descendente seleccionamos el WSDL que teníamos preparado, y le indicamos una vez más que desplegaremos en un WAS.

Seleccionamos siguiente. El WID nos muestra una casilla, que nos permite asociarle un paquete específico a un namespace determinado (caso contrario WID creará los paquetes, y no lo hace con estilo xD). Obviamos este paso, seleccionamos Finish y el WID se encargará de generar todo lo necesario para que podamos programar.

Echémoles un ojo a parte de lo mucho que ha generado el WID para nosotros. Observamos la interfaz del Endpoint (llamada también SEI: Service Endpoint Interface) que contiene las operaciones que nuestro cliente puede invocar mediante SOAP (en nuestro caso, sólo una). Como lo establece JAX-RPC, la SEI hereda de jax.rmi.Remote, y todos los métodos declaran la excepción java.rmi.RemoteException. También, el WID nos ha generado la implementación de esta interfaz -también conocida como SIB, Service Implementation Bean- que es donde irá la lógica de implementación del servicio.También está por ahí el descriptor de despliegue del servicio web, y los archivos de mapeo del JAX-RPC, pero por ahora dejémoslo ahí xD.

Ahora, veamos si es que no les he mentido y si es que este servicio funciona. Al momento de generar el servicio web, el WID ha colocado el WSDL y todos los XSD (definiciones de esquemas XML) necesarios dentro de la carpeta WEB-INF/wsdl. Clic derecho al WSDL definitivo-> Web Services-> Test with Web Service Explorer. Esta herramienta también la he visto en Eclipse, y es una forma bastante práctiva de ver si tu servicio funciona o no. Seleccionamos la única operación de nuestro servicio -notar que nos muestra un formulario para el ingreso de parámetros- y le damos Go. Si es que en la parte inferior aparece algo similar a la estructra de respuesta que hemos definido, es que hemos triunfado. Eso sería todo, por lo que declaro terminado el post más largo de la historia de este blog. Hasta otra!!

PS: Un agradecimiento a Carlos Lazo, que fue el que me ilustró en estas lides xD