Comienzo Rápido con Axis2


Servicios Web con Axis2 – Guía de Comienzo Rápido

Compartir

El presente artículo es una traducción de: Axis 2 – Quick Start Guide.
Traducido por: Willy Mejía.
Última modificación: Abril 2008.

NOTAS:

El propósito de esta guía es permitirle comenzar a crear servicios y clientes utilizando Axis2 lo más rápido posible. Tomaremos un servicio simple StockQuote y le mostraremos algunas de las diversas maneras en las cuales puede crearlos y desplegarlos, así como una vista rápida a una o dos herramientas que vienen con Axis2. Entonces veremos la creación de clientes para tener acceso a esos servicios.

Contenido

Una Nota Rápida de Instalación:

El código para el presente documento se puede encontrar tras la extracción de la distribución binaria estándar, específicamente en AXIS2_HOME/samples/ dentro de los directorios: quickstart, quickstartadb, quickstartaxiom, quickstartjibx y quickstartxmlbeans. (Considere
descargarla ahora mismo, pues le ayudará a seguir adelante.) La misma incluye los buildfiles (archivos build.xml) para Ant a los cuales nos referiremos a través de los ejemplos para hacer la compilación más fácil.

Introducción

Comencemos con el servicio en sí mismo. Lo haremos simple de modo que pueda ver lo que se está sucediendo cuando construimos y desplegamos los servicios. Un ejemplo de StockQuoteService parece ser obligatorio en casos como éste, así que utilizaremos la siguiente clase (véase el listado del código 1).

Listado De Código 1: La clase StockQuoteService

package samples.quickstart.service.pojo;

import java.util.HashMap;

public class StockQuoteService {
    private HashMap map = new HashMap();

    public double getPrice(String symbol) {
        Double price = (Double) map.get(symbol);
        if(price != null){
            return price.doubleValue();
        }
        return 42.00;
    }

    public void update(String symbol, double price) {
        map.put(symbol, new Double(price));
    }
}

Será un servicio simple con dos posibles llamadas. Una de las cuales es un mensaje de entrada/salida, y la otra es de solamente-entrada. En última instancia, empaquetaremos el servicio y lo desplegaremos de cuatro maneras distintas. Pero primero, veamos cómo esta simple clase Java corresponde a un servicio.

Preparándose

Antes de que construyamos cualquier cosa que utilice Axis2, tenemos que encargarnos de realizar unos poco arreglos caseros. Primero que nada, necesitará preparar su ambiente para trabajar con Axis2. Afortunadamente, esto implica sólo algunos sencillos pasos:

  1. Descargue e instale Java (la versión mínima es JDK1.4).
  2. Establezca la variable de entorno JAVA_HOME a la ruta de acceso del directorio en el cual instaló el JDK.
  3. Descargue Axis2 y extráigalo a un directorio destino.
  4. Copie el archivo axis2.war al directorio de los webapps de su motor de servlets.
  5. Establezca la variable de entorno AXIS2_HOME para señalar el directorio destino del paso 2. ¡Observe que todos los scripts y archivos build que Axis2 genera dependen de ese valor, así que no se salte este paso! Los usuarios de Linux alternativamente pueden ejecutar el archivo setenv.sh del directorio AXIS2_HOME/bin para establecer la variable de entorno AXIS2_HOME a la ruta de acceso del directorio de extracción de Axis2.

En la mayoría de los casos, también vamos a necesitar un archivo WSDL para nuestro servicio. La herramienta Java2WSDL de Axis2 se puede utilizar para generar un WSDL. Para generar un archivo WSDL a partir de una clase de Java, realice los pasos siguientes:

  1. Cree y compile la clase de Java.
  2. Genere el WSDL utilizando el comando:
%AXIS2_HOME%/bin/java2wsdl -cp . -cn samples.quickstart.service.pojo.StockQuoteService -of StockQuoteService.wsdl

Una vez que haya generado el archivo WSDL, puede realizar los cambios que usted necesite. Por ejemplo, puede ser que agregue faults personalizados o cambie el nombre de los elementos generados. Por ejemplo, este StockQuoteService.wsdl está en la carpeta AXIS2_HOME/samples/quickstartadb/resources/META-INF, que utilizaremos a través del resto de esta guía, substituya los parámetros genéricos creados por el proceso de generación.

Servicios Axis2

Antes de que construyamos cualquier cosa, es necesario entender cual es la apariencia del producto acabado. El lado servidor de Axis2 se puede desplegar en cualquier motor de Servlets, y tiene la estructura siguiente. Mostrada en el listado de código 2.

Listado de código 2: La estructura del directorio de axis2.war

axis2-web
META-INF
WEB-INF
    classes
    conf
        axis2.xml
    lib
        activation.jar
        ...
        xmlSchema.jar
    modules
        modules.list
        addressing.mar
        ...
        soapmonitor.mar
    services
        services.list
        aservice.aar
        ...
        version.aar
    web.xml

Comenzando en la cima, axis2-web es una colección de JSPs que permiten la administración de aplicaciones Axis2, con la cual se puede realizar cualquier acción tal como la adición de servicios y el enganchar y desenganchar módulos. El directorio WEB-INF contiene las clases Java y otros archivos de soporte para ejecutar cualquier servicio desplegado en el directorio services. El archivo principal en todo esto es axis2.xml, el cual controla cómo la aplicación se ocupa de los mensajes recibidos, determinando si Axis2 necesita aplicar cualesquiera de los módulos definidos en el directorio modules. Los servicios se pueden desplegar como archivos *.aar, como se puede ver aquí, pero su contenido se debe arreglar de una manera específica. Por ejemplo, la estructura de este servicio será como sigue:

- StockQuoteService
   - META-INF
     - services.xml
   - lib
   - samples
     - quickstart
       - service
         - pojo
           - StockQuoteService.class

Aquí, el nombre del servicio es StockQuoteService, que se especifica en el archivo services.xml y se corresponde con la carpeta a nivel superior de este servicio. Las clases compiladas Java se ponen por debajo de ella en su lugar apropiado basado en el nombre del paquete. El directorio lib contiene cualquier archivo JAR específico al servicio necesario para que el servicio se ejecute (ninguno en este caso) además de los ya almacenados en el archivo WAR de Axis2 y los directorios JAR comunes del contenedor de servlets. Finalmente, el directorio META-INF contiene cualquier información adicional sobre el servicio que Axis2 necesite para ejecutarlo correctamente. El archivo services.xml define el servicio en sí mismo y vincula los Java class a él (véase el listado de código 3).

Listado de código 3: El Archivo de definición del Servicio

<service name="StockQuoteService" scope="application">
    <description>
        Stock Quote Sample Service
    </description>
    <messageReceivers>
        <messageReceiver
            mep="http://www.w3.org/2004/08/wsdl/in-only"
    class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver"/>
        <messageReceiver
            mep="http://www.w3.org/2004/08/wsdl/in-out"
    class="org.apache.axis2.rpc.receivers.RPCMessageReceiver"/>
    </messageReceivers>
    <parameter name="ServiceClass">
        samples.quickstart.service.pojo.StockQuoteService
    </parameter>
</service>

Aquí el servicio es definido, junto con los tipos messageReceiver relevantes para los diversos patrones del intercambio de mensajes. El directorio META-INF es también la ubicación para cualquier archivo WSDL personalizado que se preponga incluir para esta aplicación. Puede desplegar un servicio simplemente tomando esta jerarquía de archivos y copiándola al directorio webapps/axis2/Web-INF/services de su motor de servlets. (observe que el archivo WAR de Axis2 debe estar previamente instalado en el motor de servlets.) Esto se conoce como formato
exploded. También puede comprimir sus archivos en un archivo *.aar, similar a a un archivo *.jar, y colocar el archivo *.aar directamente en el directorio webapps/axis2/Web-INF/services del motor de servlets. Ahora que entiende lo que estamos intentando lograr, estamos casi listos para comenzar a construir. Primero, descargue y desempaque la versión apropiada de la distribución binaria estándar de Axis2. Asegúrese de establecer el valor de la variable AXIS2_HOME hacia la ubicación en la cual usted extrajo el contenido de este lanzamiento. Ahora veamos algunas de las diferentes maneras de crear clientes y servicios.

Creación de Servicios

En esta sección, veremos cinco formas de crear un servicio basado en la clase StockQuoteService:

  1. Despliegue con POJOs
  2. Creación del servicio utilizando AXIOM
  3. Generación del servicio utilizando ADB (Axis2 Databinding Framework)
  4. Generación del servicio utilizando XMLBeans
  5. Generación del servicio utilizando JiBX

Despliegue con POJOs

Para desplegar el servicio utilizando un POJO (Plain Old Java Object), ejecute los pasos siguientes.

Observe la estructura del directorio contenida en AXIS2_HOME/samples/quickstart (el archivo de services.xml es el mismo de la primera sección de esta guía):

- quickstart
   - README.txt
   - build.xml
   - resources
     - META-INF
       - services.xml
   - src
     - samples
       - quickstart
         - service
           - pojo
             - StockQuoteService.java

Observe que puede generar un WSDL a partir del directorio quickstart mediante el archivo build.xml “tecleando”:

ant generate.wsdl

Sin embargo, crear el StockQuoteService.wsdl es opcional. El WSDL puede ser la versión generada directamente de la clase de Java, o una versión modificada para requisitos particulares. El archivo services.xml es el mismo archivo referido anteriormente.

Ahora construya el proyecto mediante ant generate.service en el directorio quickstart, que se creará la estructura de directorios siguiente:

- quickstart/build/classes
   - META-INF
     - services.xml
   - samples
     - quickstart
       - service
         - pojo
           - StockQuoteService.class

Si desea desplegar el servicio en un formato de directorio “exploded”, renombre el directorio classes a StockQuoteService, y copielo al directorio  webapps/axis2/Web-INF/services en su motor de servlets. Si no, copie el archivo build/StockQuoteService.aar al directorio webapps/axis2/Web-INF/services en su motor de servlets. Entonces compruebe que el servicio haya sido desplegado correctamente viendo la lista de servicios en:

http://localhost:8080/axis2/services/

También puede comprobar el WSDL en:

http://localhost:8080/axis2/services/StockQuoteService?wsdl

Y el esquema en:

http://localhost:8080/axis2/services/StockQuoteService?xsd

Una vez que los URLs estén funcionando, pruebe rápidamente el servicio. Intente apuntar su browser al URL siguiente:

http://localhost:8080/axis2/services/StockQuoteService/getPrice?symbol=IBM

Obtendrá la respuesta siguiente:

<ns:getPriceResponse xmlns:ns="http://pojo.service.quickstart.samples/xsd"><ns:return>42</ns:return></ns:getPriceResponse>

Si usted invoca el método de Actualización como,

http://localhost:8080/axis2/services/StockQuoteService/update?symbol=IBM&price=100

y entonces ejecuta el primer URL con el parámetro getPrice, usted verá que el precio se ha actualizado.

Creación del servicio utilizando AXIOM

Para construir un servicio utilizando AXIOM, ejecute los pasos siguientes.

Observe la estructura del directorio contenido en /samples/quickstartaxiom

- quickstartaxiom
   - README.txt
   - build.xml
   - resources
     - META-INF
       - services.xml
       - StockQuoteService.wsdl
   - src
     - samples
       - quickstart
         - service
           - axiom
             - StockQuoteService.java
         - clients
           - AXIOMClient.java

Puesto que AXIOM es un poco diferente, va a necesitar un archivo services.xml distinto de el que se utilizó para el POJO. Defínalo, según lo mostrado en el listado de código 4.

Listado de código 4: El Archivo de definición del Servicio.

<service name="StockQuoteService" scope="application">
    <description>
        Stock Quote Service
    </description>
    <operation name="getPrice">
        <messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
    </operation>
    <operation name="update">
        <messageReceiver class="org.apache.axis2.receivers.RawXMLINOnlyMessageReceiver"/>
    </operation>
    <parameter name="ServiceClass">samples.quickstart.service.axiom.StockQuoteService</parameter>
</service>

Observe que casi es igual, excepto que las operaciones están definidas explícitamente en el archivo service.xml, y que el MessageReceivers ahora es RawXML.

La clase StockQuoteService.java arriba referida, es una clase “plana” de Java que utiliza las clases de las bibliotecas de Axis2, se define según se muestra en el listado de código 5.

Listado de código 5: La clase StockQuoteService utilizando AXIOM

package samples.quickstart.service.axiom;

import javax.xml.stream.XMLStreamException;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMNamespace;

import java.util.HashMap;
public class StockQuoteService {
    private HashMap map = new HashMap();

    public OMElement getPrice(OMElement element) throws XMLStreamException {
        element.build();
        element.detach();

        OMElement symbolElement = element.getFirstElement();
        String symbol = symbolElement.getText();

        String returnText = "42";
        Double price = (Double) map.get(symbol);
        if(price != null){
            returnText  = "" + price.doubleValue();
        }
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs =
            fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");
        OMElement method = fac.createOMElement("getPriceResponse", omNs);
        OMElement value = fac.createOMElement("price", omNs);
        value.addChild(fac.createOMText(value, returnText));
        method.addChild(value);
        return method;
    }

    public void update(OMElement element) throws XMLStreamException {
        element.build();
        element.detach();

        OMElement symbolElement = element.getFirstElement();
        String symbol = symbolElement.getText();

        OMElement priceElement = (OMElement)symbolElement.getNextOMSibling();
        String price = priceElement.getText();

        map.put(symbol, new Double(price));
    }
}

Axis2 utiliza AXIOM (AXIs Object Model), un estructura estilo DOM (Document Object Model) que se basa en el API de StAX (Streaming API for XML). Los métodos que actúan como servicios deben tomar como argumento(s) un OMElement, que representa un elemento XML que suceda, en este caso, para ser el payload del mensaje entrante SOAP. El método getPrice(OMElement), por ejemplo, extrae el contenido del primer hijo del elemento del payload, que corresponde al símbolo común, y utiliza esto para buscar el precio correspondiente de la acción. A menos que éste sea un servicio “solamente-entrada”, estos métodos deben devolver un OMElement, ya que el mismo se convierte en el payload del mensaje de retorno SOAP.

Ahora construya el proyecto con ant generate.service sobre el directorio AXIS2_HOME/samples/quickstartaxiom.

Coloque el archivo StockQuoteService.aar en el directorio de webapps/axis2/Web-INF/services del motor de servlets, y compruebe que el servicio haya sido desplegado correctamente viendo la lista de servicios en,

http://localhost:8080/axis2/services/

También puede comprobar el acostumbrado WSDL en,

http://localhost:8080/axis2/services/StockQuoteService?wsdl

y el esquema en,

http://localhost:8080/axis2/services/StockQuoteService?xsd

Generación del servicio utilizando ADB

Para generar y desplegar el servicio utilizando el Axis2 Databinding Framework (ADB), ejecute los pasos siguientes.

Genere el skeleton utilizando la herramienta WSDL2Java tecleando lo siguiente en el directorio AXIS2_HOME/samples/quickstartadb:

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.adb -d adb -s -ss -sd -ssi -o build/service

O bien, simplemente teclee ant generate.service
en el directorio AXIS2_HOME/samples/quickstartadb.

La opción -d adb especifica la utilización de Axis Data Binding (ADB). La opción
-s especifica síncrono o llamadas con bloqueo solamente. La opción
-ss crea el código del lado del servidor (skeleton y archivos relacionados). La opción
-sd crea un descriptor del servicio (archivo services.xml). La opción
-ssi crea un interfaz para el skeleton del servicio. Los archivos del servicio se deberán estar ahora en subdirectorio build/service.

Si generó el código utilizando WSDL2Java directamente, tiene que modificar el
skeleton generado para implementar el servicio (si usted utilizó
ant generate.service, un skeleton terminado será copiado sobre el
que se generó automáticamente).

Abra el archivo build/service/src/samples/quickstart/adb/service/StockQuoteServiceSkeleton.java y modifíquelo para agregarle funcionalidad a los métodos generados de su servicio; tal como se muestra en el listado de código 6.

Listado de código 6: Definición del archivo skeleton del servicio

package samples.quickstart.service.adb;

import samples.quickstart.service.adb.xsd.GetPriceResponse;
import samples.quickstart.service.adb.xsd.Update;
import samples.quickstart.service.adb.xsd.GetPrice;

import java.util.HashMap;

public class StockQuoteServiceSkeleton {

    private static HashMap map;

    static{ map = new HashMap(); }

    public void update(Update param0) {
        map.put(param0.getSymbol(), new Double(param0.getPrice()));
    }

    public GetPriceResponse getPrice(GetPrice param1) {
        Double price = (Double) map.get(param1.getSymbol());
        double ret = 42;
        if(price != null){
            ret = price.doubleValue();
        }
        GetPriceResponse res =
                new GetPriceResponse();
        res.set_return(ret);
        return res;
    }
}

Ahora puede construir el proyecto tecleando el comando siguiente en el directorio build/service:

ant jar.server

Si todo va bien, deberá ver el mensaje BUILD SUCCESSFUL en su ventana, y el archivo de StockQuoteService.aar en el directorio build/service/build/lib. Copie ese archivo al directorio de webapps/axis2/Web-INF/services del motor de servlets.

Para cerciorarse, compruebe que el servicio haya sido desplegado correctamente viendo la lista de servicios en,

http://localhost:8080/axis2/services/

También puede comprobar el acostumbrado WSDL en,

http://localhost:8080/axis2/services/StockQuoteService?wsdl

y el esquema en,

http://localhost:8080/axis2/services/StockQuoteService?xsd

Generación del servicio utilizando XMLBeans

Para generar un servicio utilizando XMLBeans, ejecute los pasos siguientes.

Genere el skeleton utilizando la herramienta WSDL2Java tecleando lo siguiente en el directorio AXIS2_HOME/samples/quickstartxmlbeans.

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d xmlbeans -s -ss -sd -ssi -o build/service

O bien, simplemente teclee ant generate.service en el directorio AXIS2_HOME/samples/quickstartxmlbeans.

La opción -d xmlbeans especifica la utilización de XML Beans Data Binding. La opción -s especifica síncrono o llamadas con bloqueo solamente. La opción -ss crea el código del lado del servidor (skeleton y archivos relacionados). La opción -sd crea un descriptor del servicio (archivo services.xml). La opción -ssi crea un interfaz para el skeleton del servicio. Los archivos del servicio se deberán estar en build/service.

Si generó el código utilizando directamente WSDL2Java, tiene que modificar el skeleton generado para implementar el servicio (si usted utilizó la “ant generate.service”, un skeleton terminado será copiado encima del automáticamente generado).

Abra el archivo build/service/src/samples/quickstart/service/xmlbeans/StockQuoteServiceSkeleton.java y modifíquelo para agregarle funcionalidad a los métodos generados de su servicio (véase el listado de código 7).

Listado de código 7: Definición del skeleton del servicio

package samples.quickstart.service.xmlbeans;

import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;
import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;
import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;

import java.util.HashMap;

public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {

    private static HashMap map;

    static{ map = new HashMap(); }

    public void update(UpdateDocument param0) {
        map.put(param0.getUpdate().getSymbol(), new Double(param0.getUpdate().getPrice()));
    }

    public GetPriceResponseDocument getPrice(GetPriceDocument param1) {
        Double price = (Double) map.get(param1.getGetPrice().getSymbol());
        double ret = 42;
        if(price != null){
            ret = price.doubleValue();
        }
        System.err.println();
        GetPriceResponseDocument resDoc =
                GetPriceResponseDocument.Factory.newInstance();
        GetPriceResponseDocument.GetPriceResponse res =
                resDoc.addNewGetPriceResponse();
        res.setReturn(ret);
        return resDoc;
    }
}

Construya el proyecto tecleando el comando siguiente en el directorio build/service, que contiene el archivo build.xml:

ant jar.server

Si todo va bien, deberá ver el mensaje BUILD SUCCESSFUL en su ventana, y el archivo StockQuoteService.aar en el directorio nuevo creado build/service/build/lib. Copie ese archivo al directorio webapps/axis2/Web-INF/services del motor de servlets.

Puede comprobar que el servicio haya sido desplegado correctamente viendo la lista de servicios en,

http://localhost:8080/axis2/services/[listServices]

Usted puede también comprobar el acostumbrado WSDL en,

http://localhost:8080/axis2/services/StockQuoteService?wsdl

y el esquema en,

http://localhost:8080/axis2/services/StockQuoteService?xsd

Generación del servicio utilizando JiBX

Para generar y desplegar el servicio utilizando JiBX Data Binding, ejecute los pasos siguientes.

Genere el skeleton utilizando la herramienta WSDL2Java tecleando lo siguiente en el directorio AXIS2_HOME/samples/quickstartjibx:

%AXIS2_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.jibx -d jibx -s -ss -sd -ssi -uw -o build/service

O bien, simplemente teclee “ant generate.service” en el directorio AXIS2_HOME/samples/quickstartjibx.

La opción -d jibx especifica la utilización de JiBX data binding. La opción -s especifica síncrono o llamadas con bloqueo solamente. La opción -ss crea el código del lado del servidor (skeleton y archivos relacionados). La opción -sd crea un descriptor del servicio (archivo services.xml). La opción -ssi crea un interfaz para el skeleton del servicio. La opción -uw desempaqueta los parámetros pasados hacia y desde las operaciones del servicio para crear un interfaz de programación más natural.

Después de ejecutar WSDL2Java, los archivos del servicio se deben estar en build/service. Si generó el código utilizando WSDL2Java directamente, necesita modificar el skeleton generado para implementar el servicio (si utilizó “ant generate.service” un skeleton terminado será copiado sobre el automáticamente generado).

Abra el archivo build/service/src/samples/quickstart/service/jibx/StockQuoteServiceSkeleton.java y modifiqúelo para agregarle funcionalidad a los métodos generados de su servicio, según se muestra en el listado de código 8.

Listado de código 8: Definición del archivo skeleton del servicio

package samples.quickstart.service.jibx;

import java.util.HashMap;

public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {
    private HashMap map = new HashMap();

    public void update(String symbol, Double price) {
        map.put(symbol, price);
    }

    public Double getPrice(String symbol) {
        Double ret = (Double) map.get(symbol);
        if (ret == null) {
            ret = new Double(42.0);
        }
        return ret;
    }
}

Ahora puede construir el proyecto tecleando el comando siguiente en el directorio build/service:

ant jar.server

Si todo va bien, deberá ver el mensaje BUILD SUCCESSFUL en su ventana, y el archivo StockQuoteService.aar en el directorio build/service/build/lib. Copie ese archivo al directorio webapps/axis2/Web-INF/services del motor de servlets.

Puede comprobar que el servicio haya sido desplegado correctamente viendo la lista de servicios en,

http://localhost:8080/axis2/services/[listServices]

También puede comprobar el acostumbrado WSDL en,

http://localhost:8080/axis2/services/StockQuoteService?wsdl

y el esquema en,

http://localhost:8080/axis2/services/StockQuoteService?xsd

Para más información sobre la utilización de JiBX con Axis2, vea JiBX code generation integration. También puede revisar la JiBX Axis2 Wiki page para saber si existe información actualizada sobre la utilización de JiBX con Axis2.

Creación de Clientes

En esta sección, veremos cuatro maneras de crear a clientes basados en la clase de StockQuoteService:

  1. Creación de un cliente basado en AXIOM
  2. Generación de un cliente utilizando Axis2 Databinding Framework (ADB)
  3. Generación de un cliente utilizando XMLBeans
  4. Generación de un cliente utilizando JiBX

Crear un cliente con AXIOM

Para construir a un cliente utilizando AXIOM, ejecute los pasos siguientes.

Observe la estructura del directorio mostrada en la sección Crear un servicio con AXIOM, duplicada abajo.

- quickstartaxiom
   - README.txt
   - build.xml
   - resources
     - META-INF
       - services.xml
       - StockQuoteService.wsdl
   - src
     - samples
       - quickstart
         - service
           - axiom
             - StockQuoteService.java
         - clients
           - AXIOMClient.java

La clase AXIOMClient.java arriba referida se define como sigue en el listado de código 9.

Listado de código 9: La clase AXIOMClient utilizando AXIOM

package samples.quickstart.clients;

import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMNamespace;
import org.apache.axis2.Constants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.ServiceClient;

public class AXIOMClient {

    private static EndpointReference targetEPR =
        new EndpointReference("http://localhost:8080/axis2/services/StockQuoteService");

    public static OMElement getPricePayload(String symbol) {
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");

        OMElement method = fac.createOMElement("getPrice", omNs);
        OMElement value = fac.createOMElement("symbol", omNs);
        value.addChild(fac.createOMText(value, symbol));
        method.addChild(value);
        return method;
    }

    public static OMElement updatePayload(String symbol, double price) {
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");

        OMElement method = fac.createOMElement("update", omNs);

        OMElement value1 = fac.createOMElement("symbol", omNs);
        value1.addChild(fac.createOMText(value1, symbol));
        method.addChild(value1);

        OMElement value2 = fac.createOMElement("price", omNs);
        value2.addChild(fac.createOMText(value2,
                                         Double.toString(price)));
        method.addChild(value2);
        return method;
    }

    public static void main(String[] args) {
        try {
            OMElement getPricePayload = getPricePayload("WSO");
            OMElement updatePayload = updatePayload("WSO", 123.42);
            Options options = new Options();
            options.setTo(targetEPR);
            options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

            ServiceClient sender = new ServiceClient();
            sender.setOptions(options);

            sender.fireAndForget(updatePayload);
            System.err.println("price updated");
            OMElement result = sender.sendReceive(getPricePayload);

            String response = result.getFirstElement().getText();
            System.err.println("Current price of WSO: " + response);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Axis2 utiliza AXIOM (AXIs Object Model), una estructura estilo DOM (Document Object Model) que se basa en la API StAX (Streaming API for XML). En el listado se establece el
payload para los métodos update y getPrice del servicio. Los payloads son creados de forma similar a como creó el
payload del getPriceResponse para el servicio AXIOM. Entonces configura la clase Options, y crea un ServiceClient que utilizará para comunicarse con el servicio. Primero llama al método update, que es un método de tipo fireAndForget que no devuelve nada. Finalmente, llama al método getPrice, y recupera el precio actual desde servicio y lo exhíbe.

Ahora puede construir y ejecutar el cliente AXIOM tecleando ant run.client en el directorio AXIS2_HOME/samples/quickstartaxiom.

Debe obtener lo siguiente como salida:

done
Current price of WSO: 123.42

Generación de un cliente utilizando ADB

Para construir a un cliente utilizando Axis Data Binding (ADB), ejecute los pasos siguientes.

Genere los databings del cliente tecleando lo siguiente en el directorio AXIS2_HOME/samples/quickstartadb:

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d adb -s -o build/client

O bien, simplemente teclee ant generate.client en el directorio AXIS2_HOME/samples/quickstartadb.

Ahora revise el archivo quickstartadb/src/samples/quickstart/clients/ADBClient.java, que se define como en el listado de código 10.

Listado de código 10: La clase ADBClient

package samples.quickstart.clients;

import samples.quickstart.service.adb.StockQuoteServiceStub;

public class ADBClient{
    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);
            getPrice(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            StockQuoteServiceStub.Update req = new StockQuoteServiceStub.Update();
            req.setSymbol ("ABC");
            req.setPrice (42.35);

            stub.update(req);
            System.err.println("price updated");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            StockQuoteServiceStub.GetPrice req = new StockQuoteServiceStub.GetPrice();

            req.setSymbol("ABC");

            StockQuoteServiceStub.GetPriceResponse res =
                stub.getPrice(req);

            System.err.println(res.get_return());
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

}

Esta clase crea un stub cliente utilizando el Axis Data Bindings que creó anteriormente. Entonces llama a las operaciones getPrice y update del servicio web. La operación del método getPrice crea el payload de
tipo GetPrice y establece símbolo de la acción (symbol) a ABC. Después envía la petición y exhibe el precio actual. El método update crea un payload de
tipo Update, estableciendo el símbolo de la acción (symbol) a ABC y su precio (price) a 42.35.

Ahora construya y ejecute el cliente tecleando ant run.client en el directorio AXIS2_HOME/samples/quickstartadb.

Deberá obtener la siguiente salida:

42
price updated
42.35

Generación de un cliente utilizando XMLBeans

Para construir a un cliente utilizando XML Beans, ejecute los pasos siguientes.

Genere los databings tecleando lo siguiente en el directorio xmlbeansClient (AXIS2_HOME/samples/quickstartxmlbeans).

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d xmlbeans -s -o build/client

O bien, simplemente teclee ant generate.client en el directorio AXIS2_HOME/samples/quickstartxmlbeans.

Observe que esto crea un código del stub cliente y ningún código del lado servidor.

Dé una mirada a quickstartxmlbeans/src/samples/quickstart/clients/XMLBEANSClient.java, que se define como en el listado de código 11.

Listado de código 11: La clase XMLBEANSClient

package samples.quickstart.clients;

import samples.quickstart.service.xmlbeans.StockQuoteServiceStub;
import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;
import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;
import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;

public class XMLBEANSClient{

    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);
            getPrice(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            UpdateDocument reqDoc = UpdateDocument.Factory.newInstance();
            UpdateDocument.Update req = reqDoc.addNewUpdate();
            req.setSymbol ("BCD");
            req.setPrice (42.32);

            stub.update(reqDoc);
            System.err.println("price updated");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            GetPriceDocument reqDoc = GetPriceDocument.Factory.newInstance();
            GetPriceDocument.GetPrice req = reqDoc.addNewGetPrice();
            req.setSymbol("BCD");

            GetPriceResponseDocument res =
                stub.getPrice(reqDoc);

            System.err.println(res.getGetPriceResponse().getReturn());
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }
}

Esta clase crea un stub cliente utilizando los XML Beans data-bindings que creó anteriormente. Entonces llama las operaciones getPrice y update del servicio web. La operación del método getPrice crea el GetPriceDocument, su GetPrice interno clasifica y establece
symbol a ABC. Después envía la petición y recupera un GetPriceResponseDocument y exhibe el precio actual. El método update crea un UpdateDocument, actualiza y establece
symbol a ABC y price a 42.32, y despliega ‘done’ cuando termina.

Ahora construya y ejecute el proyecto tecleando ant run.client en el directorio AXIS2_HOME/samples/quickstartxmlbeans.

Deberá obtener la siguiente salida:

42
price updated
42.32

Generación de un cliente utilizando JiBX

Para construir a un cliente utilizando JiBX, ejecute los pasos siguientes.

Genere el stub cliente tecleando lo siguiente en el directorio AXIS2_HOME/samples/quickstartjibx.

%AXIS2_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d jibx -s -uw -o build/client

O bien, simplemente teclee ant generate.client.

Dé una mirada a quickstartjibx/src/samples/quickstart/clients/JiBXClient.java, mostrado abajo en el listado de código 12.

Listado de código 12: La clase JiBXClient

package samples.quickstart.clients;

import samples.quickstart.service.jibx.StockQuoteServiceStub;

public class JiBXClient{
    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);
            getPrice(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            stub.update("CDE", new Double(42.35));
            System.err.println("price updated");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            System.err.println(stub.getPrice("CDE"));
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

}

Esta clase utiliza el stub cliente JiBX creado para tener acceso a las operaciones getPrice y update del servicio web. El método getPrice envía una petición para la acción “ABC” y exhibe el precio actual. El método update establece el precio para la acción “ABC” a 42.35.

Ahora construya y ejecute el cliente tecleando ant run.client en el directorio AXIS2_HOME/samples/quickstartjibx.

Deberá obtener lo siguiente como salida:

42
price updated
42.35

Para más información sobre la utilización de JiBX con Axis2, vea JiBX code generation integration.

Resumen

Axis2 proporciona una manera pulida y robusta para obtener servicios web funcionando en poco tiempo. Esta guía presentó cinco métodos para la creación de un servicio desplegado en Axis2, y cuatro métodos para la creación de un cliente para comunicarse con los servicios. Ahora tiene la flexibilidad de crear servicios web utilizando una variedad de diferentes tecnologías.

Para Estudio Adicional

7 respuestas a Comienzo Rápido con Axis2

  1. ocars dijo:

    Excelente articulo, muchas gracias

  2. Willy Mejía dijo:

    Basándome en parte del QuickStart de Axis2, el cual he traducido en “Comienzo Rápido con Axis2“, he elaborado un screencast sobre el desarrollo “top down” de un Servicio Web utilizando Eclipse Europa y Axis2…

    Screencast: Servicio Web con Eclipse y Axis2

  3. Ángel Cristóbal Lázaro Ríos dijo:

    Muchas gracias por el excelente artículo que has realizado, ha sido la piedra angular que necesitaba para poder implementar el despliegue de servicios web sobre OpenCms 7.0.5 a través de módulos.

    Un saludo.

  4. Pingback: Web Services sobre OpenCms « Ángel C. Lázaro

  5. intoxicadocoder dijo:

    hola a todos una consulta estoy investigando un buen rato con esto: estoy tratando de retornar un java.util.Map en webservice
    es esto posible? y como lo puedo hacer
    chas gracias!!!

  6. Carlos dijo:

    Hola, gracias por el artículo, el problema que tengo básicamente es que quiero pasar un POJO, por ejemplo tengo una clase Persona en el servidor y quiero publicar el método public Persona getPersona(Persona p). Cómo se hace esto para que en el cliente no de un Axis2Fault? “org.apache.axis2.AxisFault: es.uned.services.pojo.Persona”.

    En teoría en mi cliente tengo un Persona creado por el wsdl2java y en el servidor está el servicio getPersona publicado.

    Gracias!:

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s