Añadir logging a un cliente SOAP de web services

Tes — Mon, 09 Jun 2008 09:51:38 +0000

Cuando trabajamos con web services en java, a la hora de depurar nos sería muy útil el poder ver el xml (protocolo SOAP) que se envían cliente y servidor.
Sin embargo no existe una forma 'sencilla' de hacerlo.

La idea consiste en hacer una clase que implemente el interface javax.xml.rpc.handler.Handler, capaz de interceptar los mensajes SOAP antes de su envío del cliente al servidor y antes de la recepción por parte del cliente de los mensajes enviados por el servidor.
Pueden añadirse varios handlers en serie para procesar las llamadas (handler chains). Este comportamiento es idéntico al de un ServletFilter en una cadena de filtros.
Desde esta clase tenemos acceso al contenido del mensaje SOAP, por lo que somos capaces de leerlo y escribirlo en un fichero de texto o similar.

En el caso de un cliente hecho con apache axis, podemos obtener la lista de Handlers asociados a un nombre de puerto (javax.xml.namespace.QName) y a un punto de destino a través de la clase org.apache.axis.client.Service. Una vez obtenida la lista, solo nos resta añadir nuestro Handler.

Vamos a ello. En primer lugar implementamos el interfaz javax.xml.rpc.handler.Handler para interceptar la llamada soap:

package com.madeinxpain.seamcity.ws;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.xml.namespace.QName;
import javax.xml.rpc.handler.Handler;
import javax.xml.rpc.handler.HandlerInfo;
import javax.xml.rpc.handler.MessageContext;
import javax.xml.rpc.handler.soap.SOAPMessageContext;

public class SoapLoggingHandler implements Handler{

private HandlerInfo handlerInfo;
private List streams;

public SoapLoggingHandler() {
streams = new ArrayList();
try {
this.addOutputStreamLog(System.out);
this.addFileLog("soap.xml");
} catch (Exception e) {
e.printStackTrace();
}
}

public void addOutputStreamLog(OutputStream os) {
this.streams.add(os);
}

public void addFileLog(String rute) throws FileNotFoundException {
FileOutputStream fos = new FileOutputStream(new File(rute));
this.addOutputStreamLog(fos);
}

public boolean handleRequest(MessageContext arg0) {
SOAPMessageContext messageContext = (SOAPMessageContext) arg0;
try {
for (OutputStream os : streams) {
os.write(new String("\n\n\n").getBytes());
messageContext.getMessage().writeTo(os);
}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}

public boolean handleResponse(MessageContext arg0) {
SOAPMessageContext messageContext = (SOAPMessageContext) arg0;
try {
for (OutputStream os : streams) {
os.write(new String("\n\n\n").getBytes());
messageContext.getMessage().writeTo(os);
}
} catch (Exception e) {
}
return true;
}

public boolean handleFault(MessageContext arg0) {
SOAPMessageContext messageContext = (SOAPMessageContext) arg0;
try {
for (OutputStream os : streams) {
os.write(new String("\n\n\n").getBytes());
messageContext.getMessage().writeTo(os);
}
} catch (Exception e) {
}
return true;
}

public void init(HandlerInfo arg0) {
this.handlerInfo = arg0;
}

public void destroy() {
}

public QName[] getHeaders() {
return handlerInfo.getHeaders();
}
}

Esta clase implementa una serie de métodos extra aparte de los obligatorios definidos por el interface. Estos métodos permiten definir una lista de Streams por los que escribir el mensaje.
Estos métodos de logging deben ser invocado desde el constructor, ya que al añadir el Handler a la cadena (como veremos más adelante) no se añade una instancia de un objeto, si no una clase, y es el framework axis el encargado de crear la instancia mediante el método Class.new Instance(), por lo que no es posible definir las formas de logging si no es en el constructor por defecto del handler.

Un a vez codificada la clase, vamos a proceder a añadirla a la cadena. Cada handler debe estar asociado
Tomaremos como ejemplo un cliente WebService para Microsoft Exchange 2007, creado en un post anterior
En primer lugar buscamos la clase que extiende de org.apache.axis.client.Stub, en nuestro caso llamada ExchangeServiceBindingStub, y le añadimos dos campos para almacenar el port por el que se va a realizar la petición soap y el punto de destino.
Estos campos se van a utilizar en el metodo createCall() a la hora de crear la petición soap.
Por simplicidad crearemos los campos como públicos.

public class ExchangeServiceBindingStub extends org.apache.axis.client.Stub implements com.microsoft.schemas.exchange.services._2006.messages.ExchangeServicePortType {

public javax.xml.namespace.QName portName;
public String endPoint;

// resto del código original de la clase

// metodo a modificar
protected org.apache.axis.client.Call createCall() throws java.rmi.RemoteException {
// codigo anterior
if (super.cachedPortName != null) {
_call.setPortName(super.cachedPortName);
}

// Tenemos que añadir estas dos lineas
_call.setPortName(this.portName);
_call.setTargetEndpointAddress(this.endPoint);

// codigo posterior
java.util.Enumeration keys = super.cachedProperties.keys();

}

Cuando instanciamos el objeto org.apache.axis.client.Stub le añadimos el handler:

public class ExchangeWebServiceClient {
private ExchangeServiceBindingStub esb;
private ExchangeServicesLocator locator;

public ExchangeWebServiceClient() {
this.locator = new ExchangeServicesLocator();
this.esb = (ExchangeServiceBindingStub) locator.getExchangeServicePort(new URL(locator.getExchangeServicePortAddress()));

// Añadimos el handler
QName portName = new QName("http://www.neodoo.es/", locator.getExchangeServicePortWSDDServiceName());
List list = locator.getHandlerRegistry().getHandlerChain(portName);
HandlerInfo handlerInfo = new HandlerInfo();
handlerInfo.setHandlerClass(com.madeinxpain.seamcity.ws.SoapLoggingHandler.class);
list.add(handlerInfo);
this.esb.portName = portName;
this.esb.endPoint = locator.getExchangeServicePortAddress();
}
}

Y con esto y un bizcocho, ya tenemos una forma de depurar las llamadas soap a un webservice desde un cliente hecho con axis.
La optimización del código queda a cargo del desarrollador final

Crear un cliente java de Web Services para Exchange 2007

Tes — Sun, 27 Apr 2008 16:53:44 +0000

Para crear el cliente he usado el IDE eclipse-Red Hat Developer Studio, pero el procedimiento será similar para cualquier IDE.
Supondremos que la dirección del servidor es "my.exchange.com".

El primer paso es bajarse del servidor exchange estos 3 archivos y guardarlos en local:
* https://my.exchange.com/ews/Services.wsdl
* https://my.exchange.com/ews/messages.xsd
* https://my.exchange.com/ews/types.xsd
Después hay que modificar el archivo "Services.wsdl" para añadir el servicio y su url.

Debes añadir al final del archivo (antes de cerrar la etiqueta ) las siguientes lineas:

:service name="ExchangeServices">
> :port name="ExchangeServicePort" binding="tns:ExchangeServiceBinding">
:address location="https://my.exchange.com/EWS/Exchange.asmx"/>
>

Ahora tendrás que modificar los archivos "types.xsd" y "messages.xsd" para que maneje correctamente los arrays, mapeandolos a colecciones.
Para cada tipo llamado "ArrayOf..." o "NonEmpyArrayOf..." tendrás que añadirle el atributo maxOccurs="unbounded"
Ejemplo:

:complexType name="ArrayOfFoldersType">
> :choice minOccurs="0" maxOccurs="unbounded">
:element name="Folder" type="t:FolderType" maxOccurs="unbounded"/>
:element name="CalendarFolder" type="t:CalendarFolderType" maxOccurs="unbounded"/>
:element name="ContactsFolder" type="t:ContactsFolderType" maxOccurs="unbounded"/>
:element name="SearchFolder" type="t:SearchFolderType" maxOccurs="unbounded"/>
:element name="TasksFolder" type="t:TasksFolderType" maxOccurs="unbounded"/>
>

Si ya has generado el cliente y sin haber cambiado esto, las clases "ArrayOf..." y "NonEmpyArrayOf..." y generadas serán incapaces de manejar arrays.
Pero aún tiene solución. Deber añadir a cada clase un campo de tipo List (cualquier Collection vale), y en cada método setXXX añadir el objeto pasado como parámetro al array.
Por ejemplo, en la clase ArrayOfRealItemsType:

// declaras la lista:
private List<ItemType> items = new ArrayList<ItemType>();

//sobreescribes los setters para añadir los parametros a la lista:
public void setPostItem(com.microsoft.schemas.exchange.services._2006.types.PostItemType postItem) {
this.items.add(postItem);
this.postItem = postItem;
}

public void setMessage(com.microsoft.schemas.exchange.services._2006.types.MessageType message) {
this.items.add(message);
this.message = message;
}

// etc..

Una vez que has generado el cliente verás que te da algunos fallos de compilación.
Esto es porque por algún motivo los constructores no se generan bien.
Tras arreglar los fallos podemos continuar.

La clase principal para realizar las llamadas al Web Service es ExchangeServiceBindingStub.
Creamos el objeto y le ponemos los parametros de usuario, password y servidor.

ExchangeServiceBindingStub esb = (ExchangeServiceBindingStub) new ExchangeServicesLocator().getExchangeServicePort(new URL(locator.getExchangeServicePortAddress()));
esb.setUsername("usuario");
esb.setPassword("password");
esb._setProperty(javax.xml.rpc.Stub.ENDPOINT_ADDRESS_PROPERTY, "https://my.exchange.com/EWS/Exchange.asmx");

Antes de continuar debes asegurarte que el servidor tiene activada la autentificación básica, si no te saldrá un error HTTP 402.2 "acceso denegado debido a la configuración del servidor"

Ahora solo queda invocar al método del Web Service que quieras y rellenar los parámetros requeridos.

.:: Seam City ::. » exchange

Añadir logging a un cliente SOAP de web services

Crear un cliente java de Web Services para Exchange 2007