Servicios Web con Java SE 6.0

Servicios Web con JAX-WS sin contenedores Java EE

Por Willy Mejía.
Publicado: Octubre 2007
Modificado: Diciembre 2007.

En Java SE 6.0 se incluye JAX-WS (Java API for XML Web Services). El siguiente cuadro muestra las APIs disponibles en Java SE 6.0 y sus paquetes correspondientes.

Paquete	API
javax.xml.ws	Núcleo del API JAX-WS
javax.xml.soap	API para crear y construir mensajes SOAP
javax.jws	Metadatos para la construcción de Servicios Web

La justificación para la inclusión de JAX-WS 2.0 como parte de Java SE 6.0 en lugar de en Java EE 5, es que la entrega de Servicios Web con JAX WS 2.0 no requiere de un contenedor de Servlet o EJB. Esto prácticamente vuelve a HTTP un protocolo intrínseco más para el cómputo distribuido en la plataforma Java, además que extiende el alcance de los Servicios Web.

El presente artículo muestra cómo utilizar las clases y herramientas de JAX-WS incluidas en Java SE 6.0 para crear y publicar un sencillo Servicio Web así como su cliente.

Nota: Para una breve introducción a los Servicios Web puede leer: Guía Breve de Servicios Web.

Creando un Servicio Web muy simple

Para ilustrar la creación de Servicio Web con JAX-WS 2.0 emplearemos el clásico ejemplo de Hola Mundo el cual luce así:

Listado de Hello.java

package hello;
import javax.jws.WebService;

@WebService
public class Hello {
    private String message = new String("Hola ");
    public String sayHello(String name) {
    	String msg = message + name + ".";
        System.out.println(msg);
        return msg; 
    } 
}

Nótese que luce como una clase Java normal pero con un par de adiciones: En primer lugar importamos javax.jws.WebService, lo cual es necesario para marcar la clase Hello con la anotación @WebService. Con esto habilitamos la clase para que pueda ser publicada como un Servicio Web, en éste caso con solo una operación, la del método sayHello.

El siguiente paso es generar los artefactos de despliegue para dicha clase, para ello utilizamos la herramienta wsgen, incluida en Java SE 6.0, a la cual le pasamos como argumento la clase hello.Hello compilada:

>javac hello/Hello.java

>wsgen -cp . hello.Hello

Con todo lo anterior ya tenemos un sencillo Servicio Web casi listo para ser desplegado en algún contenedor Java EE, no obstante podemos probarlo sin un contenedor si creamos un Endpoint dentro de una aplicación que actuará como host del servicio web, tal como se ilustra en el siguiente código:

Listado de SimpleHelloWS.java

import javax.xml.ws.Endpoint;
import hello.Hello;

public class SimpleHelloWS {
  public static void main(String[] args) {    	
    String endpointAddress = "http://localhost:8080/hello";
    Endpoint.publish(endpointAddress, new hello.Hello());
    System.out.println("El Servicio Web Hello se esta ejecutando...");     
    System.out.println("WSDL: " + endpointAddress + "?wsdl");
  }
}

Nótese que se trata de una simple aplicación de consola que utiliza el método publish de la clase javax.xml.ws.Endpoint para crear y publicar un Endpoint para una instancia de la clase hello.Hello en la dirección http://localhost:8080/hello. Esto último gracias a que la clase Endpoint utiliza el servidor web “liviano” de Sun que está incluido en Java SE dentro del paquete com.sun.net.httpserver.

Tras compilar y ejecutar la aplicación se mostraran dos líneas indicando que el servicio se está ejecutando y que la ubicación del «contrato del servicio», es decir el documento WSDL del mismo, para cualquier cliente que desee acceder al mismo.

>javac SimpleHelloWS.java

>java SimpleHelloWS

El Servicio Web Hello se esta ejecutando...
WSDL: http://localhost:8080/hello?wsdl

Por lo que ahora sigue crear un cliente que lo consuma.

Creando un Cliente muy simple para un Servicio Web muy simple

Ahora crearemos —en un directorio/proyecto distinto— el cliente para nuestro Servicio Web el cual debe estar publicado y en ejecución.

Pero primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta wsimport incluida en Java SE 6.0, a la cual le pasamos como argumento la ubicación del contrato del servicio, es decir el documento WSDL:

>wsimport http://localhost:8080/hello?wsdl

Esto generará las clases que encapsulan las operaciones para la invocación de los métodos del Servicio Web. En nuestro caso se generarán seis clases dentro del paquete ‘hello’, entre ellas estan las clases hello.HelloService y hello.Hello que utilizaremos directamente en nuestro cliente.

Una vez generados los artefactos cliente solo resta crear el cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.java

public class Client {    
  public static void main(String[] args) {    	
    String arg = null;
    String result = null;        
    if (args.length > 0) {
      arg = args[0];
    } 
    else {
      arg = "Anonimo";
    }
    try {              
      hello.HelloService service = new hello.HelloService();
      hello.Hello port = service.getHelloPort();
      result = port.sayHello(arg);
    } 
    catch (Exception ex) {
      result = ex.toString();
    }
    finally{
      System.out.println(result);
    }
  }
}

Nótese que para invocar la operación de nuestro Servicio Web primero creamos el localizador del servicio (con HelloService) y mediante éste obtenemos un puerto (de tipo Hello) por medio del cual después invocamos al método sayHello —tras del cual se invoca la operación del Servicio Web el cual a su vez invoca el método de la clase Hello implementada al inicio del artículo…

Solo resta compilar y ejecutar nuestro cliente con algún argumento, su nombre por ejemplo, si no se especifica un argumento la salida será «Hola Anónimo»:

>javac Client.java

>java Client Yo
Hola Yo.

La misma salida se desplegará en la consola del servicio.

Epílogo

Con todo lo que hemos realizado vemos lo fácil que es crear y publicar un Servicio Web así como su cliente con los paquetes y herramientas de JAX-WS incluidos en Java SE 6.0. Y aunque para un despliegue en producción no podremos prescindir de los contenedores Java EE (Tomcat, Glassfish, JBoss etc…) para los fines de desarrollo de prototipos o durante las primeras fases —así como en proyectos escolares— es suficiente con lo incluido en Java SE 6.0.

No obstante todo esto tan sólo fue el inicio, la finalidad fue dar una introducción al desarrollo de Servicios Web utilizando JAX-WS esperando le motive a continuar para después «abordar el Metro». Quedan entonces muchas cosas por tratar, como la automatización de las tareas que realizamos, crear un servicio y cliente a partir de un WSDL, el despliegue en contenedores Java EE, utilizar contratos de datos y JAXB, utilización de JAXP, StAX y SAAJ, interoperabilidad y WS-* con WSIT, etc. Ya ni se diga de explorar otras opciones para el desarrollo de WS en Java como CXF, Axis2, etc…

Espero que sirva de algo y hasta la próxima,
Willy Mejía.

 

Anexo A: Consumiendo el Servicio desde WCF

Para llevarlo a cabo se requiere tener instalado el .NET Framework 3.0 ó bien 3.5 —los cuales a su vez requieren del .NET Framework 2.0— con su correspondiente SDK.

Primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta svcutil (Herramienta de utilidad de metadatos de ServiceModel) incluida en el Windows SDK for .NET Framework 3.x, a la cual le pasamos como argumento la ubicación del documento WSDL:

>svcutil http://localhost:8080/hello?wsdl /out:Hello.cs /config:Client.exe.config /n:http://hello/,hello

Esto generará un archivo con la clases proxy las cuales encapsularán la invocación de las operaciones del Servicios Web. En nuestro caso se generará el archivo Hello.cs (con la clase HelloClient que utilizaremos directamente en la aplicación cliente) así como el archivo de configuración Client.exe.config, que coincide con el nombre del ejecutable de la aplicación cliente.

Una vez generados los artefactos cliente (proxy) solo resta crear la aplicación cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    string arg = null;
    string result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = “Anónimo”;
    }
    try {
      hello.HelloClient service = new hello.HelloClient();
      result = service.sayHello(arg);
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Solo resta compilar tanto el proxy como la aplicación cliente:

>csc /t:library Hello.cs

>csc /t:exe Client.cs /r:Hello.dll

Después ejecute la aplicación cliente con algún argumento:

>Client WCF

Hola WCF.

La misma salida se desplegará en la consola del servicio.

 

Anexo B: Consumiendo el Servicio desde PHP5

Para llevarlo a cabo se requiere tener instalado PHP5 con SOAP habilitado.

PHP5 trae consigo algunas funciones SOAP intrísecas, de las cuales utilizaremos SoapClient para consumir nuestro Servicio Web. A ésta función le pasaremos como argumento la ubicación del documento WSDL, no obstante el mismo debe ser local —en teoría podría ser remoto, pero existen algunos problemas…

Primero debemos descargar y guardar una copia del documento WDSL del Servicio Web junto con cualquier otro documento anexo (WSDL o XSD). En nuestro caso el WSDL: http://localhost:8080/hello?wsdl lo guardamos como hello.wsdl, el cual tiene un XSD adjunto que se puede ver en el WSDL como:

<xsd:import namespace="http://hello/" schemaLocation="http://localhost:8080/hello?xsd=1" />

Por lo que guardamos http://localhost:8080/hello?xsd=1 como hello.xsd. Después editamos la misma línea en nuestro WSDL local (hello.wsdl) de modo que refleje la ubicación de nuestro XSD local (hello.xsd):

<xsd:import namespace="http://hello/" schemaLocation="hello.xsd" />

Así mismo si la ubicación del host del servicio radica en localhost, como es nuestro caso, es preferible cambiarla por la dirección IP: 127.0.0.1, de modo que editamos la línea correspondiente en el WSDL para que quede de la siguiente manera:

<soap:address location="http://127.0.0.1:8080/hello" />

Una vez alojados los documentos en el mismo directorio donde estará nuestro script php (client.php) solo queda escribir el mismo:

Listado de client.php

<?php 
ini_set("soap.wsdl_cache_enabled", "0");
$client = new SoapClient("hello.wsdl");
try {
  $request->arg0 = "PHP5";
  $response = $client->sayHello($request);
  print $response->return . "\n";
} catch (SoapFault $exception) { 
  echo $exception; 
} 
?>

Tome en cuenta que el nombre de los elementos arg0 y return los tomamos de la definición de los tipos utilizados por el servicio, la cual encontramos en hello.xsd.

Solo resta ejecutar el script desde la línea de comandos o con ayuda de algún servidor web previamente configurado:

>php -f "client.php"

>Hola PHP5.

La misma salida se desplegará en la consola del servicio.