Spring Web Services y MTOM Parte 1

Hola que tal hace tiempo que no posteaba, así que decidí hacerlo con un nuevo tema, el de los web services, el tema tiene que ver con la arquitectura orientada a servicios que estoy analizando desde hace un par de meses así que para recordar algo de los web services decidí implementar uno con spring web services; allí les va la definición simple del caso de uso que implementé:

CUS: Calcular operaciones matemáticas.

Descripción breve del CUS: El CUS permitirá al usuario del web service calcular operaciones matemáticas de suma, resta, multiplicación y división, la información enviada al servicio web podrá estar en formato XML o en un archivo de texto comprimido en formato zip que el web service procesará y generará la información en formato XML.

Un ejemplo de mensaje XML enviado al servidor será:

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 
  
   
    12
    13
   
  
  
   
    22
    5
   
  
 

Cuando implementamos web services lo podemos hacer mediante un servlet o un enterprise java bean(EJB) en este caso como estoy usando spring la implementación será con un servlet, por lo que nuestra aplicación será un empaquetado WAR(Web ARchive), ahora una vez definido como será deployado el web service, debemos definir como será diseñado, el diseño de los web services puede realizarse de dos maneras:

(1)Primero escribimos código java que implemente el web service y una vez terminado de codificado, lo deployamos en nuestro servidor de aplicaciones favorito y es éste ultimo quien creará la descripción de nuestro servicio web inspeccionando las clases anotadas con @WebService. Este tipo de diseño se conoce como 'JAVA to WSDL' ó primero java.

(2)Primero escribimos el contrato del web service, el contrato en toda especificación de componente de software es la descripción detallada de mensajes intercambiados entre este componente y su entorno, en el caso de los web services el contrato o especificación es el descriptor del servicio web(WSDL). Este tipo de diseño se conoce como 'WSDL to JAVA' ó primero el contrato.

Como voy a usar spring para implementar mi web service lo primero que tengo que hacer es definir el formato de los mensajes aceptados por mi web service así como el formato de los mensajes de respuesta de mi web service. Esta definición la realizo en un schema XSD:

 elementFormDefault="qualified" attributeFormDefault="qualified"
 targetNamespace="http://www.slcsccy.com.pe/pc/springws/calculadora"
 xmlns:calc="http://www.slcsccy.com.pe/pc/springws/calculadora"
 xmlns:xmime="http://www.w3.org/2005/05/xmlmime">
    
    
   
    
 
  
   
   
    
    
     
      
               maxOccurs="unbounded" />
      
     
    
    
    
   
  
 

 
 
  
   
    
     
      
        
      
     
    
   
  
 

 
  
   
   
   
   
  
 

 
  
   
    
     
             type="xs:decimal" />
     
    
   
  
  
  
 
 
 
      
        
          
        
      
    
    
    
  
   
  
  
 

El schema anterior me define los mensajes de entrada al web service y el formato de mensaje de respuesta.

Ahora veamos el descriptor de despliegue de la aplicación web:

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    Servicio web simple que implementa una calculadora
    
    
        calculadora-annotation
        org.springframework.ws.transport.http.MessageDispatcherServlet
        
            transformWsdlLocations
            true
        
    
    
    
        calculadora-annotation
        /*
    

El descriptor anterior define el servlet calculadora-annotation-servlet.xml en forma implicita, dicho contenedor de beans es el siguiente:

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:oxm="http://www.springframework.org/schema/oxm"
    xmlns:sws="http://www.springframework.org/schema/web-services"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-1.5.xsd
       http://www.springframework.org/schema/web-services http://www.springframework.org/schema/web-services/web-services-1.5.xsd">

 
 
        
        
        
            
                C:\\logs\spring.config
            
        
    
    
    
         class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
        
            
                
                
            
        
        
    
    
 
    
        
    

 
              class="org.springframework.ws.soap.server.endpoint.interceptor.PayloadValidatingInterceptor">
        
        
        
    
    
    
    

 
    
     
    
    
    
    
    
    
     
    
    
    
    
        
        
        
    
    
    
    
        
    

    
    
    

A continuación veamos la clase principal que implementa el web service mediante anotaciones de spring:

package pe.com.slcsccy.pc.springws.ws;

import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipInputStream;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.xml.datatype.DatatypeConfigurationException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;

import pe.com.slcsccy.pc.springws.domain.Operacion;
import pe.com.slcsccy.pc.springws.exception.OperandoInvalidoException;
import pe.com.slcsccy.pc.springws.exception.UnzipException;
import pe.com.slcsccy.pc.springws.schema.MensajeRequest;
import pe.com.slcsccy.pc.springws.schema.MensajeResponse;
import pe.com.slcsccy.pc.springws.schema.ObjectFactory;
import pe.com.slcsccy.pc.springws.schema.OperacionType;
import pe.com.slcsccy.pc.springws.schema.OperacionesZipType;
import pe.com.slcsccy.pc.springws.schema.ResultadoType;
import pe.com.slcsccy.pc.springws.schema.MensajeResponse.Resultados;
import pe.com.slcsccy.pc.springws.service.CalculadoraService;

@Endpoint
public class CalculadoraEndpointWithAnnotation {

 private final Log logger = LogFactory.getLog(CalculadoraEndpointWithAnnotation.class);
 public static final String NAMESPACE_URI = "http://www.slcsccy.com.pe/pc/springws/calculadora";
 public static final String REQUEST_LOCAL_NAME = "mensajeRequest";
 public static final String RESPONSE_LOCAL_NAME = "mensajeResponse";
 private ObjectFactory objectFactory = new ObjectFactory();
 
 private CalculadoraService calculadoraService;
 

 /**
  * Antes de la ejecución de este método la declaración:
  * <sws:marshalling-endpoints marshaller="formador" unmarshaller="formador"/>
  * se a encargado de crear el arbol de objetos desde un archivo xml, hay
  * que recordar que el servicio web recibe XML y que es spring integrado con
  * JAXB quién realiza el proceso de unmarshalling y marshalling para crear el
  * arbol de objetos(MensajeRequest) y el formato de respuesta respectivamente. 
  * */
 @PayloadRoot(localPart = REQUEST_LOCAL_NAME, namespace = NAMESPACE_URI)
 public MensajeResponse calcular(MensajeRequest request) 
  throws DatatypeConfigurationException,OperandoInvalidoException,UnzipException {
  logger.info("Mensaje recibido.");
  
  //Empiezo a crear el objeto de respuesta
  MensajeResponse response = objectFactory.createMensajeResponse();
  Resultados resultados = objectFactory.createMensajeResponseResultados();
  response.setResultados(resultados);
  
  //Si el cliente del servicio web envió las operaciones en formato XML
  if(request.getOperaciones()!=null){
   List<OperacionType> operaciones = request.getOperaciones().getOperacion();
   for(OperacionType operacion:operaciones){
    if( operacion.getOperador().equals("/") && 
      operacion.getOperandos().getOperando().get(1).equals(BigDecimal.ZERO))
     throw new OperandoInvalidoException("No se puede dividir por cero.");
    
    BigDecimal calculo = calculadoraService.calcular(operacion.getOperandos().getOperando(), operacion.getOperador());
    ResultadoType resultado = objectFactory.createResultadoType();
    resultado.setId(operacion.getId());//Copio los identificadores.
    resultado.setValue(calculo);
    resultados.getResultado().add(resultado);
    logger.info("Respuesta calculada en el server:"+calculo.toPlainString());
   } 
  }
  else{
   //Si no me enviaron las operaciones en formato XML, entonces me las
   //enviaron en un archivo comprimido en formato zip:
   OperacionesZipType operacionesZip = request.getOperacionesZip();
   String archivoAsString = unzipOperaciones(operacionesZip.getArchivoZip());
   List<Operacion> operacionesDomain = crearOperaciones(archivoAsString);
   int idSecuencial = 1;
   for(Operacion operacion:operacionesDomain){
    BigDecimal calculo = calculadoraService.calcular(operacion.getOperandos(), operacion.getOperador());
    ResultadoType resultado = objectFactory.createResultadoType();
    resultado.setId(String.valueOf(idSecuencial++));
    resultado.setValue(calculo);
    resultados.getResultado().add(resultado);
    logger.info("Respuesta calculada en el server:"+calculo.toPlainString());
   }
  }
  return response; 
 }
 
 
 /**
  * Descomprime el archivo zip en una cadena
  * */
 private String unzipOperaciones(DataHandler handlerZip)throws UnzipException{
  DataSource dataSource = null;
  ZipInputStream zis = null;
  String archivoAsString = null;
  try{
   dataSource = handlerZip.getDataSource();
   zis = new ZipInputStream(dataSource.getInputStream());
   if(zis.getNextEntry() != null){
    int bytesLeidos = 0;
    int BUFFER_SIZE = 1024*10;
    byte buffer[] = new byte[BUFFER_SIZE];
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    while( (bytesLeidos = zis.read(buffer,0,BUFFER_SIZE)) != -1 ){
     bos.write( buffer, 0, bytesLeidos);
    }
    archivoAsString = new String(bos.toByteArray());
   }
   zis.close();
  }catch(Exception e){
   logger.info("Error al leer el zip.",e);
   throw new UnzipException("Error al leer el zip.");
  }finally{
  }
  return archivoAsString;
 }
 
 
 /**
  * Crea una lista de operaciones a partir de un cadena de texto. 
  * */
 private List<Operacion> crearOperaciones(String archivoAsString){
  Operacion operacion = null;
  List<Operacion> operaciones = new ArrayList<Operacion>();
  String[] lineas = archivoAsString.split("\n");
  for(int i=0;i<lineas.length;i++){
   logger.info("Linea a analizar:"+lineas[i]);
   String[] operacionToken = lineas[i].split(",");
   List<BigDecimal> operandos = new ArrayList<BigDecimal>();
   for(int j=1;j<operacionToken.length;j++){
    logger.info("Operador a procesar:"+operacionToken[j]);
    operandos.add(new BigDecimal(operacionToken[j].trim()));
   }
   operacion = new Operacion(operacionToken[0],operandos);
   operaciones.add(operacion);
  }
  return operaciones;
 }


 public CalculadoraService getCalculadoraService() {
  return calculadoraService;
 }


 public void setCalculadoraService(CalculadoraService calculadoraService) {
  this.calculadoraService = calculadoraService;
 }
}

Como siempre para que el desarrollo sea más eficiente, generar fuentes con JAXB, compilar y deployar a weblogic uso MAVEN, el descriptor del proyecto es el siguiente:

 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 4.0.0
 pe.com.slcsccy.pc
 springws
 war
 0.0.1-SNAPSHOT
 Aplicación de ejemplo básica de spring web services
 http://maven.apache.org

 
  2.9.1
  t3
  false
  true
  true
  false
  false
  true
  localhost
  7001
  ccacique
  xxx
  AdminServer
  true
 

 
  
   jdk14-jdk15
   
    !1.6
   
   
    
     javax.xml.stream
     stax-api
    
    
     javax.xml.soap
     saaj-api
    
   
  
 

 
  
   junit
   junit
   3.8.1
   test
  
  
   org.springframework.ws
   spring-ws-core
   2.0.0-M1
  
  
            javax.xml.bind
            jaxb-api
            2.0
        

        
            com.sun.xml.bind
            jaxb-impl
            2.0.3
        

        
         log4j
         log4j
         1.2.16
        
 
 
  springws
  
   
                org.codehaus.mojo
                jaxb2-maven-plugin
                1.3
                
                    
                        
                            xjc
                        
                    
               
               
                 src/main/webapp/WEB-INF
     src/main/java
     pe.com.slcsccy.pc.springws.schema
     false
               
           
   
    org.apache.maven.plugins
    maven-compiler-plugin
    
     1.6
     1.6
    
   
   
    org.codehaus.mojo
    weblogic-maven-plugin
    ${weblogic-maven-plugin.version}
    
     ${weblogic-maven-plugin.upload}
     ${weblogic-maven-plugin.verbose}
     ${weblogic-maven-plugin.debug}
     ${weblogic-maven-plugin.exploded}
     ${weblogic-maven-plugin.noExit}
     ${weblogic-maven-plugin.continueOnFailure}
     ${weblogic-maven-plugin.adminServerHostName}
     ${weblogic-maven-plugin.adminServerPort}
     ${weblogic-maven-plugin.adminServerProtocol}
     ${weblogic-maven-plugin.userId}
     ${weblogic-maven-plugin.password}
     ${weblogic-maven-plugin.remote}
     ${weblogic-maven-plugin.targetNames}
    
    
     
      weblogic
      wlfullclient
      10.3
     
     
      com.bea
      com.bea.core.descriptor.wl
      1.1.0.0
     
    
   
  
 

En el siguiente post expondré los clientes del web service que envía y reciben las respuestas del web service.

El proyecto completo en eclipse te lo puedes bajar desde AQUI