Java Frameworks & APIs: diciembre 2011

Antes de empezar a ver este tutorial, por favor leer lo siguiente: Web Services - Apache AXIS - Tutorial I

Si tiene dudas respecto a Apache CXF, ver:

Otro tutorial útil para el desarrollo de WS mediante JAX-WS:

1. Veamos un ejemplo paso a paso de como crear un WS y un cliente para consumirlo con CXF y Eclipse Helios

Vamos a descargar las librerías correspondientes a CXF version 2.3.7

Luego vamos a agregar estas librerías en las preferencias del eclipse para que luego, cuando generemos el WS mediante el wizzard sepa de donde obtener las librerias de CXF

Luego, creamos un proyecto web simple (Dynamic Web Project) y creamos la siguiente clase llamada Converter.java

package ws;
import javax.jws.WebService;

public class Converter
{
public float celsiusToFarenheit ( float celsius )
{
return (celsius * 9 / 5) + 32;
}

public float farenheitToCelsius ( float farenheit )
{
return (farenheit - 32) * 5 / 9;
}
}

Una vez creada dicha clase, procedemos a crear el WS sobre esta clase mediante el Wizzard del eclipse. A continuación mostramos las capturas de pantallas que nos guiaran paso a paso en la construcción de este WS:

Aquí tendemos que cambiar de implementacion de WS (Axis por Apache CXF)

Aquí vemos como nos queda modificado la clase Converter.java con ciertas anotaciones que la convierte en WS:

Testeamos el WS mediante la herramienta que nos proporciona el eclipse:

Luego, vemos que también nos ha generado un nuevo proyecto cliente (WS_Prueba_CXFCliente) donde tendremos las clases necesarias para poder consumir dicho WS desde cualquier aplicacion y ademas, nos crea un clase de ejemplo que nos permite consumirlo (procedemos a correr dicha clase):

Luego de ver el resultado por consola (desde la consola de ejecucion de dicha clase de ejemplo), podemos cambiar de consola y ver la del tomcat del WS que esta deployado y asi ver que nos arroja por dicha consola:

Herramienta para el testeo de los WS - SOAPUI

Ver: http://www.dosideas.com/wiki/SoapUI

Ejemplos para descargar

Presionar aquí para descargar los ejemplos vistos anteriormente

JAX-WS 2.0 es la especificación actual de Java para desarrollar web services mediante anotaciones. JAX-WS forma parte del estándar Java EE, conocido antes como J2EE (el cual incluye varias especificaciones de API, tales como JDBC, RMI, e-mail, JMS, Servicios Web, XML, etc)

En la plataforma Java EE, JAX-RPC 2.0 (Java API for XML Based RPC) fue renombrada a JAX-WS 2.0 (Java API for XML Web Services). Este cambio en el nombre demuestra el cambio de estilo de RPC a Documento

Ver: http://finallyigotit.blogspot.com/2009/05/jax-rpc-vs-jax-ws.html

La interface de un Web Service es especificada por el WSDL. El WSDL es un XML que contiene toda la informacion para que el WS sea localizado y pueda ser accedido.

La implementacion de un servicio SOA generalmente es un WS, pero puede no serlo. Por ejemplo, un servicio de mensajería JMS puede ser tranquilamente otra forma de implementar un servicio

Todo servidor de aplicaciones compatible con Java EE 5 implementa una API para web service llamada: JAX-WS la cual define el mapeo entre java y el WSDL. El mapeo entre los objetos Java y el WSDL ( que es un XML ) lo delega en el API JAXB 2.0.

Existen dos maneras de crear los WS

Crear el WSDL y luego, basándonos en el WSDL, creamos el WS (la clase java conocida como endpoint)
Crear la clase java (endpoint) y luego generamos su correspondiente WSDL.

Existen varias implmementaciones para desarrollar WS en Java (algunas de las mas conocidas son):

Axis (http://axis.apache.org/axis/): Soporta JAX-RPC API
Axis2 (http://axis.apache.org/axis2/java/core/): Soporta JAX-WS API
Apache CFX (http://cxf.apache.org/): Soporta JAX-WS API
JBossWS (http://www.jboss.org/jbossws):Soporta JAX-WS API

Como podemos ver, todos estos SOAP engines (implementaciones) menos Axis no están dentro del estándar JAX-WS.

Como para que nos quede un poco mas claro, JAX-WS es para Apache CXF lo que JPA es para Hibernate.

Si no se quiere utilizar ninguna implementacion existente, la JDK trae su propia implementacion para desarrollar WS en Java:

http://chuwiki.chuidiang.org/index.php?title=Ejemplo_sencillo_de_web_service_con_maven_y_jax-ws_metro

La JDK trae para publicarlo directamente pero si lo queres tirar a un tomcat (lo cual seria lo mas prolijo y logico), entonces necesitas el sun-wx.xml, el listener, y tirarle las librerias de JAX-WS al tomcat porque no las tiene.

http://www.mkyong.com/webservices/jax-ws/deploy-jax-ws-web-services-on-tomcat/

Para publicarlo directamente con java: Endpoint.publish(...)

------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------

Si quedan dudas, por favor mirar la documentación original de oracle sobre la JDK 6 que va a aclarar mejor el panorama:

WS: http://docs.oracle.com/javaee/6/tutorial/doc/gijti.html
JAX-WS: http://docs.oracle.com/javaee/6/tutorial/doc/bnayl.html
JAX-RS: http://docs.oracle.com/javaee/6/tutorial/doc/giepu.html

------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------

1. Veamos un ejemplo paso a paso de como crear un WS con AXIS y Eclipse Helios

Antes que nada, vamos a necesitar tener instalado el Eclipse + el plug in de WTP
Descargarlo desde: http://eclipse.org/webtools/ws/
En algunas versiones mas nuevas de Eclipse, esto ya viene por dafault.
En primer lugar, vamos a crear el WS partiendo de una clase Java (A) y luego vamos a generar el WS partiendo de un WSDL (B)

A. Partimos desde un POJO (endpoint) y luego generamos el WSDL

Vamos a crear un servidor, para esto utilizaremos el Tomcat 6

Luego, creamos un Dynamic Web Project

Luego, creamos una clase Java llamada Converter,java con dos metodos

Luego, nos paramos sobre esa clase, y procedemos a crear el WS mediante el Wizzard del Eclipse

Aquí es en donde vamos a poder subir y bajar la barra y seleccionar el web server (Tomcat), el API de WS que vamos a utilizar (por defecto AXIS viene con el Eclipse, por lo que no vamos a tener que descargar nada) y el nombre del Web project que queremos que se despliegue en el Tomcat

Lanzamos el Tomcat, antes de proceder con la canalización de la creacion del WS.

Listo, ya quedo desplegado el WS en el Tomcat, ahora vamos a proceder a verificar la URL del despliegue. Para esto, vamos al WSDL que nos creo este Wizzard, y vamos a buscar la URL

Colocamos dicha URL en el navegador

Colocamos la misca URL en el navegador seguida de "?wsdl". Con esto podemos ver el WSDL generado

Por ultimo, para terminar de verificar el WS, podemos testearlo con una herramienta que nos proporciona el eclipse. Nos paramos sobre el WSDL:

Esto va a abrir una consola dentro del Eclipse, para testear cada uno de los metodos.

Ver: http://www.eclipse.org/webtools/jst/components/ws/1.5/tutorials/BottomUpWebService/BottomUpWebService.html

B. Partimos desde el WSDL para luego generar el POJO (endpoint)

Obtenemos el WSDL anterior o sino vamos a la URL que listamos a continuación y nos bajamos el WSDL (sobre este WSDL se explicara paso a paso este procedimiento "Top Down". El anterior (puntoA) se lo conoce como "Bottom Up".

Ver: http://www.eclipse.org/webtools/jst/components/ws/1.5/tutorials/TopDownWebService/TopDownWebService.html

Creamos una carpeta llamada wsdl y la colocamos dentro de Web Content. Ahi vamos a copiar el WSDL que tengamos (en nuestro caso, vamos a copiar el que nos descargamos de la URL anterior, pero tambien podriamos utilizar el que ya tenemos del Punto A)

Luego, procedemos a crear el web service basandonos en el WSDL, para lo cual vamos a File, new, other, Web Service

En estos momentos, ya tenemos deployado el WS creado a paritir del WSDL, ahora vamos a proceder a corroborar la URL, para lo cual, vamos al WSDL nuevo que nos creo este Wizzard

Agregamos a la URL los siguiente: "?wsdl", y como ya vimos anteriormente, vemos que nos muestra el WSDL.

Ahora vamos a testear este WS mediante la herramienta que trae el eclipse, como ya lo hicimos anteriormente.

2. Veamos un ejemplo paso a paso de como crear un cliente para consumir el WS con ECLIPSE

Creamos un proyecto java simple, en donde vamos a tener un test que consumira el WS antes creado. Para poder consumirlo, vamos a tener que tener levantado el tomcat con el WS deployado.

En este paso, tenemos que seleccionar el WSDL del proyecto que tiene el WS.

Luego, presionamos finish y vemos que nos creara 5 clases que son las que vamos a necesitar para conectarnos con el WS como asi tambien las librerias necesarias:

Converter,java
ConverterProxy,java
ConverterService,java
ConverterServiceLocator,java
ConverterSoapBindingStub,java

axis.jar
commons-discovery-0.2.jar
jaxrpc.jar
saaj.jar
entre otras...

Luego, creamos una clase de test para consumir el WS dentro de este nuevo proyecto cliente.

Una vez que creamos la clase, vamos a agregarle estas lineas de codigo que serviran para consumir el WS e incovar a uno de sus métodos:

public class ConverterTest {

public static void main(String args []) throws ServiceException, RemoteException, MalformedURLException{

// Localizamos y obtenemos el WS
String endpoint = "http://localhost:8080/WS_Prueba/services/Converter";
ConverterServiceLocator loc = new ConverterServiceLocator();
Converter converter = loc.getConverter(new URL(endpoint));

// Invocamos a uno de sus metodos
float farenheitToCelsius = converter.farenheitToCelsius(100f);
System.out.println("farenheitToCelsius " + farenheitToCelsius);

}

}