MII 733 -Computación Móvil

José Miguel Rubio L.Oficina 3-20

http://www.inf.ucv.cl/~jrubiojose.rubio.l@ucv.cl

Sección 5 Servicios Web con Axis

José Miguel Rubio L.Oficina 3-20

http://www.inf.ucv.cl/~jrubiojose.rubio.l@ucv.cl

Introducción I

� Los Servicios Web son la piedra angular de cualquier desarrollo de sistemas distribuidos actual

� Los ordenadores hablan unos a otros a través de la web usando HTTP y otros protocolos.

� Un servicio web no tiene interfaz gráfica� Provee una API de métodos que pueden ser

invocados en la web� Diseñados para proveer “servicios”

Introducción II

� Futuro en el que los negocios exponen aplicaciones a clientes como Servicios Web en los cuales se paga por su uso

� Los sistemas de diferentes empresas cooperan unos con otros a través de la Web

� Mientras que DCOM está basado en estándares propietarios, los Servicios Web lo están en XML y HTTP� Son independientes de la plataforma y del lenguaje como

CORBA, pero más aceptados� En .NET, IIS y la infraestructura ASP.NET compilan

las fuentes, construyen contratos WSDL y manejan las peticiones y respuestas de los servicios web.

� En Java AXIS realiza una tarea muy similar

SOA� Los servicios web han dado lugar a un nuevo

modo de diseñar sistemas distribuídos:� Arquitecturas SOA (Service Oriented Arquitecture)

� SOA = colección de servicios� Más información en http://www.service-architecture.com/

� http://msdn.microsoft.com/Longhorn/understanding/pillars/Indigo/default.aspx?pull=/library/en-us/dnbda/html/srorientwp.asp

Servicios Web

� Son un estándar basado en protocolos abiertos como HTTP y SOAP� SOAP es un vocabulario XML que representa RPCs

� http://www.w3.org/TR/SOAP

� No necesitas ni Windows ni .NET, ni UNIX ni Java para escribir servicios web

� Servicio web = aplicación que:� se ejecuta en un servidor web� expone métodos a clientes� escucha peticiones HTTP representando comandos que invocan

a métodos Web� ejecuta métodos web y devuelve resultados

SOAP

� SOAP es un protocolo de comunicación basado en XML útil para la comunicación entre aplicaciones� Actualmente en versión 1.2, aunque la más utilizada es la 1.1

� http://www.w3.org/2000/xp/Group/

� SOAP es reconocido como el backbone de una nueva generación de aplicaciones multi-platforma y multi-lenguaje, denominado Servicios Web.

� SOAP es un mecanismo para el intercambio de mensajes a través de Internet independiente de los lenguajes de programación� Es un protocolo de transporte

� Los clientes envían una petición SOAP mediante un HTTP POST normalmente y reciben un código de respuesta (éxito o error) y una respuesta SOAP

� Un mensaje SOAP es un mensaje XML que consta de un conjunto de cabeceras opcionales y de un cuerpo.

Petición SOAP

<soap:Envelopexmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">

<soap:Body>

<getProductDetailsxmlns="http://warehouse.example.com/ws">

<productId>827635</productId>

</getProductDetails>

</soap:Body>

</soap:Envelope>

Respuesta SOAP

<soap:Envelopexmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><getProductDetailsResponse

xmlns="http://warehouse.example.com/ws"><getProductDetailsResult><productName>Toptimate 3-Piece Set</productName><productId>827635</productId><description>3-Piece luggage set. Black

Polyester.</description><price>96.50</price><inStock>true</inStock>

</getProductDetailsResult></getProductDetailsResponse>

</soap:Body></soap:Envelope>

Apache AXIS� AXIS es un motor SOAP, una framework para construir tanto la

parte servidora como cliente de Servicios Web.� Además:

� Incluye un servidor � Un servlet que se integra con motores de servlets como Tomcat� Soporte extensivo del estándar Web Service Description Language

(WSDL)� Una herramienta para generar clases Java a partir de WSDL� Un conjunto de aplicaciones de ejemplo� Una herramienta para la monitorización de los paquetes TCP/IP

� Open source, disponible en:http://ws.apache.org/axis/� WS-*

Apache Axis

� Axis es disponible en el fichero axis.jar; que implementa la API JAX-RPC API declarada en los ficheros JAR jaxrpc.jary saaj.jar. Requiere varias bibliotecas de ayuda, para logeo, procesamiento WSDL e introspección.

Características AXIS

� La arquitectura de AXIS está basada en cadenas configurables de manejadores de mensajes que implementan pequeños fragmentos de funcionalidad de una manera flexible

� Sus propiedades principales:� Rápido implementado con un procesador XML SAX� Flexible� Estable� Orientado a Compontes� Soporta WSDL 1.1

� Apache EXtensible Interaction System (AXIS) � motor SOAP muy configurable

Proceso de Generación de Programas con Axis

Instalación Axis

1. Bajarse la distribución de Apache Axis de http://ws.apache.org/axis/� La versión actual es 1.2RC2

� Bajarse tanto versión binaria (ya compilado) como fuente (contiene ejemplos)

2. Instalar un contenedor de servlets como Tomcat 53. Copiar el directorio axis-1_2RC2\webapps\axis contenido

en la distribución de Axis en %TOMCAT_HOME\webapps4. Instalar .jar terceros necesitados por Axis, copiándolos en

%TOMCAT_HOME%\common\lib:� Junit.jar (Junit Testing System -

http://www.junit.org/index.htm) � mail.jar (Java Mail -

http://java.sun.com/products/javamail/)� activation.jar (Java Beans Activation Framework -

http://java.sun.com/products/javabeans/glasgow/jaf.html)

Instalación Axis

5. Arrancar el servidor web6. Validar la instalación:

http://127.0.0.1:8080/axis/(hacer clic en Validate)

7. Validar un SOAP endpoint: http://localhost:8080/axis/services/Version?method=getVersion

� Axis soporta HTTP GET

Creando Servicios Web .jws

� Axis tiene un método muy sencillo de crear servicios web básicos, mediante el mecanismo de ficheros .jws�Cuando alguien solicita a través de una url un

fichero .jws, éste es compilado y ejecutado

� Revisar ejemplo: http://localhost:8080/axis/EchoHeaders.jws?method=list

Cómo Instalar un Nuevo Servicio Web� Dos pasos:

1. Copiar el código del servicio web bajo el directorio %TOMCAT_HOME%\webapps\axis WAR � En el directorio WEB-INF\classes de AXIS copiar las

clases de tu nuevo servicio web� Si tus clases están en un .jar simplemente copiarlas a

WEB-INF\lib

2. Informar al motor de AXIS acerca del nuevo fichero� Se realiza haciendo un POST de un fichero de explotación

(wsdd) mediante el programa AdminClient� El Web Service Deployment Descriptor describe en XML cuál

es el servicio web y qué métodos exporta

Compilando Servicios Web

� Para compilar servicios web necesitamos colocar en nuestro CLASSPATH las dependencias de AXISset AXIS_HOME=c:\axisset AXIS_LIB=%AXIS_HOME%\libset

AXISCLASSPATH=%AXIS_LIB%\axis.jar;%AXIS_LIB%\commons-discovery.jar;%AXIS_LIB%\commons-logging.jar;%AXIS_LIB%\jaxrpc.jar;%AXIS_LIB%\saaj.jar;%AXIS_LIB%\log4j-1.2.8.jar;%AXIS_LIB%\xml-apis.jar;%AXIS_LIB%\xercesImpl.jar

� Luego podemos hacer:� javac –classpath %AXISCLASSPATH% � java -cp %AXISCLASSPATH% ...

Ejecución del AdminClient

� Buscar en axis\samples\stock un ejemplo de un fichero de explotación web de AXIS: deploy.wsdd.

� Registrar el servicio web mediante el comando:java -cp %AXISCLASSPATH% org.apache.axis.client.AdminClient -lhttp://localhost:8080/axis/services/AdminService deploy.wsdd

� Para probar el servicio web acceder a: java -cp .;%AXISCLASSPATH% samples.stock.GetQuote-lhttp://localhost:8080/axis/servlet/AxisServlet -uuser1 -wpass1 XXX

Cómo Añadir AXIS a tu Aplicación Web� Los pasos a seguir son:

1. Añadir axis.jar, wsdl.jar, saaj.jar, jaxrpc.jar y otras bibliotecas dependientes a tufichero WAR

2. Copiar todas las declaraciones del servlet de Axis y sus mapeos de axis/WEB-INF/web.xml y añadirlos a tu propio web.xml

3. Construir y desplegar la aplicación web4. Ejecutar el AdminClient de AXIS contra tu propia

aplicación web, en vez de contra AXIS, cambiando la url con la que invocas a AXIS

Consumiendo un Servicio Web

� Vamos a desarrollar una pequeña aplicación cliente que consume el servicio web más sencillo que podemos imaginar, implementado en Echo.jws, que copiaremos a %TOMCAT_HOME%\webapps\AXIS\:public class Echo {

public String echoString(String msg)

{

return msg;

}

}

Consumiendo un Servicio Web

� A continuación, vamos a definir un cliente que me permita consumir este servicio web desde línea de comando

� Desde un navegador podríamos invocar a este servicio mediante la URL:http://localhost:8080/axis/Echo.jws?method=ec

hoString&msg=hola

Consumiendo un Servicio Webimport org.apache.axis.client.Call;import org.apache.axis.client.Service;import javax.xml.namespace.QName;public class EchoClient{

public static void main(String [] args) {try {

String endpoint = "http://localhost:8080/axis/Echo.jws";Service Service Service Service serviceserviceserviceservice = new Service();= new Service();= new Service();= new Service();Call Call Call Call callcallcallcall = (Call) = (Call) = (Call) = (Call) service.createCallservice.createCallservice.createCallservice.createCall();();();();

call.setTargetEndpointAddresscall.setTargetEndpointAddresscall.setTargetEndpointAddresscall.setTargetEndpointAddress( new ( new ( new ( new java.net.URL(endpointjava.net.URL(endpointjava.net.URL(endpointjava.net.URL(endpoint) );) );) );) );call.setOperationName(newcall.setOperationName(newcall.setOperationName(newcall.setOperationName(new QName("http://soapinterop.orgQName("http://soapinterop.orgQName("http://soapinterop.orgQName("http://soapinterop.org/", "/", "/", "/", "echoStringechoStringechoStringechoString") );") );") );") );

String ret = (String) call.invokecall.invokecall.invokecall.invoke( new Object[] { "Hello!" } );System.out.println("Sent 'Hello!', got '" + ret + "'");

} catch (Exception e) {System.err.println(e.toString());

}}

}

Consumiendo un Servicio Web

� Los objetos Service y Call son los objetos estándar JAX-RPC que permiten guardar metadatos sobre el servicio a invocar.

Consumiendo un Servicio Web

� Al invocar el método la siguiente información aparecería en el navegador:<?xml version="1.0" encoding="UTF-8"?><SOAP-ENV:Envelope

xmlns:xsd="http://www.w3.org/2001/XMLSchema"xmlns:SOAP-

ENV="http://schemas.xmlsoap.org/soap/envelope/"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><SOAP-ENV:Body><ns1:echoString xmlns:ns1="http://soapinterop.org/"><arg0 xsi:type="xsd:string">Hello!</arg0>

</ns1:echoString></SOAP-ENV:Body>

</SOAP-ENV:Envelope>

Consumiendo un Servicio Web

� Si deseamos dar nombre a los parámetros solamente deberemos insertar el siguiente código:// Call to addParameter/setReturnType as described in user-guide.html

call.addParameter("testParam", org.apache.axis.Constants.XSD_STRING, javax.xml.rpc.ParameterMode.IN);

� Si queremos indicar a AXIS cuál es el tipo de dato devuelto haríamos:call.setReturnType(org.apache.axis.Constants.XSD_STRING);

Publicando un Servicio Web con AXIS� Vamos a suponer que tenemos una clase Calculator que queremos sea accesible como Servicio Web.

� Tenemos dos mecanismos:�A través de un fichero .JWS

�Registrando el nuevo servicio vía AxisAdminusando desplegamiento propietario

Publicando con JWS

� Sólo para Servicios Web muy sencillos� Con esta instrucción se desplegaría:

� copy Calculator.java <your-webapp-root>/axis/Calculator.jws

� Para invocarlo haríamos: http://localhost:8080/axis/Calculator.jws

� O nos crearíamos nuestros clientes propietarios.� Revisar samples/userguide/example2/Calculator.java

Calculator.java

public class Calculator {public int add(int i1, int i2){return i1 + i2;

}

public int subtract(int i1, int i2){return i1 - i2;

}}

CalcClient.javaimport org.apache.axis.client.Call;import org.apache.axis.client.Service;import org.apache.axis.encoding.XMLType;import org.apache.axis.utils.Options;

import javax.xml.rpc.ParameterMode;

public class CalcClient{

public static void main(String [] args) throws Exception {Options options = new Options(args);

String endpoint = "http://localhost:" + options.getPort() +"/axis/Calculator.jws";

args = options.getRemainingArgs();

if (args == null || args.length != 3) {System.err.println("Usage: CalcClient <add|subtract> arg1 arg2");return;

}

String method = args[0];if (!(method.equals("add") || method.equals("subtract"))) {

System.err.println("Usage: CalcClient <add|subtract> arg1 arg2");return;

}

CalcClient.java

Integer i1 = new Integer(args[1]);Integer i2 = new Integer(args[2]);

Service service = new Service();Call call = (Call) service.createCall();

call.setTargetEndpointAddress( new java.net.URL(endpoint) );call.setOperationName( method );call.addParameter( "op1", XMLType.XSD_INT, ParameterMode.IN );call.addParameter( "op2", XMLType.XSD_INT, ParameterMode.IN );call.setReturnType( XMLType.XSD_INT );

Integer ret = (Integer) call.invoke( new Object [] { i1, i2 });

System.out.println("Got result : " + ret);}

}

Custom Deployment

� Habrá ocasiones en que queramos exportar código anteriormente realizado como un servicio web

� Además a menudo se requerirán configuraciones más sofisticadas: inclusión de Handlers

� Para acceder a toda la flexibilidad configurativade AXIS necesitamos utilizar Web ServiceDeployment Descriptor (WSDD)

Web Service DeploymentDescriptor� Describe un conjunto de configuraciones que quieres hacer disponible a

AXIS� Por ejemplo:

<deployment xmlns="http://xml.apache.org/axis/wsdd/"

xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

<service name="MyService" provider="java:RPC"><parameter name="className" value="samples.userguide.example3.MyService"/><parameter name="allowedMethods" value="*"/></service></deployment>

� Indicamos que el servico web MyService de tipo java:RPC es definido en la clase samples.userguide.example3.MyService y hacemos disponibles todos los métodos públicos en esa clase

Web Service DeploymentDescriptor� Algunas opciones adicionales que se pueden especificar

en un .wsdd son:� Alcance de los servicios, se pueden definir servicios web con

tres alcances:� request� crea un nuevo objeto cada vez que se recibe una

petición al servicio� application � un solo objeto servirá todas las peticiones� session� un objeto por cada sesión de cliente

� Por ejemplo:<service name="MyService"...><parameter name="scope" value=“request"/>...

</service>

Utilizando el AdminClient

� La clase org.apache.axis.client.AdminClientpermite el envío del fichero de explotación al servidor Tomcat, si está escuchando en un puerto diferente al 8080 hay que enviar el parámetro –p <port>.� java org.apache.axis.client.AdminClientdeploy.wsdd

� java org.apache.axis.client.AdminClient list

� java org.apache.axis.client.AdminClientundeploy.wsdd

� Revisar samples/userguide/example3.

Manejadores y Cadenas

� Los Handlers (o manejadores) permiten pre/post procesar peticiones a servicios web. � Por ejemplo, para contar el número de invocaciones recibidas� Revisar ejemplo samples/log

� En el .wsdd podemos colocar un elemento handler que puede recibir una serie de parámetros (subelemento parameter)

� Después, podemos definir services que usan los handler, mediante subelementos requestFlow del service� Estos handlers son invocados antes de que el provider sea

invocado

Manejadores y Cadenas

<deployment xmlns="http://xml.apache.org/axis/wsdd/"

xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"><!-- define the logging handler configuration --><handler name="track"

type="java:samples.userguide.example4.LogHandler"><parameter name="filename" value="MyService.log"/></handler>

<!-- define the service, using the log handler we just defined --><service name="LogTestService" provider="java:RPC"><requestFlow><handler type="track"/></requestFlow>

<parameter name="className" value="samples.userguide.example4.Service"/>

<parameter name="allowedMethods" value="*"/></service></deployment>

Pasos para Crear un Servicio Web con Custom Deployment1. Crear un directorio de trabajo:

examples/webservices/ej3customdeployment2. Crear la clase Java que define el servicio web (MyService.java)3. Crear el cliente web (Client.java)4. Crear el descriptor de despliegue para este servicio (deploy.wsdd)5. Crear el descriptor para eliminar este servicio (undeploy.wsdd)6. cd ej3customdeployment7. Compilar el código: javac *.java8. Ejecutar el AdminClient: java org.apache.axis.client.AdminClient

deploy.wsdd9. copy ej3customdeployment/*.class %TOMCAT_HOME%\axis\WEB-

INF\classes\ ej3customdeployment10. Ejecutar: cd ..; java ej3customdeployment.Client -

lhttp://localhost:8080/axis/services/MyService "test me!"

MyService.java

package ej3customdeployment;

public class MyService

{

public String serviceMethod(String arg)

{

return arg;

}

}

Client.java

package ej3customdeployment;import org.apache.axis.client.Call;import org.apache.axis.client.Service;import org.apache.axis.encoding.XMLType;import org.apache.axis.utils.Options;import javax.xml.namespace.QName;import javax.xml.rpc.ParameterMode;public class Client{

public static void main(String [] args){

try {Options options = new Options(args); String endpointURL = options.getURL();String textToSend;args = options.getRemainingArgs();if ((args == null) || (args.length < 1)) {

textToSend = "<nothing>";} else {

textToSend = args[0];}Service service = new Service();Call call = (Call) service.createCall();call.setTargetEndpointAddress( new java.net.URL(endpointURL) );call.setOperationName( new QName("http://ej3_customdeployment", "serviceMethod") );call.addParameter( "arg1", XMLType.XSD_STRING, ParameterMode.IN);call.setReturnType( org.apache.axis.encoding.XMLType.XSD_STRING );String ret = (String) call.invoke( new Object[] { textToSend } );System.out.println("You typed : " + ret);

} catch (Exception e) {System.err.println(e.toString());

}}

}

deploy.wsdd/undeploy.wsdd

� deploy.wsdd<deployment xmlns="http://xml.apache.org/axis/wsdd/"

xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

<service name="MyService" provider="java:RPC"><parameter name="className" value="ej3customdeployment.MyService"/><parameter name="allowedMethods" value="*"/></service></deployment>

� undeploy.wsdd<undeployment xmlns="http://xml.apache.org/axis/wsdd/"><service name="MyService"/></undeployment>

Mapeos de WSDL a Java

java.lang.Stringxsd:string

shortxsd:short

javax.xml.namespace.QNamexsd:QName

longxsd:long

java.math.BigIntegerxsd:integer

intxsd:int

byte[]xsd:hexBinary

floatxsd:float

doublexsd:double

java.math.BigDecimalxsd:decimal

java.util.Calendarxsd:dateTime

bytexsd:byte

booleanxsd:boolean

byte[]xsd:base64Binary

Pasando Objetos en Servicios Web

� Las excepciones se representan como elementos wsdl:fault� Podemos pasar objetos como argumentos con la ayuda del elemento

del elemento beanmapping en un .wsdd<beanMapping qname="ns:local" xmlns:ns="someNamespace"

languageSpecificType="java:my.java.thingy"/>

� Revisar ejemplo: samples/userguide/example5/BeanService.java<deployment xmlns="http://xml.apache.org/axis/wsdd/"

xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"><service name="OrderProcessor" provider="java:RPC">

<parameter name="className" value="samples.userguide.example5.BeanService"/>

<parameter name="allowedMethods" value="processOrder"/>

<beanMapping qname="myNS:Order" xmlns:myNS="urn:BeanService" languageSpecificType="java:samples.userguide.example5.Order"/></service>

</deployment>

Pasando Objetos en Servicios Web

� Dado que el BeanSerializer no permite transformar clases ya existentes que no conformen con el estándar JavaBean, es posible utilizar customserialization

� Para ello en el wsdd colocaremos:<typeMapping qname="ns:local" xmlns:ns="someNamespace" languageSpecificType="java:my.java.thingy"

serializer="my.java.Serializer" deserializer="my.java.DeserializerFactory" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>

Web Services DescriptionLanguage (WSDL)

� Si miramos al fichero WSDL encontraremos:� Elemento service que describe el servicio web� Elementos operation que documentan las

operaciones� Elementos binding que documentan los

protocolos soportados por el servicio web� Etc.

� Para publicar un servicio web deberemos publicar su contrato, WSDL.� Otros desarrolladores pueden utilizar el contrato

para desarrollar clientes web� Nomalmente procesan el fichero WSDL a través

de una herramienta que genera clases wrapper

Usando WSDL con Axis

� Web Service Description Language (WSDL) permite describir los servicios web de una manera estructurada

� Un WSDL nos da la siguiente información:� La interfaz al servicio� Los parámetros que acepta� La localización del servicio

� AXIS soporta WSDL de tres formas:� Podemos obtener el wsdl de un servicio accediendo a su URL en un

navegador y colocando el sufijo ?wsdlhttp://localhost:8080/axis/Echo.jws?wsdl

� Herramienta WSDL2Java que genera Java proxies y skeletons a partir de descriptores WSDL

� Herramienta Java2WSDL que construye WSDL a partir de clases Java

WSDL2Java: proxies, stubs y tipos de datos� Esta herramienta es disponible en la

clase: org.apache.axis.wsdl.WSDL2Java

� Su uso sería: java org.apache.axis.wsdl.WSDL2Java

(WSDL-file-URL)

� Existe la tarea wsdl2java en Ant

WSDL2Java

A service implementation (the locator)

A service interfaceFor each service

A stub classFor each binding

A java interfaceFor each portType

A holder if this type is used as an inout/out parameter

A java classFor each entry in the type section

Java class(es) generatedWSDL clause

Mapeo Tipos<xsd:complexType name="phone"><xsd:all>

<xsd:element name="areaCode" type="xsd:int"/><xsd:element name="exchange" type="xsd:string"/><xsd:element name="number" type="xsd:string"/>

</xsd:all></xsd:complexType>� Mapearía a:public class Phone implements java.io.Serializable {

public Phone() {...}public int getAreaCode() {...}public void setAreaCode(int areaCode) {...}public java.lang.String getExchange() {...}public void setExchange(java.lang.String exchange) {...}public java.lang.String getNumber() {...}public void setNumber(java.lang.String number) {...}public boolean equals(Object obj) {...}public int hashCode() {...}

}

Mapeo Parámetros de Entrada/Salidapackage samples.addr.holders;public final class PhoneHolder implements

javax.xml.rpc.holders.Holder {public samples.addr.Phone value;

public PhoneHolder(){}

public PhoneHolder(samples.addr.Phone value) {this.value = value;

}}

Mapeo PortTypes

<message name="empty"><message name="AddEntryRequest"><part name="name" type="xsd:string"/><part name="address" type="typens:address"/>

</message><portType name="AddressBook"><operation name="addEntry"><input message="tns:AddEntryRequest"/><output message="tns:empty"/>

</operation></portType>� Mapearía a:public interface AddressBook extends java.rmi.Remote {

public void addEntry(String name, Address address) throws java.rmi.RemoteException;

}

Mapeo Bindings

� Su nombre es el nombre del Binding con el sufijo Stub� Implementa el SDI (Service Description Interface)� Actúa como un proxy entre el cliente y el servicio web� El stub esconde el endpoint, namespace, o los arrays de parámetros� Así el siguiente fragmento de wsdl generaría:

<binding name="AddressBookSOAPBinding" type="tns:AddressBook"> ... </binding>

� Lo siguiente:public class AddressBookSOAPBindingStub extends org.apache.axis.client.Stub

implements AddressBook {public AddressBookSOAPBindingStub() throws org.apache.axis.AxisFault{...}

public AddressBookSOAPBindingStub(URL endpointURL, javax.xml.rpc.Service service)

throws org.apache.axis.AxisFault{...}

public AddressBookSOAPBindingStub(javax.xml.rpc.Service service)throws org.apache.axis.AxisFault

{...}

public void addEntry(String name, Address address) throws RemoteException{...}

}

Servicios� Normalmente un cliente instanciará un localizador de servicios y luego llamará al método

get para recuperar su stub.� Se deriva del elemento service de WSDL:

<service name="AddressBookService"><port name="AddressBook" binding="tns:AddressBookSOAPBinding">

<soap:addresslocation="http://localhost:8080/axis/services/AddressBook"/>

</port></service>

� Como:public interface AddressBookService extends javax.xml.rpc.Service {

public String getAddressBookAddress();

public AddressBook getAddressBook() throws javax.xml.rpc.ServiceException;

public AddressBook getAddressBook(URL portAddress) throws javax.xml.rpc.ServiceException;

}

WSDL2Java will also generate the locator which implements this interface:

public class AddressBookServiceLocator extends org.apache.axis.client.Serviceimplements AddressBookService {

...

Uso del Service Locator

public class Tester{

public static void main(String [] args) throws Exception {// Make a serviceAddressBookService service = new

AddressBookServiceLocator();

// Now use the service to get a stub which implements the SDI.

AddressBook port = service.getAddressBook();

// Make the actual callAddress address = new Address(...);port.addEntry("Russell Butek", address);

}}

Bindings en la Parte Servidora: Skeleton� Stub es el proxy en el cliente de un Servicio

Web� El Skeleton es el proxy del Servicio Web en el

servidor� Necesitas especificar los flags --server-side --skeletonDeploy true" cuando invocasWSDL2java:java org.apache.axis.wsdl.WSDL2Java --server-side --skeletonDeploy true AddressBook.wsdl

Bindings en la Parte Servidora: Skeleton

One undeploy.wsdd file

One deploy.wsdd fileFor all services

An implementation template class

A skeleton classFor each binding

Java class(es) generatedWSDL clause

Los Skeleton

� Intermediario entre el Axis engine y la implementación del servicio

� Su nombre es el del binding con el sufijo Skeleton

Compilación Ejemplo ej4-wsdl2java

� Los pasos a seguir serían:� java org.apache.axis.wsdl.WSDL2Java --server-side AddressBook.wsdl

� cd AddressFetcher2

� javac *.java

� java org.apache.axis.client.AdminClientdeploy.wsdd

Herramienta Java2WSDL

1. Crear una interfaz Java o una clase que describa la interfaz del servicio web. Por ejemplo:package ej5java2wsdl;

public interface MyWidgetPrice {

public void setWidgetPrice(StringwidgetName, String price);

public String getWidgetPrice(StringwidgetName);

}

Herramienta Java2WSDL

2. Crear el WSDL por medio de Java2WSDLPara crear el WSDL asociado a la clase anterior haríamos:java org.apache.axis.wsdl.Java2WSDL -o wp.wsdl -

l"http://localhost:8080/axis/services/MyWidgetPrice" -n "urn:Example6" -p"ej5java2wsdl" "urn:Example6" ej5java2wsdl.MyWidgetPrice

donde:� -o indica el nombre del fichero WSDL de salida� -l denota la localización del servicio� -n es el espacio de nombres de destino del fichero WSDL� -p indica un mapeo del paquete al espacio de nombres.� la clase que contiene la interfaz del servicio web.

� Para más información sobre Java2WSDL revisar http://ws.apache.org/axis/java/reference.html

Java2WSDL3. Utilizar WSDL2Java para generar los bindings

� El comando:java org.apache.axis.wsdl.WSDL2Java -o . -d Session -s

-S true -Nurn:Example6 ej5java2wsdl wp.wsdl

� Generaría:� WidgetPriceSoapBindingImpl.java : fichero Java conteniendo la

implementación por defecto de la parte servidora del servicio web WebService� Habrá que modificar esta clase para añadir tu implementación

� WidgetPrice.java: nueva interfaz que contiene los java.rmi.Remoteapropiados

� WidgetPriceService.java: fichero que contiene la interfaz de la parte cliente

� WidgetPriceServiceLocator.java: fichero conteniendo la implementación de la parte cliente del servicio

� WidgetPriceSoapBindingSkeleton.java: el skeleton de la parte servidora

� WidgetPriceSoapBindingStub.java: el stub de la parte cliente� deploy.wsdd: descriptor de explotación� undeploy.wsdd: descriptor de desesplotación� Tipos de datos: ficheros correspondientes a los tipos y holders del

servicio web

Servicios Web de Consumo Público� Acceder a la url: http://www.xmethods.net

� Generar la parte cliente del servicio webcon el comando WSDL2Java

Tareas Ant para Construir Ejemplos� Las siguientes tareas en Ant simplifican la compilación y

despliegue de servicios web:� <axis-wsdl2java>� <axis-java2wsdl>� <axis-admin>

� Para más información mirar en: http://ws.apache.org/~toshi/jp-site/axis/java/ant/ant.html

� Revisar ejemplo samples\userguide\example6\build.xml

Cliente Calculadora en .NET

� Vamos a realizar un cliente para nuestro Servicio Web calculadora en .NET:� wsdlhttp://localhost:8080/axis/Calculator.jws?wsdl

� Escribimos fichero Calculadora.cs� csc CalculatorService.cs Calculadora.cs

� Ejecutamos: Calculadora.exe

Calculadora.cs

using System;

class Calculadora{

public static void Main (){

CalculatorService calc = new CalculatorService ();int sum = calc.add (2, 2);Console.WriteLine ("2 + 2 = " + sum);int resta = calc.subtract (2, 2);Console.WriteLine ("2 - 2 = " + resta);

}}

Cliente Calculadora en Java

� Pasos de desarrollo:1. java

org.apache.axis.wsdl.WSDL2Java http://localhost:8080/axis/Calculator.jws?wsdl

2. Escribir clase CalcClient3. Compilarla: javac CalcClient

4. Ejecutarla: java CalcClient

Cliente Calculadora en Java

import localhost.axis.Calculator_jws.*;

public class CalcClient{

public static void main(String [] args) throws Exception {// Make a serviceCalculatorService service = new CalculatorServiceLocator();

// Now use the service to get a stub which implements the SDI.Calculator port = service.getCalculator();

// Make the actual callint sum = port.add(2,2);System.out.printf("2+2=%d\n", sum);int resta = port.subtract(2,2);System.out.printf("2-2=%d\n", resta);

}}