El Blog de Carlitos Cacique

Spring Security Mediante Base de Datos

2010-08-10T19:56:00.000-07:00

En el post anterior les mostré como implementar spring security de la manera más básica, ahora continuaremos pero esta vez ya no obtendremos los usuarios desde XML como en:

Ahora vamos a obtener los usuarios desde un archivo de propiedades, para eso el XML anterior se reduce a:

Ojo que el archivo de propiedades lo podemos obtener desde el classpath de la aplicación(como en el ejemplo anterior)
o desde un archivo externo a la aplicación como en:

De esta manera podemos modificar el archivo de propiedades sin desempaquetar el EAR o WAR de la aplicación

El archivo de propiedades que contiene a los usuarios es bien simple, le especificamos el usuario, password, los roles o perfiles y si está habilitado o no:


#usuario=password,rol1[,rolN][,enabled|disabled]
ccacique1=pass1,PERFIL_ADMINISTRADOR,disabled
ccacique2=pass2,PERFIL_SUPERVISOR,enabled
ccacique3=pass3,PERFIL_ADMINISTRADOR,PERFIL_SUPERVISOR,enabled

La gestión de usuarios mediante archivos(sea en XML o en properties) no es apropiado en un entorno de producción donde pueden interactuar cientos o miles de usuarios, por lo que spring security nos proporciona una manera de obtener dichos usuarios desde la base de datos:

Para implementar la gestión de usuarios mediante una base de datos con spring security debemos de hacer lo siguiente:

Implementar un proveedor de usuarios.

El proveedor de usuarios debe de implementar la interface org.springframework.security.core.userdetails.UserDetailsService

La interface anterior obliga a definir el método public UserDetails loadUserByUsername(String username), por lo que debemos de implementarlo

El método anterior retorna un objeto de la clase org.springframework.security.core.userdetails.UserDetails, esta clase define campos de autenticación de usuarios simple como nombre de usuario, password, si el usuario está bloqueado y los perfiles asociados a este usuario.

Colocar la referencia al proveedor de usuarios en donde usuarioService es mi proveedor de usuarios

Veamos la implementación del gestor de usuarios:


package pe.com.slcsccy.pc.springsecurity.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import pe.com.slcsccy.pc.springsecurity.dao.UsuarioDAO;
import pe.com.slcsccy.pc.springsecurity.model.Usuario;

@Service("usuarioService")
public class UsuarioServiceImpl implements UserDetailsService{
 @Autowired
 private UsuarioDAO usuarioDAO;
 
 @Override
 public UserDetails loadUserByUsername(String username)
   throws UsernameNotFoundException, DataAccessException {
  Usuario usuario = null;
  List usuarios = usuarioDAO.buscarUsuarioPorCodigo(username);
  if(usuarios.size()==0)throw new UsernameNotFoundException("Usuario no existe.");
  else{
   usuario = usuarios.get(0);
   usuario.setPerfiles(usuarioDAO.buscarPerfilesDeUsuarioPorCodigo(username));
   return usuario; 
  }
 }
}

El proveedor de usuarios hace uso de un objeto de acceso a datos, que lo he implementado con spring jdbc:


package pe.com.slcsccy.pc.springsecurity.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.security.core.GrantedAuthority;

import pe.com.slcsccy.pc.springsecurity.model.Perfil;
import pe.com.slcsccy.pc.springsecurity.model.Usuario;

public class UsuarioDAOImpl implements UsuarioDAO {

 private JdbcTemplate jdbcTemplate;

 public void setDataSource(DataSource dataSource) {
  this.jdbcTemplate = new JdbcTemplate(dataSource);
 }

 @SuppressWarnings("unchecked")
 @Override
 public List buscarUsuarioPorCodigo(String codigo) {
  return jdbcTemplate.query("select * from usuario where cod_usuario = ? ", new RowMapper() {
   public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    Usuario usuario = new Usuario();
    usuario.setUsername(rs.getString("cod_usuario"));
    usuario.setPassword(rs.getString("des_password"));
    usuario.setAccountNonExpired(rs.getString("in_cuenta_expirada").equals("N")?true:false);
    usuario.setAccountNonLocked(rs.getString("in_cuenta_bloqueada").equals("N")?true:false);
    usuario.setCredentialsNonExpired(rs.getString("in_credencial_expirada").equals("N")?true:false);
    usuario.setEnabled(rs.getString("in_habilitado").equals("S")?true:false);
    return usuario;
   }
  },codigo);
 }

 @SuppressWarnings("unchecked")
 @Override
 public List buscarPerfilesDeUsuarioPorCodigo(String codigo) {
  return jdbcTemplate.query("select cod_perfil from usuario_perfil where cod_usuario = ? ", new RowMapper() {
   public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    Perfil perfil = new Perfil();
    perfil.setNombrePerfil(rs.getString("cod_perfil"));
    return perfil;
   }
  },codigo);
 }
}

El acceso a los datos se realiza mediante un modelo de dominio de usuarios y de perfiles siguiente:

Usuario.java


package pe.com.slcsccy.pc.springsecurity.model;
import java.util.Collection;
import java.util.List;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
public class Usuario implements UserDetails{

 private static final long serialVersionUID = -4993799715730712001L;
 
 private List perfiles;
 private String username;
 private String password;
 private boolean accountNonExpired;
 private boolean accountNonLocked;
 private boolean credentialsNonExpired;
 private boolean enabled;
 
 public Collection getPerfiles() {
  return perfiles;
 }
 
 @SuppressWarnings("unchecked")
 public void setPerfiles(List perfiles) {
  this.perfiles = (List) perfiles;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public boolean isAccountNonExpired() {
  return accountNonExpired;
 }
 public void setAccountNonExpired(boolean accountNonExpired) {
  this.accountNonExpired = accountNonExpired;
 }
 public boolean isAccountNonLocked() {
  return accountNonLocked;
 }
 public void setAccountNonLocked(boolean accountNonLocked) {
  this.accountNonLocked = accountNonLocked;
 }
 public boolean isCredentialsNonExpired() {
  return credentialsNonExpired;
 }
 public void setCredentialsNonExpired(boolean credentialsNonExpired) {
  this.credentialsNonExpired = credentialsNonExpired;
 }
 public boolean isEnabled() {
  return enabled;
 }
 public void setEnabled(boolean enabled) {
  this.enabled = enabled;
 }
 public Collection getAuthorities() {
  return perfiles;
 }
 
}

Perfil.java


package pe.com.slcsccy.pc.springsecurity.model;
import org.springframework.security.core.GrantedAuthority;
public class Perfil implements GrantedAuthority{

 private static final long serialVersionUID = 1L;
 private String nombrePerfil;
 
 public Perfil(){
 }
 
 public String getNombrePerfil() {
  return nombrePerfil;
 }

 public void setNombrePerfil(String nombrePerfil) {
  this.nombrePerfil = nombrePerfil;
 }

 @Override
 public String getAuthority() {
  return this.nombrePerfil;
 }

}

El modelo de dominio y el objeto de acceso a datos colaboran entre sí para conectarse y dar soporte a los datos de una base de datos Oracle que tiene la siguiente estructura e información:


create user springsecurity identified by springsecurity account unlock;
grant resource,connect to springsecurity;

create table springsecurity.usuario(
  cod_usuario varchar2(40) not null,
  des_password varchar2(40) not null,
  in_cuenta_expirada char(1) default 'N' not null ,
  in_cuenta_bloqueada char(1) default 'N' not null ,
  in_credencial_expirada char(1) default 'N' not null ,
  in_habilitado char(1) default 'S' not null ,
  primary key(cod_usuario)
);

create table springsecurity.perfil(
  cod_perfil varchar2(40) not null,
  des_perfil varchar2(40) not null,
  primary key(cod_perfil)
);

create table springsecurity.usuario_perfil(
  cod_usuario varchar2(40),
  cod_perfil varchar2(40),
  primary key(cod_usuario,cod_perfil),
  foreign key(cod_usuario) references springsecurity.usuario(cod_usuario),
  foreign key(cod_perfil) references springsecurity.perfil(cod_perfil)
);

insert into springsecurity.perfil values('PERFIL_ADMINISTRADOR','PERFIL DE ADMINISTRADOR');
insert into springsecurity.perfil values('PERFIL_SUPERVISOR','PERFIL DE SUPERVISOR');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique1','pass1');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique2','pass2');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique3','pass3');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique4','pass4');
insert into springsecurity.usuario_perfil(cod_usuario,cod_perfil) values('ccacique1','PERFIL_ADMINISTRADOR');
insert into springsecurity.usuario_perfil(cod_usuario,cod_perfil) values('ccacique2','PERFIL_SUPERVISOR');

Con la estructura anterior ya podemos gestionar nuestros usuarios con soporte de spring security.

El contenedor de beans de spring security quedaría de la siguiente manera:



 xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">

 
   access-decision-manager-ref="accessDecisionManager">

  
  
  
  

  
     login-page="/login.jsp" 
   default-target-url="/public/mostrarFormulario.htm" 
   authentication-failure-url="/loginerror.jsp"/>

  
  

  
     invalidate-session="true" 
   logout-url="/public/terminarSesion.htm"
   logout-success-url="/logout.jsp"  />

El proyecto completo te lo puedes bajar desde AQUI

Spring Security Mediante XML

2010-08-07T11:24:00.000-07:00

Hola que tal, ahora les voy a presentar una pequeña implementación de spring security, el caso de uso a implementar es el siguiente:

Permitir que la aplicación calculadora(formulario simple de ingreso de operandos y selección de operación) sea accedida mediante usuarios que previamente se han autenticado o que tambien sea accedida en forma anónima al seleccionar una lista de opciones.

1. Lo primero que tenemos que hacer es configurar un filtro en el descriptor de despliegue de nuestra aplicación web de la siguiente manera:



 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">

 
 
  calculadora-controller
  org.springframework.web.servlet.DispatcherServlet
  1
 
 
 
 
  calculadora-controller
  *.htm
 


 
 
  springSecurityFilterChain
  org.springframework.web.filter.DelegatingFilterProxy
 

 
 
  springSecurityFilterChain
  /*
 

 
 
  org.springframework.web.context.ContextLoaderListener
 
 
 
 
  contextConfigLocation
  
  /WEB-INF/calculadora-security.xml 
 

 
 
  index.jsp
 
 
 
 
        403
        /sinacceso.jsp

2. Ahora vamos a configurar los beans que conforman el controller de la aplicación, mediante anotaciones. El flujo de control de la aplicación es simple: define un archivo de inicio index.jsp que redirecciona hacia /public/iniciar.htm está ruta será interceptada por el filtro de spring security y como la URL es pública no necesitará de una autenticación, después llegará hacia el controller: @Controller public class CalculadoraController {...} que ha mapeado la URL solicitada y la redirigirá hacia la página jsp opciones.jsp. En la página de opciones es donde se prueba la seguridad implementanda mediante spring, en esta página listo 5 opciones de acceso(todas me conducen al formulario de la calculadora), la primera opción accesa al formulario en forma anónima, las 4 siguientes requieren una autenticación, si el usuario aún no se a autenticado es redirigido hacia login.jsp para que se autentique, si el usuario ingresa sus credenciales(usuario y passwords) y genera un error entonces es redirigido hacia loginerror.jsp, si el usuario se autentica satisfactoriamente pero no tiene permiso entonces generará un error 403(acceso denegado, el cual es definido en el descriptor de despliegue)



       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">
    
    
    
    

  p:basename="mensajes"/>
   
        p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>

3. Ahora lo más importante, la definición del contexto de seguridad mediante spring:



 xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">

 
   access-decision-manager-ref="accessDecisionManager">

  
  
  
  

  
     login-page="/login.jsp" 
   default-target-url="/public/mostrarFormulario.htm" 
   authentication-failure-url="/loginerror.jsp"/>

  
  

  
     invalidate-session="true" 
   logout-url="/public/terminarSesion.htm"
   logout-success-url="/logout.jsp"  />

El proyecto completo te lo puedes bajar desde AQUI

Spring Web Services y MTOM Parte 2

2010-07-27T20:58:00.000-07:00

Continuando con el post anterior ahora les voy a presentar el cliente del servicio web implementando mediante saaj y axiom integrado a spring. Veamos:

El cliente se despliega de la siguiente manera:

1. Maven ejecuta la clase principal CalculadoraClientWebServiceZip mediante un plugin:



  org.codehaus.mojo
  exec-maven-plugin 
  1.1.1
  
    
      
        java
      
    
  
  
    pe.com.slcsccy.pc.springws.client.CalculadoraClientWebServiceZip

2. La clase CalculadoraClientWebServiceZip crea los beans que se conectaran con el web service, este contenedor de beans se llama applicationContextZip.xml:



       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 
 
 
 
        
        
        
            
                C:\\logs\spring.config

Una vez creados los beans anteriores la aplicación cliente llamará al bean 'clienteWebServiceSaaj' y ejecutará el método enviarZip(nombreArchivo), este buscará en el sistema de archivos el archivo zip y lo enviará al web service, para poder hacer esto es necesario que previamente se hayan creado los proxies del web service mediante una llamada a la meta maven 'jaxb2:xjc', está meta buscará el schema XSD y generará las fuentes java, es decir realizará el binding entre el web service y su cliente. El plugin que implementa la meta maven se ejecuta como parte del proceso generate sources de maven, pero para evitar que eclipse me muestre errores de compilación la ejecuto antes:



org.codehaus.mojo
jaxb2-maven-plugin
1.3

  
    
     xjc
    
  


  src/main/resources
  src/main/java
  pe.com.slcsccy.pc.springws.client.schema
  false

La clase que crea el mensaje de envío al web service y que recepciona su respuesta mediante Saaj es la siguiente:CalculadoraClientSaajMTOM.java


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

import javax.activation.DataHandler;
import javax.activation.FileDataSource;

import org.springframework.ws.client.core.support.WebServiceGatewaySupport;
import org.springframework.ws.soap.saaj.SaajSoapMessageFactory;

import pe.com.slcsccy.pc.springws.client.schema.MensajeRequest;
import pe.com.slcsccy.pc.springws.client.schema.MensajeResponse;
import pe.com.slcsccy.pc.springws.client.schema.ObjectFactory;
import pe.com.slcsccy.pc.springws.client.schema.OperacionesZipType;

public class CalculadoraClientSaajMTOM extends WebServiceGatewaySupport {
 
 private ObjectFactory objectFactory = new ObjectFactory();
 
 public CalculadoraClientSaajMTOM(SaajSoapMessageFactory messageFactory) {
        super(messageFactory);
    }
 
 public MensajeResponse enviarZip(String nombreArchivo){
  MensajeRequest mensajeRequest = objectFactory.createMensajeRequest();
  OperacionesZipType zipType = new OperacionesZipType();
  zipType.setNombreArchivoZip(nombreArchivo);
  DataHandler handler = new DataHandler(new FileDataSource(nombreArchivo));
  zipType.setArchivoZip(handler);
  mensajeRequest.setOperacionesZip(zipType);
        Object respuesta = getWebServiceTemplate().marshalSendAndReceive(mensajeRequest);
        return (MensajeResponse)respuesta;
 } 
}

La clase que realiza lo mismo que la anterior pero mediante Axiom es la siguiente:CalculadoraClientAxiomMTOM.java


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

import java.io.IOException;
import java.util.Iterator;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.xml.namespace.QName;
import javax.xml.transform.TransformerException;

import org.apache.axiom.om.OMAttribute;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMNamespace;
import org.apache.axiom.om.OMOutputFormat;
import org.apache.axiom.om.OMText;
import org.apache.axiom.soap.SOAPBody;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axiom.soap.SOAPMessage;
import org.springframework.ws.WebServiceMessage;
import org.springframework.ws.client.core.WebServiceMessageCallback;
import org.springframework.ws.client.core.WebServiceMessageExtractor;
import org.springframework.ws.client.core.support.WebServiceGatewaySupport;
import org.springframework.ws.soap.axiom.AxiomSoapMessage;
import org.springframework.ws.soap.axiom.AxiomSoapMessageFactory;

public class CalculadoraClientAxiomMTOM extends WebServiceGatewaySupport {

 public CalculadoraClientAxiomMTOM(AxiomSoapMessageFactory messageFactory) {
        super(messageFactory);
    }
 
 public void enviarZip(final String nombreArchivo){
  
  WebServiceMessageCallback requestCallback = new WebServiceMessageCallback() {
            public void doWithMessage(WebServiceMessage message) throws IOException, TransformerException {
                AxiomSoapMessage soapMessage = (AxiomSoapMessage) message;
                SOAPMessage axiomMessage = soapMessage.getAxiomMessage();
                SOAPFactory factory = (SOAPFactory) axiomMessage.getOMFactory();
                
                //Armamos el contenido del mensaje:
                SOAPBody cuerpoMensaje = axiomMessage.getSOAPEnvelope().getBody();
                OMNamespace ns = factory.createOMNamespace("http://www.slcsccy.com.pe/pc/springws/calculadora", "calc");
                OMElement mensajeRequestElement = factory.createOMElement("mensajeRequest",ns);
                cuerpoMensaje.addChild(mensajeRequestElement);
                OMElement operacionesZipElement = factory.createOMElement("operacionesZip", ns);
                
                //Creo el archivo zip
                OMAttribute nombreArchivoZipAttribute = factory.createOMAttribute("nombreArchivoZip",ns,nombreArchivo);
                operacionesZipElement.addAttribute(nombreArchivoZipAttribute);
                OMElement archivoZipElement = factory.createOMElement("archivoZip", ns);
                DataSource dataSource = new FileDataSource(nombreArchivo);
                DataHandler dataHandler = new DataHandler(dataSource);
                OMText archivoZipText = factory.createOMText(dataHandler, true);
                archivoZipElement.addChild(archivoZipText);
                operacionesZipElement.addChild(archivoZipElement);
                mensajeRequestElement.addChild(operacionesZipElement);

                OMOutputFormat outputFormat = new OMOutputFormat();
                outputFormat.setSOAP11(true);
                outputFormat.setDoOptimize(true);
                soapMessage.setOutputFormat(outputFormat);
            }
        };
  
        WebServiceMessageExtractor responseExtractor = new WebServiceMessageExtractor() {
            @SuppressWarnings("unchecked")
   public Object extractData(WebServiceMessage message) throws IOException, TransformerException {
             AxiomSoapMessage mensajeAxiom = (AxiomSoapMessage)message;
             SOAPMessage mensaje = mensajeAxiom.getAxiomMessage();
             SOAPEnvelope envelope = mensaje.getSOAPEnvelope();
             SOAPBody body = envelope.getBody();
             
             OMElement mensajeResponse = body.getFirstElement();
             OMElement resultados = mensajeResponse.getFirstElement();
             
             StringBuilder salida = new StringBuilder();
             Iterator resultadosElement =  resultados.getChildren();
             QName atributoId = new QName("http://www.slcsccy.com.pe/pc/springws/calculadora","id");
             while(resultadosElement.hasNext()){
              OMElement elemento = resultadosElement.next();
              salida.append("id:"+elemento.getAttributeValue(atributoId)+",valor:"+elemento.getText()+"\n");
             }
             
             logger.info("salida retorno:"+salida.toString());
                return salida.toString();
            }
        };
        
  @SuppressWarnings("unused")
  String response = (String)getWebServiceTemplate().sendAndReceive(requestCallback,responseExtractor);
 }
}

Una vez creado el proxy del web service ahora podemos conectarnos al web service y obtener los resultados esperados, veamos el log del cliente:


2010-07-27 23:35:27 (AbstractBeanFactory.java:241) - Returning cached instance of singleton bean 'clienteWebServiceSaaj'
2010-07-27 23:35:27 (WebServiceAccessor.java:110) - Opening [org.springframework.ws.transport.http.HttpUrlConnection@372a54] to [http://localhost:7001/springws/serviciosWeb]
2010-07-27 23:35:28 (WebServiceTemplate.java:581) - Sent request [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:35:35 (WebServiceTemplate.java:639) - Received response [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeResponse] for request [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]

Ahora veamos el log del web service:


2010-07-27 23:35:34 (WebServiceMessageReceiverObjectSupport.java:114) - Accepting incoming [org.springframework.ws.transport.http.HttpServletConnection@ea0dfc] to [http://localhost:7001/springws/serviciosWeb]
2010-07-27 23:35:34 (MessageDispatcher.java:167) - Received request [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:35:34 (AbstractMethodEndpointMapping.java:62) - Looking up endpoint for [{http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:35:34 (MessageDispatcher.java:256) - Endpoint mapping [org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping@3311c0] maps request to endpoint [public pe.com.slcsccy.pc.springws.schema.MensajeResponse pe.com.slcsccy.pc.springws.ws.CalculadoraEndpointWithAnnotation.calcular(pe.com.slcsccy.pc.springws.schema.MensajeRequest) throws javax.xml.datatype.DatatypeConfigurationException,pe.com.slcsccy.pc.springws.exception.OperandoInvalidoException,pe.com.slcsccy.pc.springws.exception.UnzipException]
2010-07-27 23:35:34 (AbstractValidatingInterceptor.java:179) - Request message validated
2010-07-27 23:35:34 (AbstractLoggingInterceptor.java:160) - Request: UEsDBBQAAAAIAE26+TxJUMN0JgAAACgAAAAPAAAAb3BlcmFjaW9uZXMudHh0PcixCQAgEATB/OEa0RV8T9D+K/Mjs2EaOVlsRf+qS2ysGJxbr3hQSwECFAAUAAAACABNuvk8SVDDdCYAAAAoAAAADwAAAAAAAAAAACAAAAAAAAAAb3BlcmFjaW9uZXMudHh0UEsFBgAAAAABAAEAPQAAAFMAAAAAAA==
2010-07-27 23:35:34 (MessageDispatcher.java:277) - Testing endpoint adapter [org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter@1d33c09]
2010-07-27 23:35:35 (MarshallingMethodEndpointAdapter.java:146) - Unmarshalled payload request to [pe.com.slcsccy.pc.springws.schema.MensajeRequest@1ea9700]
2010-07-27 23:35:35 (AbstractBeanFactory.java:241) - Returning cached instance of singleton bean 'calculadoraEndpoint'
2010-07-27 23:35:35 (MarshallingMethodEndpointAdapter.java:153) - Marshalling [pe.com.slcsccy.pc.springws.schema.MensajeResponse@1fcbeda] to response payload
2010-07-27 23:35:35 (AbstractLoggingInterceptor.java:160) - Response: 8016108968
2010-07-27 23:35:35 (AbstractValidatingInterceptor.java:221) - Response message validated
2010-07-27 23:35:35 (MessageDispatcher.java:178) - Sent response [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeResponse] for request [SaajSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:35:35 (FrameworkServlet.java:677) - Successfully completed request

Con Axion el log en el cliente es el siguiente:


2010-07-27 23:43:35 (AbstractBeanFactory.java:241) - Returning cached instance of singleton bean 'lifecycleProcessor'
2010-07-27 23:43:35 (AbstractBeanFactory.java:241) - Returning cached instance of singleton bean 'clienteWebServiceAxiom'
2010-07-27 23:43:35 (WebServiceAccessor.java:110) - Opening [org.springframework.ws.transport.http.HttpUrlConnection@1f4d2b] to [http://localhost:7001/springws/serviciosWeb]
2010-07-27 23:43:35 (WebServiceTemplate.java:581) - Sent request [AxiomSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:43:35 (OMOutputFormat.java:140) - Start getContentType: OMOutputFormat [ mimeBoundary =null rootContentId=null doOptimize=true doingSWA=false isSOAP11=true charSetEncoding=null xmlVersion=null contentType=null ignoreXmlDeclaration=false autoCloseWriter=false actionProperty=null optimizedThreshold=0]
2010-07-27 23:43:35 (OMOutputFormat.java:166) - getContentType= {multipart/related; boundary="MIMEBoundary_be673ed239be738d78bcea194265e824bd3e5e2b92766546"; type="application/xop+xml"; start="<0.ae673ed239be738d78bcea194265e824bd3e5e2b92766546@apache.org>"; start-info="text/xml"}   OMOutputFormat [ mimeBoundary =MIMEBoundary_be673ed239be738d78bcea194265e824bd3e5e2b92766546 rootContentId=0.ae673ed239be738d78bcea194265e824bd3e5e2b92766546@apache.org doOptimize=true doingSWA=false isSOAP11=true charSetEncoding=null xmlVersion=null contentType=text/xml ignoreXmlDeclaration=false autoCloseWriter=false actionProperty=null optimizedThreshold=0]
2010-07-27 23:43:35 (MTOMXMLStreamWriter.java:91) - OutputStream =class org.springframework.ws.transport.AbstractSenderConnection$RequestTransportOutputStream
2010-07-27 23:43:35 (MTOMXMLStreamWriter.java:92) - OMFormat = OMOutputFormat [ mimeBoundary =MIMEBoundary_be673ed239be738d78bcea194265e824bd3e5e2b92766546 rootContentId=0.ae673ed239be738d78bcea194265e824bd3e5e2b92766546@apache.org doOptimize=true doingSWA=false isSOAP11=true charSetEncoding=null xmlVersion=null contentType=text/xml ignoreXmlDeclaration=false autoCloseWriter=false actionProperty=null optimizedThreshold=0]
2010-07-27 23:43:35 (StAXUtils.java:615) - About to create XMLOutputFactory implementation with classloader=java.net.URLClassLoader@32d985
2010-07-27 23:43:35 (StAXUtils.java:617) - The classloader for javax.xml.stream.XMLOutputFactory is: null
2010-07-27 23:43:35 (StAXDialectDetector.java:219) - StAX implementation at jar:file:/I:/repo-maven/org/codehaus/woodstox/wstx-asl/3.2.9/wstx-asl-3.2.9.jar!/ is:
  Title:         WoodSToX XML-processor
  Symbolic name: null
  Vendor:        woodstox.codehaus.org
  Version:       3.2.9
2010-07-27 23:43:35 (StAXDialectDetector.java:181) - Detected StAX dialect: Woodstox
2010-07-27 23:43:35 (StAXUtils.java:635) - Created XMLOutputFactory = class org.apache.axiom.util.stax.wrapper.ImmutableXMLOutputFactory for classloader=java.net.URLClassLoader@32d985
2010-07-27 23:43:35 (StAXUtils.java:637) - Size of XMLOutputFactory map =1
2010-07-27 23:43:35 (StAXUtils.java:352) - XMLStreamWriter is org.apache.axiom.util.stax.dialect.WoodstoxStreamWriterWrapper
2010-07-27 23:43:35 (OptimizationPolicyImpl.java:60) - Start MTOMXMLStreamWriter.isOptimizedThreshold()
2010-07-27 23:43:35 (OptimizationPolicyImpl.java:65) - DataHandler fetched, starting optimized Threshold processing
2010-07-27 23:43:35 (OptimizationPolicyImpl.java:71) - node should be added to binart NodeList for optimization
2010-07-27 23:43:35 (MTOMXMLStreamWriter.java:182) - Calling MTOMXMLStreamWriter.flush
2010-07-27 23:43:35 (MTOMXMLStreamWriter.java:190) - The XML writing is completed.  Now the attachments are written
2010-07-27 23:43:35 (MTOMXMLStreamWriter.java:172) - close
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement Envelope by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement Header by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement Body by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement mensajeResponse by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (WebServiceTemplate.java:639) - Received response [AxiomSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeResponse] for request [AxiomSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:43:36 (WebServiceTemplate.java:639) - Received response [AxiomSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeResponse] for request [AxiomSoapMessage {http://www.slcsccy.com.pe/pc/springws/calculadora}mensajeRequest]
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement resultados by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement resultado by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement resultado by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement resultado by the StaxSOAPModelBuilder
2010-07-27 23:43:36 (StAXSOAPModelBuilder.java:278) - Build the OMElement resultado by the StaxSOAPModelBuilder

El proyecto completo en eclipse te lo puedes bajar desde AQUI

Spring Web Services y MTOM Parte 1

2010-07-26T21:05:00.000-07:00

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

PLSQL Básico2

2010-05-24T19:20:00.000-07:00

Más ejemplos sobre PLSQL, en este post veamos como podemos crear procedimientos que utilicen arrays,collections y estructuras de datos derivadas de estos

Ejemplo 1: Muestra el uso de arrays asociativos
Definimos un tipo de la forma: TYPE miHashType IS TABLE OF NUMBER INDEX BY VARCHAR2(6);
La clausula TYPE especifica que vamos a definir un nuevo tipo.
El código miHashType es el nombre del nuevo tipo, es como una nueva clase
La clausula IS TABLE OF NUMBER indica que el arreglo asociativo va a tener valores de tipo NUMBER
La clausula BY VARCHAR2(5) indica que los valores de los indices van a ser del tipo VARCHAR2(6)


CREATE OR REPLACE PROCEDURE collection01 IS 

TYPE miHashType IS TABLE OF NUMBER INDEX BY VARCHAR2(6);
arreglo1 miHashType;
arreglo2 miHashType;

TYPE miEmployeeType IS TABLE OF employees%rowtype INDEX BY PLS_INTEGER;
empleadosArray miEmployeeType;

-- Los tipos anidados pueden almacenar un número ilimitado de elementos
TYPE miTableType IS TABLE OF VARCHAR2(20);
arregloV1 miTableType;
arregloV2 miTableType;

-- Los tipos varray tienen un número máximo de elementos
TYPE miArregloType IS VARRAY(4) OF VARCHAR2(10);
varreglo1 miArregloType;
varreglo2 miArregloType;

BEGIN
  -- Agregamos 3 entradas al primer arreglo:
  arreglo1('clave1') := 666;
  arreglo1('clave2') := 667;
  arreglo1('clave3') := 668;
  
  -- Agregamos 3 entradas al primer arreglo:
  arreglo2('clave1') := 100;
  arreglo2('clave2') := 101;
  arreglo2('clave3') := 102;
  arreglo2('clave4') := 103;
  arreglo2('clave5') := 104;
  arreglo2('clave6') := 105;
  
  -- Ahora mostramos los valores deacuerdo a su clave:
  dbms_output.put_line('El valor del arreglo asociativo arreglo2(''clave2''):'||arreglo2('clave2'));
  
  -- Obtenemos los datos de un empleado:
  SELECT * INTO empleadosArray(100) FROM employees WHERE employee_id = 100;
  dbms_output.put_line('Nombre del empleado: '||empleadosArray(100).first_name);
  dbms_output.put_line('Apellidos del empleado: '||empleadosArray(100).last_name);
  dbms_output.put_line('Email del empleado: '||empleadosArray(100).email);
  
  -- Ahora asignamos los valores a los arreglos:
  arregloV1 := miTableType('carlos','alberto','cacique','yupanqui','certificado','en','java','y','oracle');
  arregloV2 := miTableType('zaida','angelica');
  varreglo1 := miArregloType('uno','dos');
  -- Con el metodo EXTEND extendemos el arreglo dinamico, el primer argument 
  -- especifica cuantos elementos más creamos y el segundo el valor que se va a 
  -- copiar de los elementos existentes a los elementos nuevos
  varreglo1.EXTEND(2,1);
  --varreglo1(3) := 'tres';
  --varreglo1(4) := 'cuatro';
  varreglo2 := miArregloType('primero','segundo','tercero','cuarto');
  
  -- Ahora mostramos los valores de los tipos anidados;
  FOR i IN arregloV1.FIRST..arregloV1.LAST LOOP
   dbms_output.put_line('arregloV1('||i||'):'||arregloV1(i));
  END LOOP;
  FOR i IN arregloV2.FIRST..arregloV2.LAST LOOP
     dbms_output.put_line('arregloV2('||i||'):'||arregloV2(i));
  END LOOP;
  
  
  -- Ahora mostramos los valores de los tipos varrays
  FOR i IN varreglo1.FIRST..varreglo1.LAST LOOP
     dbms_output.put_line('varreglo1('||i||'):'||varreglo1(i));
  END LOOP;
  FOR i IN varreglo2.FIRST..varreglo2.LAST LOOP
       dbms_output.put_line('varreglo2('||i||'):'||varreglo2(i));
  END LOOP;
  
END collection01;

Ejemplo 2:
Ahora veremos como declarar un tipo complejo con TYPE... IS RECORD, despues creamos un tipo anidado con el tipo creado anteriormente, una vez creado el tipo anidado, creamos una variable del tipo anidado, todo esto para poder mantener los datos que más tarde nos retornará un cursor.
Después declaramos un tipo cursor y creamos una variable, más adelante en el cuerpo del procedimiento abrimos el cursor para un SELECT específico y cargamos la variable coleccion con los datos del cursor por medio de la clausula FETCH <cursor> BULK COLLECTION INTO <coleccion>, al final del procedimiento solo mostramos los datos pero desde la colección.


CREATE OR REPLACE PROCEDURE collection02 IS

  -- Declaramos un tipo de dato complejo
  TYPE emp_name_rec IS RECORD (
    firstname    employees.first_name%TYPE,
    lastname     employees.last_name%TYPE,
    hiredate     employees.hire_date%TYPE
  );
    
  -- Tipo Tabla que puede mantener información acerca de los empleados
  TYPE EmpList_tab IS TABLE OF emp_name_rec;
  SeniorSalespeople EmpList_tab;   
   
  -- Declaramos una referencia a un cursor para seleccionar un subconjunto de columnas.
  EndCounter NUMBER := 10;
  TYPE EmpCurTyp IS REF CURSOR;
  emp_cv EmpCurTyp; 
   
BEGIN
  -- Abrimos el cursor con la sentencia SELECT indicada
  OPEN emp_cv FOR SELECT first_name, last_name, hire_date FROM employees 
  WHERE job_id = 'SA_REP' ORDER BY hire_date;

  -- Sacamos los datos del cursor y los colocamos dentro de la coleccion
  FETCH emp_cv BULK COLLECT INTO SeniorSalespeople;
  
  -- Cerramos el cursor
  CLOSE emp_cv;

  -- Para este ejemplo mostramos un máximo de 10 empleados
  IF SeniorSalespeople.LAST > 0 THEN
    IF SeniorSalespeople.LAST < 10 THEN EndCounter := SeniorSalespeople.LAST; 
    END IF;
    FOR i in 1..EndCounter LOOP
      DBMS_OUTPUT.PUT_LINE(SeniorSalespeople(i).lastname || ', ' 
      || SeniorSalespeople(i).firstname || ', ' || SeniorSalespeople(i).hiredate);
    END LOOP;
  END IF;
END collection02;

Ejemplo 3: En este ejemplo se muestra la eficiencia de la clausula FORALL a diferencia de la clausula FOR LOOP con tipos anidados:


CREATE OR REPLACE PROCEDURE COLLECTION03 IS
  -- Definimos des tipos de datos anidados
  TYPE NumTab IS TABLE OF parts1.pnum%TYPE INDEX BY PLS_INTEGER;
  TYPE NameTab IS TABLE OF parts1.pname%TYPE INDEX BY PLS_INTEGER;
  -- Declaramos variables de los tipos definidos anteriormente
  pnums  NumTab;
  pnames NameTab;
  -- Cuantas veces vamos a iterar
  iterations CONSTANT PLS_INTEGER := 10000;
  -- Variables que nos van a ayudar a medir el tiempo
  t1 INTEGER;
  t2 INTEGER;
  t3 INTEGER;
BEGIN
  FOR j IN 1..iterations LOOP  -- load index-by tables
     pnums(j) := j;
     pnames(j) := 'Part No. ' || TO_CHAR(j);
  END LOOP;
  t1 := DBMS_UTILITY.get_time;
  FOR i IN 1..iterations LOOP  -- use FOR loop
     INSERT INTO parts1 VALUES (pnums(i), pnames(i));
  END LOOP;
  t2 := DBMS_UTILITY.get_time;
  FORALL i IN 1..iterations  -- use FORALL statement
     INSERT INTO parts2 VALUES (pnums(i), pnames(i));
  t3 := DBMS_UTILITY.get_time;
  DBMS_OUTPUT.PUT_LINE('Tiempo de ejecución en segundos');
  DBMS_OUTPUT.PUT_LINE('---------------------');
  DBMS_OUTPUT.PUT_LINE('FOR LOOP: ' || TO_CHAR((t2 - t1)));
  DBMS_OUTPUT.PUT_LINE('FORALL:   ' || TO_CHAR((t3 - t2)));
  COMMIT;
END COLLECTION03;

Ejemplo 4: Ejemplo de uso de operaciones de comparacion con operadores SET:


CREATE OR REPLACE PROCEDURE COLLECTION04 IS

  TYPE nested_typ IS TABLE OF NUMBER;
    nt1 nested_typ := nested_typ(1,2,3);
    nt2 nested_typ := nested_typ(3,2,1);
    nt3 nested_typ := nested_typ(2,3,1,3);
    nt4 nested_typ := nested_typ(1,2,4);
    respuesta BOOLEAN;
    cantidad NUMBER;
    
    -- Definimos un procedimiento que mostrará una cadena de caracteres y una cantidad
    PROCEDURE imprimir(truth BOOLEAN DEFAULT NULL, quantity NUMBER DEFAULT NULL) IS
    BEGIN
      IF truth IS NOT NULL THEN
        DBMS_OUTPUT.PUT_LINE(CASE truth WHEN TRUE THEN 'True' WHEN FALSE THEN 'False' END);
      END IF;
      IF quantity IS NOT NULL THEN
          DBMS_OUTPUT.PUT_LINE(quantity);
      END IF;
    END;
  BEGIN
    -- La variable anidada nt1 se encuentra en el subconjunto especificado por IN?
    -- Sí, nt1 coincide con nt2 que se encuentra en la clausula IN
    respuesta := nt1 IN (nt2,nt3,nt4); 
    imprimir(truth => respuesta);
    
    -- La variable anidada nt1 es un subconjunto de la variable nt3
    -- Sí, todos los elementos coinciden
    respuesta := nt1 SUBMULTISET OF nt3; 
    imprimir(truth => respuesta);
    
    -- La variable anidada no es un subconjunto de la variable anidada nt4?
    -- Sí, la variable NO lo es.
    respuesta := nt1 NOT SUBMULTISET OF nt4;
    imprimir(truth => respuesta);
    
    -- CARDINALITY retorna el numero de elementos de la variable anidada nt3
    cantidad := CARDINALITY(nt3);
    imprimir(quantity => cantidad);
    
    -- CARDINALITY(SET(?)) muestra el número de elementos distintos en la variable
    cantidad := CARDINALITY(SET(nt3));
    imprimir(quantity => cantidad);
    
    -- El elemento con valor 4 es un miembro de la variable nt1?
    -- No, ese elemento no existe en la variable anidada.
    respuesta := 4 MEMBER OF nt1;
    imprimir(truth => respuesta);
    
    -- La variable nt3 es un SET, es decir no tiene duplicados?
    -- NO, la variable tiene duplicados, por lo tanto no es un SET
    respuesta := nt3 IS A SET;
    imprimir(truth => respuesta);
    
    -- La variable nt3 no es un SET?
    -- Sí dicha variable no es un SET porque contiene elementos duplicados.
    respuesta := nt3 IS NOT A SET;
    imprimir(truth => respuesta);
    
    -- La variable nt1 no tiene elementos?
    -- falso, dicha variable si tiene elementos.
    respuesta := nt1 IS EMPTY;
    imprimir(truth => respuesta);
   
END COLLECTION05;

Ejemplo 5: Operaciones con los diferentes métodos implícitos de la colecciones.

lista.EXIST(n), lista, es una variable de tipo anidada o varray y n es el indice de un elemento en la lista
lista.COUNT, retorna el número de elementos que la lista actualmente contiene.
lista.LIMIT, retorna el tamaño máximo de la tabla anidada.
lista.TRIM, remueve un elemento del final de la lista, si le especificasmo un argumentoentonces removerá la cantidad especificada.


CREATE OR REPLACE PROCEDURE COLLECTION05 IS

  -- Definimos un tipo anidado de enteros
  TYPE listaNumerosType IS TABLE OF INTEGER;
  lista listaNumerosType := listaNumerosType(1,3,5,7);
   
  BEGIN
   dbms_output.put_line('Cantidad de elementos de la lista 1:'||lista.COUNT);
   -- Borramos el segundo elemento:
   lista.DELETE(2); 
   dbms_output.put_line('Cantidad de elementos de la lista 2:'||lista.COUNT);
   
   -- Si en la lista existe el elemento con indice 1 entonces hacer:
   IF lista.EXISTS(1) THEN
      DBMS_OUTPUT.PUT_LINE('El element #1 existe.');
   END IF;
   -- Si en la lista no existe el elemento con indice 2 entonces hacer
   IF lista.EXISTS(2) = FALSE THEN
      DBMS_OUTPUT.PUT_LINE('El elemento #2 ha sido borrado.');
   END IF;
   
   -- Agregamos un par de elementos más a la lista y volvemos a hacer COUNT
   lista.EXTEND(5);
   lista(5) := 9;
   dbms_output.put_line('Cantidad de elementos de la lista 3:'||lista.COUNT);
   dbms_output.put_line('Limite de elementos de la lista :'||lista.LIMIT);
   -- Removera 2 elementos del final de la coleccion, ojo que TRIM solo removerá uno
   lista.TRIM(2);
   dbms_output.put_line('Cantidad de elementos de la lista despues de TRIM:'||lista.COUNT);
   dbms_output.put_line('Limite de elementos de la lista despues de TRIM:'||lista.LIMIT);
   
   -- Usando los metodos first, prior, next y last
   dbms_output.put_line('lista.FIRST:'||lista.FIRST);
   dbms_output.put_line('lista.LAST:'||lista.LAST);
   dbms_output.put_line('lista.PRIOR(2):'||lista.PRIOR(2));
   dbms_output.put_line('lista.NEXT(2):'||lista.NEXT(2));
   
END COLLECTION05;

PLSQL Básico1

2010-05-24T16:19:00.000-07:00

Encontré varios ejemplos de hace varios años cuando aprendía plsql, allí les dejo algunos ejemplitos, ojalá les sirvan:

Ejemplo 1: Lo unico que hace es mostrar una linea en consola.


CREATE OR REPLACE PROCEDURE proc01 IS
BEGIN
  dbms_output.put_line('Hola mundo con los procedimientos de Oracle');
END;

Ejemplo 2: Igual que el anterior pero ahora la ultima línea finaliza con el nombre del procedimiento... buena practica!


CREATE OR REPLACE PROCEDURE proc02 IS
BEGIN
  dbms_output.put_line('Otro procedimiento pero ahora con otro texto');
END proc02;

Ejemplo 3: Uso de la clausula %TYPE y %ROWTYPE, la clausula %TYPE sirve para asignar los tipos de datos heredados de otras variables en tiempo de ejecución lo mismo para %ROWTYPE que actua a nivel de fila


CREATE OR REPLACE PROCEDURE proc03 IS
  v_fecha_sistema DATE;
  v_fecha_contratacion v_fecha_sistema%TYPE;
  v_salario employees.salary%TYPE;
  reg_empleados employees%ROWTYPE; 
BEGIN
  SELECT sysdate INTO v_fecha_sistema FROM dual;
  SELECT * INTO reg_empleados FROM employees WHERE employee_id=200;
  v_salario := reg_empleados.salary;
  v_fecha_contratacion := reg_empleados.hire_date;
  dbms_output.put_line('El nombre del empleado es:'||reg_empleados.first_name);
  dbms_output.put_line('El salario del empleado es:'||v_salario);
  dbms_output.put_line('La fecha de contratación del empleado es:'||v_fecha_contratacion);
  dbms_output.put_line('La fecha del sistema es:'||v_fecha_sistema);
END proc03;

Ejemplo 4: Muestra el uso de etiquetas para resolucion de nombres de variables, analiza el ámbito de la variable v_cantidad


CREATE OR REPLACE PROCEDURE proc04 IS
BEGIN
  <<ambito_externo>>
  DECLARE 
  v_cantidad NUMBER := 100;
  BEGIN
    DECLARE
    v_cantidad NUMBER := 150;
    BEGIN
    -- Inicio de un bloque de codigo interno
    dbms_output.put_line('Valor de la variable interna:'||v_cantidad);
    dbms_output.put_line('Valor de la variable externa:'||ambito_externo.v_cantidad);
    END;
    -- Aqui podemos continuar con los datos de la variable etiquetada externamente
    dbms_output.put_line('Valor de la variable:'||v_cantidad);
  END;
END proc04;

Ejemplo 5: Podemos crear funciones dentro del procedimiento y usarlas en el mismo procedimiento.


CREATE OR REPLACE PROCEDURE proc05 IS
  
  -- Funcion sumar:
  FUNCTION sumar(ope1 IN NUMBER,ope2 IN NUMBER) RETURN NUMBER IS
  BEGIN
    RETURN ope1+ope2;
  END sumar;
  
  -- Funcion restar:
  FUNCTION restar(ope1 IN NUMBER,ope2 IN NUMBER) RETURN NUMBER IS
  BEGIN
    RETURN ope1-ope2;
  END restar;
  
  -- Funcion multiplicar:
  FUNCTION multiplicar(ope1 IN NUMBER,ope2 IN NUMBER) RETURN NUMBER IS
  BEGIN
    RETURN ope1*ope2;
  END multiplicar;
  
  -- Funcion dividir:
  FUNCTION dividir(ope1 IN NUMBER,ope2 IN NUMBER) RETURN NUMBER IS
  BEGIN
    RETURN ope1/ope2;
  END dividir;
  
BEGIN
  dbms_output.put_line('Suma de 15 y 45: '||sumar(15,45));
  dbms_output.put_line('Resta de 15 y 45: '||restar(15,45));
  dbms_output.put_line('Multiplicacion de 15 y 45: '||multiplicar(15,45));
  dbms_output.put_line('Division de 15 y 45: '||dividir(15,45));
END proc05;

Ejemplo 6: Muestra el uso de las estructuras de control condicional IF-THEN e IF-THEN-ELSE


CREATE OR REPLACE
PROCEDURE proc06(vi_cantidad_minima IN INTEGER) IS
  v_sueldo_base NUMBER := 4000;
  v_cantidad_empleados INTEGER := 0;
BEGIN
  --Obtenemos la cantidad de empleados que tienen un sueldo mayor al sueldo base
  SELECT COUNT(employee_id) INTO v_cantidad_empleados FROM employees 
  WHERE salary > v_sueldo_base;
  
  -- Testeamos si la cantidad de empleados es mayor a una constante
  dbms_output.put_line('La cantidad de empleados es:'||v_cantidad_empleados); 
  dbms_output.put_line('-----------------------------------------------------'); 
  dbms_output.put_line('Uso de las estructura if-then'); 
  IF v_cantidad_empleados > vi_cantidad_minima THEN
    dbms_output.put_line('La cantidad de empleados:'||v_cantidad_empleados||', ES MAYOR a la minima');  
  END IF;
  
  dbms_output.put_line('Uso de las estructura if-then-else'); 
  IF v_cantidad_empleados > vi_cantidad_minima THEN
    dbms_output.put_line('La cantidad de empleados:'||v_cantidad_empleados||', ES MAYOR a la minima');  
  ELSE
    dbms_output.put_line('La cantidad de empleados:'||v_cantidad_empleados||', NO ES MAYOR a la minima');  
  END IF;
  
END proc06;

Ejemplo 7: Muestra el uso de las estructuras de control iterativas LOOP y EXIT


CREATE OR REPLACE
PROCEDURE proc07(vi_cantidad_iteraciones IN INTEGER) IS
  v_contador1 INTEGER := 0;
  v_contador2 INTEGER := 0;
BEGIN
  -- Primero con una declaración EXIT para salir de un bucle.
  dbms_output.put_line('Iteracion con clausula EXIT');
  LOOP
    IF v_contador1 = vi_cantidad_iteraciones THEN
      EXIT;
    ELSE
      dbms_output.put_line('Iterando con EXIT');    
    END IF;
    v_contador1 := v_contador1 + 1;
  END LOOP;
  
  --Ahora iteramos pero con la clausula EXIT WHEN
  v_contador1 := 0;
  dbms_output.put_line('Iteracion con la clausula EXIT WHEN');
  LOOP
  v_contador1 := v_contador1 + 1;
  dbms_output.put_line('Iterando con EXIT WHEN');    
    EXIT WHEN v_contador1 >= 20;
  END LOOP;
  
  --Ahora iteramos con la clausula EXIT WHEN con etiquetas
  v_contador1 := 0;
  v_contador2 := 0;
  dbms_output.put_line('Iteracion con la clausula EXIT WHEN CON ETIQUETAS');
  <<externo>>
  LOOP
    v_contador1 := v_contador1 + 1;
    dbms_output.put_line('Iterando con EXIT WHEN');    
    v_contador2 := 0;
    <<interno>>
    LOOP
     v_contador2 := v_contador2 + 1;
 dbms_output.put_line('Iterando con EXIT WHEN ANIDADO');
        EXIT externo WHEN (v_contador1 = 2 AND v_contador2 = 3);  
        EXIT interno WHEN v_contador2 >= 3;
    END LOOP;
    EXIT externo WHEN v_contador1 >= 3;
  END LOOP;
    
END proc07;

Ejemplo 8: Muestra el uso de estructuras de iteracion WHILE-LOOP-END LOOP con EXIT y etiquetas


CREATE OR REPLACE
PROCEDURE proc08(vi_cantidad_iteraciones IN INTEGER) IS
  v_contador1 INTEGER := 0;
  v_contador2 INTEGER := 0;
  v_contador3 INTEGER := 0;
BEGIN  
  --Ahora iteramos con la clausula EXIT WHEN con etiquetas
  v_contador1 := 0;
  v_contador2 := 0;
  dbms_output.put_line('Iteracion con la clausula EXIT WHEN CON ETIQUETAS');
  <<externo>>
  LOOP
    v_contador1 := v_contador1 + 1;
    dbms_output.put_line('Iterando con EXIT WHEN');    
    v_contador2 := 0;
    <<interno>>
    LOOP
     v_contador2 := v_contador2 + 1;
 dbms_output.put_line('Iterando con EXIT WHEN ANIDADO'); 
 v_contador3 := 0;
 WHILE (v_contador3 < 5 ) LOOP
   v_contador3 := v_contador3 + 1;
   dbms_output.put_line('Iterando con EXIT WHEN ANIDADO CON WHILE-LOOP-END LOOP');
 END LOOP;
        EXIT externo WHEN (v_contador1 = 2 AND v_contador2 = 3);  
        EXIT interno WHEN v_contador2 >= 3;
    END LOOP;
    EXIT externo WHEN v_contador1 >= 3;
  END LOOP;   
END proc08;

Pruebas de Software con TestNG Parte 1

2010-05-24T09:01:00.000-07:00

TestNG es un framework de pruebas de software diseñado para simplificar un conjunto extenso de necesidades de prueba, desde pruebas unitarias(probar una clase java aislada de otras) hasta pruebas de integración(probar sistemas enteros implementados con muchas clases, muchos paquetes e incluso frameworks externos como servidores de aplicaciones). Escribir una prueba de software consiste tipicamente de un proceso en tres pasos:

Escribe la lógica de negocio de tu prueba e inserta anotaciones(por ejemplo @Test) de TestNG en tu código.
Agrega la información acerca de tu prueba( por ejemplo el nombre de la clase, los grupos que deseas ejecutar, etc...) en un archivo testng.xml o en un build.xml
Ejecuta tus pruebas de software.

Los conceptos usados por este framework son los que siguen:

Una conjunto de pruebas de software es representado por un archivo XML, este archivo contiene una o más pruebas(tests) y es definida por la etiqueta <suite>.
Una prueba es representada por una etiqueta <test> y puede contener una o más clases TestNG.
Una clase TestNG es una clase java que contiene al menos una anotación TestNG(@Test), es representada por la etiqueta <class> y puede contener uno o más métodos de prueba.
Un método de prueba es un método java anotado con @Test en tu código fuente.

Un ejemplo de lo anterior lo podemos ver en el siguiente archivo:

Spring, JUnit4 y Maven

2010-05-12T19:31:00.000-07:00

Esta vez vamos a ver como podemos crear nuestras pruebas unitarias mediante junit4.4 sean estas pruebas simples o transaccionales, veamos primero que es lo que vamos a probar:

Ejemplo 1; Una clase calculadora simple:


package pe.com.slcsccy.ejemplos.spring.junit4.service;
import java.math.BigDecimal;
import org.springframework.stereotype.Service;

@Service("calculadoraService")
public class CalculadoraServiceImpl implements CalculadoraService{

public BigDecimal dividir(BigDecimal operador1, BigDecimal operador2) {
return operador1.divide(operador2);
}

public BigDecimal multiplicar(BigDecimal operador1, BigDecimal operador2) {
return operador1.multiply(operador2);
}

public Long restar(Long operador1, Long operador2) {
return operador1 - operador2;
}

public Long sumar(Long operador1, Long operador2) {
return operador1 + operador2;
}

}

Y ahora veamos la clase de Test asociada a la calculadora:


package pe.com.slcsccy.ejemplos.spring.junit4.service;
import static junit.framework.Assert.assertEquals;
import java.math.BigDecimal;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
* Para que está clase ejecute test unitarios, debe de estar anotada con 'RunWith'
* cuyo valor es la clase SpringJUnit4ClassRunner, esta clase hereda de la clase Runner de junit4
* que declara un método abstracto run que Spring implementa.
* Para poder inyectar los beans de spring lo hacemos mediante la anotación
* 'ContextConfiguration' que espera la ruta o classpath donde se encuentran los contenedores
* de beans(*.xml)
* */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:/ejemplos-junit4-all.xml"})
public class CalculadoraServiceTest{


//Inyectamos el bean instanciado por Spring
@Autowired
private CalculadoraService calculadoraService;


//Creamos un log
private static Log logger = LogFactory.getLog("pe.com.slcsccy.ejemplos.spring.junit4.service.CalculadoraServiceTest");


//Los métodos anotados con @BeforeClass serán ejecutados una vez por
//cada instancia de esta clase al crearse la clase.
@BeforeClass
public static void inicializacionClass(){
logger.info("Inicialización de la clase de Test...!");
}

//Los métodos anotados con @AfterClass serán ejecutados una vez por
//cada instancia de esta clase al terminar la ejecución de todos los métodos de prueba.
@AfterClass
public static void finalizacionClass(){
logger.info("Finalización de la clase de Test...!");
}

//La anotación @Before pertenece a junit4.4 y le indica a la clase que el mètodo
//anotado se ejecute antes de la ejecución de cada método de prueba
@Before
public void inicializacion(){
logger.info("Inicialización de método de prueba ...!");
}

//Si en la clase de test hubiera varios métodos anotados con @Before
//entonces todos ellos se ejecutaran al iniciar cada método de prueba.
@Before
public void inicializacion2(){
logger.info("Inicialización de método de prueba 2...!");
}


//La anotación @After pertenece a junit4.4 y le indica a la clase que el método
//anotado se ejecute después de la ejecución de cada método de prueba
@After
public void finalizacion(){
logger.info("Finalización de método de prueba...!");
}

//Si en la clase de test hubiera varios métodos anotados con @After
//entonces todos ellos se ejecutaran al terminar cada método de prueba.
@After
public void finalizacion2(){
logger.info("Finalización de método de prueba 2...!");
}


//Método que realizará una prueba unitaria, ojo que no es necesario que
//el nombre del método empiece con test, simplemente que esté anotado con @Test
@Test
public void testSumar(){
logger.info("Inicio de test testSumar()");
Long operador1 = 1L;
Long operador2 = 2L;
Long resultado = calculadoraService.sumar(operador1, operador2);
assertEquals(3L, resultado.longValue());
logger.info("Fin de test testSumar()");
}

//Este tambien es un método de prueba que a diferencia del anterior no empieza con la
//palabra test
@Test
public void pruebaSumar(){
logger.info("Inicio de test pruebaSumar()");
Long operador1 = 2L;
Long operador2 = 3L;
Long resultado = calculadoraService.sumar(operador1, operador2);
assertEquals(5L, resultado.longValue());
logger.info("Fin de test pruebaSumar()");
}


//Esta prueba utiliza un parámetro de la anotación @Test que indica la excepción esperada
//por el método, si la excepción es lanzada entonces la prueba es correcta, si el método termina
//sin lanzar una excepción entonces la prueba falla; en el siguiente caso al dividir por cero
//el método lanza la excepción ArithmeticException que la prueba espera.
@Test(expected=ArithmeticException.class)
public void pruebaDivisionPorCero(){
logger.info("Inicio de test pruebaDivisionPorCero()");
BigDecimal operador1 = BigDecimal.TEN;
BigDecimal operador2 = BigDecimal.ZERO;
BigDecimal resultado = calculadoraService.dividir(operador1, operador2);
assertEquals(5L, resultado.longValue());
logger.info("Fin de test pruebaDivisionPorCero()");
}

//El otro parámetro de la anotación @Test es 'timeout' que indica que la prueba fallará
//si la ejecución del método se demora más del valor del parámetro 'timeout' en milisegundos
//en el ejemplo lo he colocado en 1000 milisegundos ó 1 segundo
@Test(timeout=1000)
public void pruebaMetodoLargo(){
logger.info("Inicio de test pruebaMetodoLargo()");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
logger.info("Hilo interrumpido en pruebaMetodoLargo()",e);
}
logger.info("Fin de test pruebaMetodoLargo()");
}

//Anotando un método de prueba con la anotación @Ignore le indicará a junit4 que dicho método
//no debe ser tomado en cuenta al momento de realizar las pruebas unitarias.
@Ignore
@Test(timeout=1000)
public void pruebaMetodoLargoIgnorado(){
logger.info("Inicio de test pruebaMetodoLargoIgnorado()");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
logger.info("Hilo interrumpido en pruebaMetodoLargoIgnorado()",e);
}
logger.info("Fin de test pruebaMetodoLargoIgnorado()");
}

}

Ahora veamos una prueba más interesante, que tal si queremos probar operaciones con base de datos, veamos la siguiente prueba de registro de un empleado usando el esquema HR de oracle:

Ejemplo 2: Registro de empleados en una base de datos Oracle, primero veamos la clase que va a ser testeada:


package pe.com.slcsccy.ejemplos.spring.junit4.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import pe.com.slcsccy.ejemplos.spring.junit4.dominio.beans.Employees;
import pe.com.slcsccy.ejemplos.spring.junit4.model.dao.EmployeesDAO;

@Service("empleadoService")
@Transactional
public class EmpleadoServiceImpl implements EmpleadoService{

@Autowired
private EmployeesDAO employeeDao;

/**
* Recordar que la propagación REQUIRED es la que se usa por default
* la coloco para que sea más claro que si un método de prueba no inicia
* una transacción pues los métodos de esta clase que participan en la prueba
* sí iniciarán una transacción.
* */
@Override
@Transactional(propagation=Propagation.REQUIRED)
public void registrar(Employees empleado) {
employeeDao.insert(empleado);
}

@Override
@Transactional(readOnly=true)
public Employees buscar(Integer idEmpleado) {
return (Employees)employeeDao.selectByPrimaryKey(idEmpleado);
}
}

Ahora la clase de Test del servicio de registro de empleados


package pe.com.slcsccy.ejemplos.spring.junit4.service;

import java.util.Date;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.NotTransactional;
import org.springframework.test.annotation.Repeat;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;

import pe.com.slcsccy.ejemplos.spring.junit4.dominio.beans.Employees;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:/ejemplos-junit4-all.xml"})
@TransactionConfiguration(transactionManager="administradorTransaccional",defaultRollback=false)
public class EmpleadoServiceTest extends AbstractTransactionalJUnit4SpringContextTests {

@Autowired
private EmpleadoService empleadoService;

/**
* La anotación @Rollback la indicará a spring que los cambios que involucre el método de
* prueba no deben de comprometerse en forma permanente en la base de datos.
* Por otro lado la anotación @Repeat ejecutará tantas veces el método como el valor de su argumento.
* Debemos de tener en cuenta que en la ejecución del método de prueba se crea una nueva transacción y si
* la capa de servicios (empleadoService.*) crea otra transacción entonces la primera transacción se suspende
* y esta ultima transacción se comprometerá si se ejecuta satisfactoriamente, por lo que el método del servicio
* debería estar especificado de la siguiente manera:
* @Transactional(propagation=Propagation.REQUIRED) // esto es por default, y no como:
* @Transactional(propagation=Propagation.REQUIRES_NEW) // esto no tomaría en cuenta la anotación @Rollback
* public void registrar(Employees empleado) {...}
* */
@Test
@Rollback
@Repeat(5)
public void pruebaRegistroEmpleado(){
Employees empleado1 = new Employees();
empleado1.setEmployeeId(100001);
empleado1.setLastName("ccacique");
empleado1.setEmail("ccacique@sunat.gob.pe");
empleado1.setHireDate(new Date(System.nanoTime()));
empleado1.setJobId("IT_PROG");
empleadoService.registrar(empleado1);
Employees empleado2 = empleadoService.buscar(empleado1.getEmployeeId());
logger.info("Correo del empleado en base de datos: "+empleado2.getEmail());
}

/**
* La anotación @NotTransactional le indicará a spring que NO se debe de crear una transacción al iniciar
* la ejecución del método de prueba, por default los métodos de la clase que hereden
* de AbstractTransactionalJUnit4SpringContextTests son transaccionales.
* */
@Test
@NotTransactional
public void pruebaRegistroEmpleadoNoTransaccional(){
Employees empleado1 = new Employees();
empleado1.setEmployeeId(100002);
empleado1.setLastName("ccacique");
empleado1.setEmail("ccacique@elcacique.pe");
empleado1.setHireDate(new Date(System.nanoTime()));
empleado1.setJobId("IT_PROG");
//La anotación @NotTransactional indica que todo el código
//del método pruebaRegistroEmpleadoNoTransaccional
//no es transaccional, pero la capa de servicios(empleadoService.registrar(empleado1)) al tener
//su propio contexto transaccional inicia su propia transacción y compromete los cambios.
empleadoService.registrar(empleado1);
}
}

El proyecto utiliza el siguiente pom para resolver las dependencias del proyecto:



4.0.0
pe.com.slcsccy.ejemplos.spring
junit4
jar
0.0.1-SNAPSHOT
junit4
http://maven.apache.org
 
  
  junit
  junit
  4.4
  test
 
 
  org.springframework
  spring-test
  2.5.6
  test
 
 
  com.oracle
  ojdbc6
  11.2.0.1.0
 
 
  commons-dbcp
  commons-dbcp
  1.4
 
 
  org.apache.ibatis
  ibatis-sqlmap
  2.3.0
 
 
  org.springframework
  spring
  2.5.6
 
 
  log4j
  log4j
  1.2.14
 


 
  
   org.apache.maven.plugins
   maven-surefire-plugin
   2.4
   
    false

Las dependencias del driver de oracle las he instalado a mano en mi repositorio ya que no son públicas. Las pruebas se ejecutan con un plugin de maven que se ejecuta en la fase de test: maven-surefire-plugin
El proyecto completo te lo puedes bajar desde aquí

Implementando Transacciones distribuidas con Spring y Atomikos

2010-02-24T08:40:00.000-08:00

Una transacción distribuida debe entenderse como aquella transacción(con sus propiedades ACID) que llega a ejecutarse a través de multiples recursos y por recurso debe entenderse una base de datos, una cola de mensajes(JMS), etc..., en distintos hosts, por ejemplo:

Como aseguro que una transacción interbancaria se realice con exito, es decir retirar dinero de un banco y depositarlo en otro, teniendo en cuenta que el gestor de bases de datos del banco origen y destino son diferentes(por ejemplo mysql y postgresql) y que están en distintos hosts.

Definamos entonces de una manera más simple la transacción distribuida de ejemplo:

begin Tx.

retirar dinero del banco origen, por ejemplo MYSQL

depositar dinero al banco destino por ejemplo POSTGRESQL.

si(no excepciones)

commit Tx.

sino

rollback Tx

Una transacción distribuida asegura que se realicen todos los pasos dentro de la transacción de forma correcta o no se realice ninguno.

Por ejemplo si es que a ocurrido una excepción al depositar el dinero en el banco destino entonces la transacción distribuida debe de realizar un rollback y deshacer la acción de retiro de dinero del banco origen.

Lo anterior se realiza mediante un mecanismo llamado commit en dos fases(two-phase commit) el cual es usado para coordinar multiples recursos durante una transacción distribuida, este mecanismo como su nombre lo indica consiste en dos fases:

Fase 1: La fase de preparación.

Fase 2: La fase de compromiso(commit).

Cuando solicitamos un commit hacia una transacción distribuida el administrador transaccional inicia el mecanismo del commit en dos fases de la siguiente manera:

En la fase uno a todos los recursos involucrados en la transacción(bases de datos, colas) se les pregunta por su estado, cada recurso puede responder con cualquiera de los 3 siguientes estados: READY, READ_ONLY y NOT_READY. Si cualquiera de los recursos responde con NOT_READY entonces la transacción entera es deshecha(se realiza un rollback). Si todos los recursos responden con READY entonces estos son comprometidos(commit) en la segunda fase. Los recursos que responden con READ_ONLY no participan de la segunda fase.

En el ejemplo que vamos a ver a continuación usamos el administrador transaccional Atomikos ya que no requiere el uso de un servidor de aplicaciones J2EE, hay que recordar que la administración transaccional(sea local o distribuida) la proporciona el servidor de aplicaciones(jboss, weblogic, websphere, etc).

El ejemplo consiste en realizar una transacción interbancaria simple:

1. Retiro dinero del banco BBVA estando sus cuentas en una base de datos mysql5.0

2. El dinero obtenido del punto 1 lo deposito al banco Scotiabank en una base de datos postgres 8.4

El código fuente es el siguiente:

1. Script de base de datos tanto para mysql como para postgres:

CREATE TABLE cuenta

(

co_cuenta char(10) NOT NULL,

va_monto decimal(10,2),

PRIMARY KEY (co_cuenta)

);

insert into cuenta values('0000000001',10000);

insert into cuenta values('0000000002',10000);

insert into cuenta values('0000000003',10000);

insert into cuenta values('0000000004',10000);

insert into cuenta values('0000000005',10000);

2. Modificar el archivo de configuración del postgresql(postgresql.conf) para habilitar las transacciones distribuidas:

max_prepared_transactions = 20 # zero disables the feature

3. Crear el bean de configuración de spring(application_xa.xml):

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<bean id="log4jInitialization" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">

<property name="targetClass" value="org.springframework.util.Log4jConfigurer" />

<property name="targetMethod" value="initLogging" />

<property name="arguments">

<list><value>C:\\logs\spring.config</value></list>

</property>

</bean>

<bean id="dataSourceBBVA" class="com.atomikos.jdbc.AtomikosDataSourceBean">

<property name="uniqueResourceName" value="MYSQLDS"/>

<property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>

<property name="xaProperties">

<props>

<prop key="serverName">localhost</prop>

<prop key="databaseName">bancoBBVA</prop>

<prop key="user">root</prop>

<prop key="password">jdeveloper007</prop>

</props>

</property>

<property name="minPoolSize" value="2"/>

<property name="maxPoolSize" value="10"/>

</bean>

<bean id="dataSourceScotiabank" class="com.atomikos.jdbc.AtomikosDataSourceBean">

<property name="uniqueResourceName" value="POSTGRESDS"/>

<property name="xaDataSourceClassName" value="org.postgresql.xa.PGXADataSource"/>

<property name="xaProperties">

<props>

<prop key="serverName">localhost</prop>

<prop key="databaseName">bancoScotiabank</prop>

<prop key="user">postgres</prop>

<prop key="password">Jdeveloper007</prop>

</props>

</property>

<property name="minPoolSize" value="2"/>

<property name="maxPoolSize" value="10"/>

</bean>

<!-- 4. Declaración del administrador transaccional que implementa todo el trabajo

transaccional, proporcionado por 'Atomikos' : -->

<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">

<property name="forceShutdown" value="true"/>

<property name="startupTransactionService" value="true"/>

</bean>

<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp"></bean>

<!-- 6. Al administrador transaccional JTA de spring le pasamos las referencias

implementadas por 'Atomikos' y no por un servidor de aplicaciones -->

<bean id="administradorTransaccional" class="org.springframework.transaction.jta.JtaTransactionManager">

<property name="transactionManager" ref="atomikosTransactionManager"/>

<property name="userTransaction" ref="atomikosUserTransaction"/>

</bean>

<tx:annotation-driven transaction-manager="administradorTransaccional" />

<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">

<property name="configLocation" value="sql-map-config.xml"/>

</bean>

<bean id="movimientoBBVADAO" class="pe.com.slcsccy.testspring.model.dao.MovimientoBBVADAOImpl">

<property name="dataSource" ref="dataSourceBBVA"/>

<property name="sqlMapClient" ref="sqlMapClient"/>

</bean>

<bean id="movimientoScotiabankDAO" class="pe.com.slcsccy.testspring.model.dao.MovimientoScotiabankDAOImpl">

<property name="dataSource" ref="dataSourceScotiabank"/>

<property name="sqlMapClient" ref="sqlMapClient"/>

</bean>

<context:component-scan base-package="pe.com.slcsccy.testspring.service"/>

</beans>

4. Creamos los daos y la configuración de ibatis:

4.1 MovimientoBBVADAO.java:

package pe.com.slcsccy.testspring.model.dao;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

public interface MovimientoBBVADAO {

public void retirarBBVA(Movimiento cuenta);

}

4.2 MovimientoBBVADAOImpl.java:

package pe.com.slcsccy.testspring.model.dao;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

public class MovimientoBBVADAOImpl extends SqlMapClientDaoSupport implements MovimientoBBVADAO{

@Override

public void retirarBBVA(Movimiento movimiento) {

this.getSqlMapClientTemplate().update("CUENTAS.retirarBBVA", movimiento);

}

4.3 MovimientoScotiabankDAO.java:

package pe.com.slcsccy.testspring.model.dao;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

public interface MovimientoScotiabankDAO {

public void depositarScotiabank(Movimiento movimiento)throws Exception;

}

4.4 MovimientoScotiabankDAOImpl.java:

package pe.com.slcsccy.testspring.model.dao;

import java.math.BigDecimal;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

public class MovimientoScotiabankDAOImpl extends SqlMapClientDaoSupport implements MovimientoScotiabankDAO{

private static final BigDecimal vaLimiteTransferencia = BigDecimal.valueOf(2000);

@Override

public void depositarScotiabank(Movimiento movimiento) throws Exception {

if(movimiento.getVaMonto().compareTo(vaLimiteTransferencia)>0){

throw new Exception("El monto a transferir supera el límite");

}

this.getSqlMapClientTemplate().update("CUENTAS.depositarScotiabank", movimiento);

}

4.5 CUENTAS_SqlMap.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd" >

<sqlMap namespace="CUENTAS">

<update id="retirarBBVA" parameterClass="pe.com.slcsccy.testspring.dominio.beans.Movimiento" >

UPDATE cuenta SET va_monto = va_monto - #vaMonto#

WHERE co_cuenta = #coCuentaInterbancario#

</update>

<update id="depositarScotiabank" parameterClass="pe.com.slcsccy.testspring.dominio.beans.Movimiento" >

UPDATE cuenta SET va_monto = va_monto + #vaMonto#

WHERE co_cuenta = #coCuentaInterbancario#

</update>

</sqlMap>

5. Definimos las clases que representan al servicio:

5.1 FacadeService.java

package pe.com.slcsccy.testspring.service;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

public interface FacadeService {

public void transferenciaInterbancaria(Movimiento movimiento) throws Exception;

}

5.2 FacadeServiceImpl.java

package pe.com.slcsccy.testspring.service;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

import pe.com.slcsccy.testspring.model.dao.MovimientoBBVADAO;

import pe.com.slcsccy.testspring.model.dao.MovimientoScotiabankDAO;

@Service("facadeService")

@Transactional

public class FacadeServiceImpl implements FacadeService {

private final Logger logger = Logger.getLogger(getClass());

@Autowired

private MovimientoBBVADAO movimientoBBVADAO;

@Autowired

private MovimientoScotiabankDAO movimientoScotiabankDAO;

@Override

@Transactional(rollbackFor=Exception.class,readOnly=false)

public void transferenciaInterbancaria(Movimiento movimiento) throws Exception {

logger.info("INICIANDO TRANSFERENCIA...");

movimientoBBVADAO.retirarBBVA(movimiento);

movimientoScotiabankDAO.depositarScotiabank(movimiento);

logger.info("TRANSFERENCIA FINALIZADA...");

}

6. Por ultimo la invocación al servicio anterior

6.1 Inicio2.java:

package pe.com.slcsccy.testspring;

import java.math.BigDecimal;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import pe.com.slcsccy.testspring.dominio.beans.Movimiento;

import pe.com.slcsccy.testspring.service.FacadeService;

public class Inicio2 {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("application_xa.xml");

FacadeService servicioTx = (FacadeService)context.getBean("facadeService");

Movimiento movimiento = new Movimiento();

movimiento.setCoCuentaInterbancario("0000000004");

movimiento.setVaMonto(BigDecimal.valueOf(1500));

try {

servicioTx.transferenciaInterbancaria(movimiento);

} catch (Exception e) {

e.printStackTrace();

}

Si quieres que se realice un rollback al movimiento colocale un monto mayor a 2000 y verás que hace un rollback a la base del BBVA tambien.

Implementando Transacciones con Spring y Anotaciones @Transactional Parte 3

2010-02-23T19:44:00.000-08:00

En esta oportunidad vamos a ver como podemos propagar las transacciones mediante spring. Se debe de entender por propagación de la transacción al mecanismo que extiende la transacción hacia otros métodos también transaccionales. En los ejemplos anteriores habíamos visto transacciones encapsuladas en un solo método, por ejemplo:

@Transactional

public class ClaseTransaccionalImpl implements ClaseTransaccional{

public void metodoTransaccional01(){

dao01.ejecutar();

}

public void metodoTransaccional02(){

dao02.ejecutar();

}

En el código anterior cada método(invocado independientemente) inicia y cierra una transacción, pero que pasa si cualquiera de los dos métodos llama al otro como a continuación:

@Transactional

public class ClaseTransaccionalImpl implements ClaseTransaccional{

public void metodoTransaccional01(){

dao01.ejecutar();

metodoTransaccional02();

}

public void metodoTransaccional02(){

dao02.ejecutar();

}

Ahora vemos que el método metodoTransaccional01() invoca al método metodoTransaccional02(), pero que es lo que pasa con la transacción iniciada por la invocación de metodoTransaccional01()?.

se realiza un commit antes de la ejecución del siguiente método?

la transacción se suspende y se crea otra transacción por la invocación del nuevo método?

la transacción se extiende(PROPAGA) y la ejecución de los dos métodos se ejecutan en una sola transacción?

Recordando del post anterior los atributos transaccionales por default a nivel de método son los siguientes:

propagation: REQUIRED.

isolation: DEFAULT(READ_COMMITED para Oracle)

timeout: -1

readOnly: false

Entonces la clase anterior definida explicitamente quedaría como:

@Transactional

public class ClaseTransaccionalImpl implements ClaseTransaccional{

@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.READ_COMMITTED,readOnly=false)

public void metodoTransaccional01(){

dao01.ejecutar();

metodoTransaccional02();

}

@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.READ_COMMITTED,readOnly=false)

public void metodoTransaccional02(){

dao02.ejecutar();

}

Entonces que se puede deducir?, pues que la transacción se propaga hacia el método metodoTransaccional02(), ya que el atributo de propagación de la transacción es REQUIRED. Veamoslo más despacio:

1. Supongamos que desde una clase cualquiera ejecutamos lo siguiente:

ClaseTransaccional servicio = (ClaseTransaccional)context.getBean("claseTransaccional");

servicio.metodoTransaccional01();

2. Lo que hará spring es detectar que el método a sido marcado como transaccional e iniciará una transacción.

3. La ejecución del método se realiza e invoca al DAO: dao01.ejecutar();

4. La ejecución del método continua y encuentra el método metodoTransaccional02() antes de ejecutar este método spring identifica que es transaccional y que su tipo de propagación es REQUIRED, es decir que si ya existe un contexto transaccional entonces comparte dicho contexto, y si es que no existe el contexto transaccional entonces debe de crear una nueva transacción, para el ejemplo el método transaccional ha sido invocado en un contexto transaccional definido por metodoTransaccional01() por lo que la transacción se propaga a este nuevo método.

5. Si el método metodoTransaccional02() termina exitosamente, es decir no lanza alguna excepción entonces el método metodoTransaccional01() continua su ejecucion y si termina satisfactoriamente realiza un commit de la transacción, dando la posta al hilo que lo invocó.

6. Si en el punto 5 al metodo metodoTransaccional01() le hemos aplicado un aspecto afterReturning entonces la transacción se propagará a dicho aspecto.

Implementando Transacciones con Spring y Anotaciones @Transactional Parte 2

2010-02-07T20:22:00.000-08:00

En el siguiente post vamos a ver el manejo de los atributos transaccionales en spring, a modo de teoria recordemos dichos atributos:

isolation: El grado de aislamiento que tiene esta transacción para otras transacciones, Por ejemplo, puede esta transacción ver registros no comprometidos(uncommited) desde otras transacciones?

propagation: Normalmente todo el código ejecutado dentro del alcance de una transacción será ejecutado en esa transacción. Como vemos, existen varias opciones que especifican el comportamiento si un método es ejecutado cuando un contexto transaccional ya existe. Por ejemplo, si un contexto transaccional ya existe podemos continuar ejecutando el método en la transacción existente o podemos suspender la transacción y crear una nueva transacción. Spring ofrece todas las opciones de propagación que ofrece EJB. Dichas opciones de propagación son:

Propagation.REQUIRED: Si el método es invocado desde un contexto transaccional, entonces el método será invocado en el mismo contexto transaccional. Si el método no es invocado desde un contexto transaccional, entonces el método creará una nueva transacción e intentará comprometer(commit) la transacción cuando el método termine su ejecución.
Propagation.REQUIRES_NEW: El método siempre creará una nueva transacción cuando sea invocado y comprometerá(commit) la transacción cuando el método termine su ejecución. Si ya existe un contexto transaccional, entonces spring suspenderá la transacción existente y creará otra transacción, cuando el método termine su ejecución comprometerá la transacción y reanudará la transacción suspendida.
Propagation.NOT_SUPPORTED: Si el método es ejecutado en un contexto transaccional, entonces este contexto no es propagado a la ejecución del método, por lo que spring suspenderá el contexto transaccional y lo reanudará cuando el método termine su ejecución.
Propagation.SUPPORTS: Si ya existe un contexto transaccional, entonces el método será invocado en el mismo contexto transaccional(igual que REQUIRED), si no existe un contexto transaccional entonces no se crea un contexto transaccional (igual que NOT_SUPPORTED)
Propagation.MANDATORY: Este atributo obliga a la transaccion a ser ejecutada en un contexto transaccional, si es que no existe un contexto transaccional en la ejecución del método spring retorna una Excepción.
Propagation.NEVER: Este atributo obliga que la ejecución del método no sea invocado desde un contexto transaccional, de lo contrario spring retorna una excepcion.
Propagation.NESTED: (Solo en spring no en EJB), Se ejecuta dentro de una transacción anidada si un contexto transaccional existe.

timeout: Cuanto tiempo esta transacción puede ejecutarse antes de que automáticamente se realice un rollback.

readOnly: Una transacción de solo lectura no modifica datos. Transacciones de solo lectura pueden ser usuales en algunos casos de optimización(por ejemplo cuando usas Hibernate).

En el siguiente ejemplo mediante spring y oracle vamos a probar los 2 niveles de aislamiento(isolation) que Oracle ofrece, el primero es READ_COMMITED(por default) y el otro es el SERIALIZABLE, resumiendo:

READ_COMMITED: Nivel de aislamiento en el que una transacción solo puede ver data que a sido comprometida(commit) en la base datos.

SERIALIZABLE: Este nivel de aislamiento es generalmente considerado el más restrictivo, ya que proporciona el más alto nivel de aislamiento transaccional. Una transacción SERIALIZABLE opera en un entorno donde parece que no hubieran otros usuarios modificando la data en la base de datos. Cualquier fila leída es asegurada a ser la misma así sea releída y cualquier consulta que ejecutemos es garantizada a retornar los mismos resultados durante la vida de la transacción.

Veamos un par de ejemplos:

El gestor de servicios FacadeServiceImpl.java ahora le he agregado 2 métodos más, un método que soporta las transacciones con un nivel de aislamiento SERIALIZABLE y otra READ_COMMITED, para probar el aislamiento SERIALIZABLE el método buscarEmpleado busca en la base un empleado con código X que al inicio de la transacción no existe, entonces duermo el hilo en ejecución por 10 segundos(Thread.sleep(1000*10);) y durante esos 10 segundos con el usuario sys(en sqlplus) ingreso un empleado con código X y comprometo(commit) la transacción, después que terminan los 10 segundos el programa intenta denuevo buscar el empleado pero tampoco lo encuentra a pesar del commit, este nivel de aislamiento es el más restrictivo:SERIALIZABLE, a diferencia del READ_COMMITED, este último si logra leer los datos comprometidos luego de pasados los 10 segundos:

FacadeService.java

package pe.com.slcsccy.testspring.service;

import java.util.List;

import pe.com.slcsccy.testspring.dominio.beans.Employees;

public interface FacadeService {

public void registrarEmpleados(List empleados);

public void testNivelAislamientoSerializable(Integer idEmpleado);

public void testNivelAislamientoReadCommited(Integer idEmpleado);

}

FacadeServiceImpl.java

package pe.com.slcsccy.testspring.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Transactional;

import pe.com.slcsccy.testspring.dominio.beans.Employees;

import pe.com.slcsccy.testspring.model.dao.EmployeesDAO;

@Service("facadeService")

@Transactional

public class FacadeServiceImpl implements FacadeService {

@Autowired

private EmployeesDAO empleadoDAO;

@Override

public void registrarEmpleados(List empleados) {

for(Employees e:empleados){

empleadoDAO.insert(e);

}

@Override

@Transactional(isolation=Isolation.SERIALIZABLE)

public void testNivelAislamientoSerializable(Integer idEmpleado) {

buscarEmpleado(idEmpleado);

}

@Override

@Transactional(isolation=Isolation.READ_COMMITTED)

public void testNivelAislamientoReadCommited(Integer idEmpleado) {

buscarEmpleado(idEmpleado);

}

private void buscarEmpleado(Integer idEmpleado){

Employees empleado = empleadoDAO.selectByPrimaryKey(idEmpleado);

if(empleado!=null)System.out.println("Empleado 1:"+empleado.getLastName());

else System.out.println("Empleado NO Existe.");

//Duermo el programa para insertar un

//empleado con código idEmpleado y pueda ser leído posteriormente.

//esto lo realizo con el sqlplus:

//SYS: OPTIMUS> insert into //hr.employees(employee_id,last_name,email,hire_date,job_id)

//values(20002,'Carlitos','algo3@algo.com',sysdate,'IT_PROG');

//1 fila creada.

//SYS: OPTIMUS> commit;

//Confirmación terminada.

try {

Thread.sleep(1000*10);

} catch (InterruptedException e) {

e.printStackTrace();

}

empleado = empleadoDAO.selectByPrimaryKey(idEmpleado);

if(empleado!=null)System.out.println("Empleado 2:"+empleado.getLastName());

else System.out.println("Empleado NO Existe.");

}

Por ultimo les muestro el log de ejecución para el nivel de aislamiento SERIALIZABLE, vean como a pesar de que creo el registro y lo comprometo(en sqlplus durante los 10 segundos), en la segunda lectura(después de los 10 segundos) Oracle aún no reconoce el registro para esta transacción, ya que esta transacción es completamente aislada de las demás:

2010-02-07 23:13:33 DEBUG [main] (AbstractFallbackTransactionAttributeSource.java:107) - Adding transactional method [testNivelAislamientoSerializable] with attribute [PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE]

2010-02-07 23:13:33 DEBUG [main] (AbstractPlatformTransactionManager.java:371) - Creating new transaction with name [pe.com.slcsccy.testspring.service.FacadeService.testNivelAislamientoSerializable]: PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE

2010-02-07 23:13:34 DEBUG [main] (DataSourceTransactionManager.java:202) - Acquired Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for JDBC transaction

2010-02-07 23:13:34 DEBUG [main] (DataSourceUtils.java:170) - Changing isolation level of JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] to 8

2010-02-07 23:13:34 DEBUG [main] (DataSourceTransactionManager.java:219) - Switching JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] to manual commit

2010-02-07 23:13:34 DEBUG [main] (SqlMapClientTemplate.java:177) - Opened SqlMapSession [com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl@1786286] for iBATIS operation

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100000} Connection

2010-02-07 23:13:34 DEBUG [main] (SqlMapClientTemplate.java:194) - Obtained JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for iBATIS operation

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100000} Preparing Statement: select EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID from EMPLOYEES where EMPLOYEE_ID = ?

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Executing Statement: select EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID from EMPLOYEES where EMPLOYEE_ID = ?

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Parameters: [20002]

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Types: [java.lang.Integer]

2010-02-07 23:13:34 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {rset-100002} ResultSet

Empleado NO Existe.

2010-02-07 23:13:44 DEBUG [main] (SqlMapClientTemplate.java:177) - Opened SqlMapSession [com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl@c792d4] for iBATIS operation

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100003} Connection

2010-02-07 23:13:44 DEBUG [main] (SqlMapClientTemplate.java:194) - Obtained JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for iBATIS operation

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100003} Preparing Statement: select EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID from EMPLOYEES where EMPLOYEE_ID = ?

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100004} Executing Statement: select EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID from EMPLOYEES where EMPLOYEE_ID = ?

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100004} Parameters: [20002]

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100004} Types: [java.lang.Integer]

2010-02-07 23:13:44 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {rset-100005} ResultSet

Empleado NO Existe.

2010-02-07 23:13:44 DEBUG [main] (AbstractPlatformTransactionManager.java:730) - Initiating transaction commit

2010-02-07 23:13:44 DEBUG [main] (DataSourceTransactionManager.java:259) - Committing JDBC transaction on Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver]

2010-02-07 23:13:44 DEBUG [main] (DataSourceUtils.java:193) - Resetting isolation level of JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] to 2

2010-02-07 23:13:44 DEBUG [main] (DataSourceTransactionManager.java:314) - Releasing JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] after transaction

2010-02-07 23:13:44 DEBUG [main] (DataSourceUtils.java:312) - Returning JDBC Connection to DataSource

Implementando Transacciones con Spring y Anotaciones @Transactional Parte 1

2010-02-07T08:29:00.000-08:00

Este post va a ser el primero de una serie el cuál estará enfocado a la implementación de transacciones mediante spring, estas implementaciones las realizaré mediantes anotaciones, con la anotación @Transactional, y en forma declarativa mediante xml y aspectos.

El proyecto desarrollado hace uso del esquema de ejemplo HR que viene con Oracle 10G, la capa de acceso a datos la he implementado con ibatis y el generador de clases de acceso a datos y beans a sido abator, el objetivo del proyecto es ver como spring implementa métodos transaccionales mediante anotaciones, en este primer post vamos a ver de forma simple como antes de la ejecución de un método java spring inicia una nueva transacción y como al finalizar exitosamente dicho método realiza el commit correspondiente para persistir los objetos en forma permanente en la base de datos oracle, es decir y para recordar oracle copia los datos a sus redologs y de allí cuando crea conveniente a sus datafiles, el proyecto tambien hace uso del log4j para poder visualizar la clase de spring que crea la transacción y la clase que la compromete(commit).

Los pasos para el desarrollo del proyecto han sido los siguientes:

1. Generación de daos y beans mediante abator(ahora ibator) , el archivo de configuración es el siguiente:

configuradorhr.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE abatorConfiguration

PUBLIC "-//Apache Software Foundation//DTD Abator for iBATIS Configuration 1.0//EN"

"http://ibatis.apache.org/dtd/abator-config_1_0.dtd">

<abatorConfiguration>

<abatorContext id="DB2Tables" generatorSet="Java5">

<jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver" connectionURL="jdbc:oracle:thin:@192.168.1.11:1521:optimus"

userId="hr" password="jdeveloper">

<classPathEntry location="ojdbc6.jar" />

</jdbcConnection>

<javaTypeResolver>

<property name="forceBigDecimals" value="false" />

</javaTypeResolver>

<javaModelGenerator targetPackage="pe.com.slcsccy.testspring.dominio.beans" targetProject=".">

<property name="enableSubPackages" value="true" />

<property name="trimStrings" value="true" />

</javaModelGenerator>

<sqlMapGenerator targetPackage="pe.com.slcsccy.testspring.model.dao.ibatis" targetProject=".">

<property name="enableSubPackages" value="true" />

</sqlMapGenerator>

<daoGenerator type="SPRING" targetPackage="pe.com.slcsccy.testspring.model.dao" targetProject=".">

<property name="enableSubPackages" value="true" />

</daoGenerator>

<table tableName="countries"/>

<table tableName="departments"/>

<table tableName="employees"/>

<table tableName="job_history"/>

<table tableName="jobs"/>

<table tableName="locations"/>

<table tableName="regions"/>

</abatorContext>

</abatorConfiguration>

Ahora lo único que necesitamos para crear los beans y daos es ejecutar lo siguiente:

java -jar abator.jar configuradorhr.xml true

Debes recordar también que debes de tener el driver del oracle en tu classpath para que abator te genere todas las clases.

2. El segundo paso a sido desarrollar la capa de servicios, el servicio lo he implementado mediante una interfaz y una clase con un solo método, que es el siguiente:

FacadeService.java

package pe.com.slcsccy.testspring.service;

import java.util.List;

import pe.com.slcsccy.testspring.dominio.beans.Employees;

public interface FacadeService {

public void registrarEmpleados(List empleados);

}

FacadeServiceImpl.java

package pe.com.slcsccy.testspring.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import pe.com.slcsccy.testspring.dominio.beans.Employees;

import pe.com.slcsccy.testspring.model.dao.EmployeesDAO;

@Service("facadeService")

@Transactional

public class FacadeServiceImpl implements FacadeService {

@Autowired

private EmployeesDAO empleadoDAO;

@Override

public void registrarEmpleados(List empleados) {

for(Employees e:empleados){

empleadoDAO.insert(e);

}

La clase FacadeServiceImpl.java primero la anotamos como un servicio estereotipado(@Service), es decir spring cuando encuentre esta anotación cargará el bean en memoria, la otra anotación @Transactional es la más importante para este post y nos indica que todos los métodos definidos en esta clase van a ser transaccionales, si la anotación @Transactional no le agregamos sus atributos, entonces los atributos que adquiere por defecto son los siguientes:

propagation: REQUIRED, es la conducta de propagación de la transacción, esto quiere decir que si el método no se ejecuta en un contexto transaccional, entonces spring crea una nueva transacción y si ya está en un contexto transaccional(por algún otro lado se inició una transacción), entonces el método se acopla a la transacción.

isolation: DEFAULT, el nivel de aislamiento de la transacción.

timeout: -1, el tiempo máximo en segundos que debe de ejecutarse la transacción.

read-only: false, es la transacción de solo lectura?.

Algunos definiciones personalizadas de @Transactional podrían ser la siguientes:

@Transactional(readOnly=false, propagation=Propagation.REQUIRES_NEW)

Esta definición a nivel de clase nos indica que todos los métodos no son de solo lectura(pueden hacer update insert a la base), y su nivel de propagación requiere una nueva transacción, es decir cuando la aplicación realice una invocación a un método de esta clase se deberá crear una nueva transacción.

@Transactional(readOnly=true)

Esta definición a nivel de clase nos indica que todos los métodos son de solo lectura, es decir nuestros métodos no puede realizar insert o update, si lo hacen entonces spring lanza una excepción.

3. El ultimo paso es la integración de los componentes en un contenedor de beans de spring:

application.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<bean id="log4jInitialization" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">

<property name="targetClass" value="org.springframework.util.Log4jConfigurer" />

<property name="targetMethod" value="initLogging" />

<property name="arguments">

<list><value>C:\\logs\spring.config</value></list>

</property>

</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"

p:driverClassName="oracle.jdbc.driver.OracleDriver"

p:url="jdbc:oracle:thin:@192.168.1.11:1521:optimus"

p:username="hr" p:password="jdeveloper"/>

<bean id="administradorTransaccional" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"

p:dataSource-ref="dataSource"/>

<tx:annotation-driven transaction-manager="administradorTransaccional" />

<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"

p:configLocation="sql-map-config.xml"/>

<bean id="abstractDao" abstract="true" p:sqlMapClient-ref="sqlMapClient"

p:dataSource-ref="dataSource"/>

<bean id="countriesDAO" class="pe.com.slcsccy.testspring.model.dao.CountriesDAOImpl" parent="abstractDao"/>

<bean id="departmentsDAO" class="pe.com.slcsccy.testspring.model.dao.DepartmentsDAOImpl" parent="abstractDao"/>

<bean id="employeesDAO" class="pe.com.slcsccy.testspring.model.dao.EmployeesDAOImpl" parent="abstractDao"/>

<bean id="jobHistoryDAO" class="pe.com.slcsccy.testspring.model.dao.JobHistoryDAOImpl" parent="abstractDao"/>

<bean id="jobsDAO" class="pe.com.slcsccy.testspring.model.dao.JobsDAOImpl" parent="abstractDao"/>

<bean id="locationsDAO" class="pe.com.slcsccy.testspring.model.dao.LocationsDAOImpl" parent="abstractDao"/>

<bean id="regionsDAO" class="pe.com.slcsccy.testspring.model.dao.RegionsDAOImpl" parent="abstractDao"/>

<context:component-scan base-package="pe.com.slcsccy.testspring.service"/>

</beans>

La ejecución del servicio que registra 3 empleados es la siguiente:

Inicio.java

package pe.com.slcsccy.testspring;

import java.util.ArrayList;

import java.util.Date;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import pe.com.slcsccy.testspring.dominio.beans.Employees;

import pe.com.slcsccy.testspring.service.FacadeService;

public class Inicio {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

FacadeService servicioTx = (FacadeService)context.getBean("facadeService");

ArrayList empleados = new ArrayList() ;

//Empleado 1.

Employees empleado1 = new Employees();

empleado1.setEmployeeId(100001);

empleado1.setLastName("ccacique1");

empleado1.setEmail("carlos.cacique1@gmail.com");

empleado1.setHireDate(new Date(System.nanoTime()));

empleado1.setJobId("IT_PROG");

//Empleado 2.

Employees empleado2 = new Employees();

empleado2.setEmployeeId(100002);

empleado2.setLastName("ccacique2");

empleado2.setEmail("carlos.cacique2@gmail.com");

empleado2.setHireDate(new Date(System.nanoTime()));

empleado2.setJobId("IT_PROG");

//Empleado 3.

Employees empleado3 = new Employees();

empleado3.setEmployeeId(100003);

empleado3.setLastName("ccacique3");

empleado3.setEmail("carlos.cacique3@gmail.com");

empleado3.setHireDate(new Date(System.nanoTime()));

empleado3.setJobId("IT_PROG");

//Colocamos a todos los empleados en una lista:

empleados.add(empleado1);

empleados.add(empleado2);

empleados.add(empleado3);

//Ejecutamos el servicio transaccional.

servicioTx.registrarEmpleados(empleados);

}

El log generado es el siguiente, vean como spring crea y compromete(commit) la transacción:

2010-02-07 11:28:10 DEBUG [main] (AbstractFallbackTransactionAttributeSource.java:107) - Adding transactional method [registrarEmpleados] with attribute [PROPAGATION_REQUIRED,ISOLATION_DEFAULT]

2010-02-07 11:28:10 DEBUG [main] (AbstractPlatformTransactionManager.java:371) - Creating new transaction with name [pe.com.slcsccy.testspring.service.FacadeService.registrarEmpleados]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT

2010-02-07 11:28:11 DEBUG [main] (DataSourceTransactionManager.java:202) - Acquired Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for JDBC transaction

2010-02-07 11:28:11 DEBUG [main] (DataSourceTransactionManager.java:219) - Switching JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] to manual commit

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:177) - Opened SqlMapSession [com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl@11c0d60] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100000} Connection

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:194) - Obtained JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100000} Preparing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Executing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Parameters: [100001, null, ccacique1, carlos.cacique1@gmail.com, null, 2293-08-14 05:29:50.376, IT_PROG, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100001} Types: [java.lang.Integer, null, java.lang.String, java.lang.String, null, java.sql.Timestamp, java.lang.String, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:177) - Opened SqlMapSession [com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl@e4bb3c] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100002} Connection

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:194) - Obtained JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100002} Preparing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100003} Executing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100003} Parameters: [100002, null, ccacique2, carlos.cacique2@gmail.com, null, 2293-08-14 05:30:04.039, IT_PROG, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100003} Types: [java.lang.Integer, null, java.lang.String, java.lang.String, null, java.sql.Timestamp, java.lang.String, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:177) - Opened SqlMapSession [com.ibatis.sqlmap.engine.impl.SqlMapSessionImpl@cffc79] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100004} Connection

2010-02-07 11:28:11 DEBUG [main] (SqlMapClientTemplate.java:194) - Obtained JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] for iBATIS operation

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {conn-100004} Preparing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100005} Executing Statement: insert into EMPLOYEES (EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100005} Parameters: [100003, null, ccacique3, carlos.cacique3@gmail.com, null, 2293-08-14 05:30:08.251, IT_PROG, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (JakartaCommonsLoggingImpl.java:27) - {pstm-100005} Types: [java.lang.Integer, null, java.lang.String, java.lang.String, null, java.sql.Timestamp, java.lang.String, null, null, null, null]

2010-02-07 11:28:11 DEBUG [main] (AbstractPlatformTransactionManager.java:730) - Initiating transaction commit

2010-02-07 11:28:11 DEBUG [main] (DataSourceTransactionManager.java:259) - Committing JDBC transaction on Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver]

2010-02-07 11:28:11 DEBUG [main] (DataSourceTransactionManager.java:314) - Releasing JDBC Connection [jdbc:oracle:thin:@192.168.1.11:1521:optimus, UserName=HR, Oracle JDBC driver] after transaction

2010-02-07 11:28:11 DEBUG [main] (DataSourceUtils.java:312) - Returning JDBC Connection to DataSource

El proyecto completo te lo puedes bajar desde AQUI

Creación de Aspectos con Spring e Interfaces

2010-02-05T13:50:00.000-08:00

En los anteriores post comenté como se pueden implementar aspectos mediante anotaciones y en forma declarativa mediante xml, ahora lo vamos a hacer mediante interfaces y unas cuantas declaraciones xml. Veamos; en los aspectos declarados con el tag <aspect> la clase java era un simple javabean, en este post vamos a ver que para evitar el uso de <aspect la clase java que define el aspecto debe de implementar al menos una interface de las siguientes para que las implementaciones de la interface definan el aspecto en la clase, estas interfaces son las siguientes: MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice, el primero de ellos me sirve si quiero que mi clase aspecte métodos antes de que estos se ejecuten, si la clase implementa AfterReturningAdvice entonces el aspecto se ejecutará al finalizar satisfactoriamente la ejecución del método aspectado y finalmente la implementación de la interface ThrowsAdvice capturará las posibles excepciones que el método aspectado lance. Los aspectos son los siguientes:

AuditoriaAspectImpl.java

package pe.com.slcsccy.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

import org.springframework.aop.MethodBeforeAdvice;

import org.springframework.aop.ThrowsAdvice;

public class AuditoriaAspectImpl

implements MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice{

/* Aspecto llamado antes de la ejecución del método que lo ejecuta.

* @param metodo: método que lanza la ejecución de este aspecto.

* @param argumentos: Listado de argumentos del método, debemos hacer el cast.

* @param instancia: Instancia que contiene el método y ejecuta el aspecto.

* */

@Override

public void before(Method metodo, Object[] argumentos, Object instancia)

throws Throwable {

System.out.println("Auditoria.before(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

/* Aspecto llamado cada vez que la ejecución del método termina con excepción.

* @param metodo: método que lanza la ejecución de este aspecto.

* @param argumentos: Listado de argumentos del método, debemos hacer el cast.

* @param instancia: Instancia que contiene el método y ejecuta el aspecto.

* @param exception: Instancia de la excepción que fué lanzada por el aspecto.

* */

public void afterThrowing(Method metodo, Object[] argumentos, Object instancia, Exception exception){

System.out.println("Auditoria.afterThrowing(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

/* Aspecto llamado cada vez que la ejecución del método termina satisfactoriamente.

* @param retorno: Instancia que retorna el método.

* @param metodo: método que lanza la ejecución de este aspecto.

* @param argumentos: Listado de argumentos del método, debemos hacer el cast.

* @param instancia: Instancia que contiene el método y ejecuta el aspecto.

* */

@Override

public void afterReturning(Object retorno, Method metodo, Object[] argumentos,

Object instancia) throws Throwable {

System.out.println("Auditoria.afterReturning(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

ImpresorAspectImpl.java

package pe.com.slcsccy.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

import org.springframework.aop.MethodBeforeAdvice;

import org.springframework.aop.ThrowsAdvice;

public class ImpresorAspectImpl implements MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice{

@Override

public void before(Method metodo, Object[] argumentos, Object instancia)

throws Throwable {

System.out.println("Impresor.before(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

public void afterThrowing(Method metodo, Object[] argumentos, Object instancia, Exception exception){

System.out.println("Impresor.afterThrowing(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

@Override

public void afterReturning(Object retorno, Method metodo, Object[] argumentos,

Object instancia) throws Throwable {

System.out.println("Impresor.afterReturning(..), metodo:"+metodo.getName()+",instancia:"+instancia.getClass().getCanonicalName());

}

Y la configuración de spring es la siguiente:

<context:annotation-config/>

<!-- Le indicamos a spring que lea todas las clases bajo el paquete pe.com.slcsccy.service y sus

subpaquetes y clases, y si encuentra anotaciones estereotipadas(@Service,@Repository,@Controller)

a nivel de clase entonces cree beans del tipo singleton instanciandolas y disponiendolas al proyecto -->

<context:component-scan base-package="pe.com.slcsccy.service"/>

<bean id="impresorAspect" class="pe.com.slcsccy.aop.ImpresorAspectImpl"/>

<bean id="auditoriaAspect" class="pe.com.slcsccy.aop.AuditoriaAspectImpl"/>

<aop:config>

<aop:pointcut id="pointcut"

expression="execution(public * pe.com.slcsccy.service..*(..))"/>

<aop:advisor id="advisor1" advice-ref="auditoriaAspect" pointcut-ref="pointcut"/>

<aop:advisor id="advisor2" advice-ref="impresorAspect" pointcut-ref="pointcut"/>

</aop:config>

Creación de Aspectos con Spring y XML

2010-02-05T07:39:00.000-08:00

En los dos post anteriores vimos como podemos crear aspectos mediante anotaciones y casi nada de xml más que un simple tag ahora vamos a seguir con los aspectos pero ya no con anotaciones sino con XML, los aspectos al no tener anotaciones que los configuren como aspectos toman al forma de simple java beans:

AuditoriaAspectXml.java

package pe.com.slcsccy.aop;

import pe.com.slcsccy.bean.Libro;

public class AuditoriaAspectXml {

public void auditar(Libro libroin, Object instancia) {

System.out.println("Aplicando Aspecto de auditoria auditar(..) @Before! con instancia:"+instancia.getClass().getCanonicalName());

}

ImpresorAspectXml.java

package pe.com.slcsccy.aop;

import pe.com.slcsccy.bean.Libro;

public class ImpresorAspectXml {

public void asignarAutor(Libro libroin, Object instancia) {

if(libroin!=null)libroin.setAutor("Carlos Cacique");

System.out.println("Aplicando Aspecto asignarAutor(..) @Before! con instancia:"+instancia.getClass().getCanonicalName());

}

La prueba de los aspectos se dispuso de tal forma que AuditoriaAspectXml.java se ejecute primero y antes del aspecto ImpresorAspectXml.java y que al final se ejecute la lógica de negocio.

Es decir el orden de ejecución debería ser el siguiente:

1. AuditoriaAspectXml.auditar();

2. ImpresorAspectXml.asignarAutor();

3. ImpresorService.imprimir()

La configuración mediante spring que logra lo anterior, es la siguiente:

<context:annotation-config/>


<context:component-scan base-package="pe.com.slcsccy.service"/>


<bean id="impresorAspectXml" class="pe.com.slcsccy.aop.ImpresorAspectXml"/>
<bean id="auditoriaAspectXml" class="pe.com.slcsccy.aop.AuditoriaAspectXml"/>


<aop:config>

<aop:aspect ref="impresorAspectXml" order="2">


<aop:pointcut id="pointcutImpresor"
expression="execution(public * pe.com.slcsccy.service..*(..)) and args(libroin) and target(instancia)"/>


<aop:before method="asignarAutor" pointcut-ref="pointcutImpresor" />
</aop:aspect>


<aop:aspect ref="auditoriaAspectXml" order="1">
<aop:pointcut id="pointcutAuditoria"
expression="execution(public * pe.com.slcsccy.service..*(..)) and args(libroin) and target(instancia)" />
<aop:before method="auditar" pointcut-ref="pointcutAuditoria" />
</aop:aspect>
</aop:config>

El proyecto completo te lo puedes bajar desde AQUI:

Creación de Aspectos con Spring y Anotaciones Parte 2

2010-02-01T09:01:00.000-08:00

Ahora vamos a ver lo siguiente: como podemos ordenar la ejecución de los aspectos cuando estos aspectos se disparan ante el mismo advisor o método. En el post anterior definí un método imprimir de la interface ImpresorService, entonces, ¿qué es lo que pasa si tenemos más de un aspecto declarado ante la ejecución del método imprimir? ¿cuál aspecto se ejecuta primero?¿cómo podemos declarar que un aspecto se ejecute antes que otro?.

Veamos el siguiente requerimiento:

1. Agregar un proceso de auditoria que capture todas las ejecuciones del método imprimir

El requerimiento anterior lo podemos solucionar agregando un aspecto más y definir e implementar tanto la clase como el método de auditoria con la anotación @Order

Solución:

Declaración de componentes de spring:

<context:annotation-config/>

<context:component-scan base-package="pe.com.slcsccy.service"/>

<bean id="impresorAspect" class="pe.com.slcsccy.aop.ImpresorAspect"/>

<bean id="auditoriaAspect" class="pe.com.slcsccy.aop.AuditoriaAspect"/>

<aop:aspectj-autoproxy/>

Implementación de componentes java:

AuditoriaAspect.java:

ImpresorAspect.java

package pe.com.slcsccy.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import pe.com.slcsccy.bean.Libro;
@Order(2)
@Aspect
public class ImpresorAspect {
@Order(2)
@Before("execution(public * pe.com.slcsccy.service..*(..)) && "+
"args(libroin) && target(instancia)")
public void asignarAutor(Libro libroin, Object instancia) {
if(libroin!=null)libroin.setAutor("Carlos Cacique");
System.out.println("Aplicando Aspecto asignarAutor(..) @Before! con instancia:"+instancia.getClass().getCanonicalName());
}
}

Algunas acotaciones: La anotación @Order debe ser colocada tanto a nivel de clase como a nivel de método, si lo colocamos solo a nivel de método, entonces el orden de ejecución va a estar indicado por el orden en la carga de los beans:
<bean id="impresorAspect" class="pe.com.slcsccy.aop.ImpresorAspect"/>
<bean id="auditoriaAspect" class="pe.com.slcsccy.aop.AuditoriaAspect"/>

Creación de Aspectos con Spring y Anotaciones Parte 1

2010-01-31T09:05:00.001-08:00

Hola denuevo, hace mucho tiempo que no posteo y esta vez quiero seguir con los aspectos en Spring, en este post supongo que ya conocen que es un aspecto, para resumirles y hablando como pragramador es un método java que se ejecuta antes, después o antes y después de la ejecución de otro método java, esto nos permite agregar lógica a nuestra aplicación conociendo únicamente la especificación de los métodos a los cuales se les quiere aplicar un aspecto.

La aplicación de ejemplo que he desarrollado es simple: un servicio impresor de libros que tiene un método imprimir con un parámetro Libro a este método imprimir es al cual le aplico una serie de aspectos para agregar las propiedades del libro(autor, isbn y título), los anotaciones que he usado para aplicar los aspectos son: @Aspect, @Before, @After, @AfterReturning, @AfterThrowing, @Around

La clase principal es la siguiente:

package pe.com.slcsccy.aop;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import pe.com.slcsccy.bean.Libro;

import pe.com.slcsccy.service.ImpresorService;

@Aspect

public class ImpresorAspect {

/**

* Este método se ejecuta SIEMPRE antes de cualquier ejecución

* de cualquier método de cualquier clase del paquete pe.com.slcsccy.service y

* que tenga un primer parámetro con nombre libroin

* Obtengo el objeto que viene como parametro y le coloco el nombre del autor,

* además capturo la instancia que disparó el aspecto.

* */

@Before("execution(public * pe.com.slcsccy.service..*(..)) && "+

"args(libroin) && target(instancia)")

public void asignarAutor(Libro libroin, Object instancia) {

if(libroin!=null)libroin.setAutor("Carlos Cacique");

System.out.println("Aplicando Aspecto asignarAutor(..) @Before! con instancia:"+instancia.getClass().getCanonicalName());

}

/**

* Este método se ejecuta SIEMPRE antes de la ejecución de cualquier

* método imprimir que tenga un primer parámetro con nombre libroin de

* cualquier clase que implementa la interface

* pe.com.slcsccy.service.ImpresorService

* */

@Before(value="execution(public * pe.com.slcsccy.service.ImpresorService.imprimir(..)) && "+

"args(libroin) && target(instancia)")

public void asignarISBN(Libro libroin, ImpresorService instancia) {

if(libroin!=null)libroin.setIsbn("41547848");

System.out.println("Aplicando Aspecto asignarISBN(..) @Before! con instancia:"+instancia.getClass().getCanonicalName());

}

/**

* Este método se ejecuta SOLO después de la ejecución EXITOSA de cualquier

* método imprimir que tenga un primer parámetro con nombre libroin

* de cualquier clase que implementa la interface

* pe.com.slcsccy.service.ImpresorService

* */

@AfterReturning(value="execution(public * pe.com.slcsccy.service.ImpresorService.imprimir(..)) && "+

"args(libroin) && target(instancia)",returning="libroOut")

public void asignarTitulo(Libro libroin, Libro libroOut, ImpresorService instancia) {

libroOut.setTitulo("Ejemplo de aspectos con spring");

System.out.println("Aplicando Aspecto asignarTitulo(..) @AfterReturning! con instancia:"+instancia.getClass().getCanonicalName());

System.out.println("Libro Out:"+libroOut);

}

/**

* Este método se ejecuta SIEMPRE después de cualquier

* método imprimir que tenga un primer parámetro con nombre libroin

* de cualquier clase que implementa la interface

* pe.com.slcsccy.service.ImpresorService

* */

@After(value="execution(public * pe.com.slcsccy.service.ImpresorService.imprimir(..)) && "+

"args(libroin) && target(instancia)")

public void finalizarNormal(Libro libroin, ImpresorService instancia) {

System.out.println("Aplicando Aspecto finalizarNormal(..) @After! con instancia:"+instancia.getClass().getCanonicalName());

System.out.println("Libro:"+libroin);

}

/**

* Este método se ejecuta SIEMPRE que ocurre una excepción después de ejecutar

* cualquier método imprimir que tenga un primer parámetro con nombre libroin

* de cualquier clase que implementa la interface

* pe.com.slcsccy.service.ImpresorService

* */

@AfterThrowing(value="execution(public * pe.com.slcsccy.service.ImpresorService.imprimir(..)) && " +

"args(libroin) && target(instancia)",

throwing="excepcion")

public void finalizarConExcepcion(Libro libroin, ImpresorService instancia, ImpresorException excepcion) {

System.out.println("Aplicando Aspecto finalizarConExcepcion(..) @AfterThrowing!");

System.out.println("Mensaje de la Excepcion en el aspecto @AfterThrowing:"+excepcion.getMessage());

}

/**

* Este método se ejecuta dos fases, la primera antes de la ejecución del método y la segunda * cuando el método a terminado satisfactoriamente.

* @throws Throwable

* */

@Around(value="execution(public * pe.com.slcsccy.service.ImpresorService.imprimir(..)) && " +

"args(libroin) && target(instancia)")

public void logging(ProceedingJoinPoint ejecutor,Libro libroin, ImpresorService instancia) throws Throwable {

System.out.println("Iniciando loggin(..) @Around!");

Object retorno = ejecutor.proceed();

System.out.println("Finalizando loggin(..) @Around!, con retorno:"+retorno.getClass().getCanonicalName());

}

La aplicación completa en eclipse la puedes descargar desde AQUI.

Spring MVC SimpleFormController

2009-09-05T07:45:00.000-07:00

Veamos una clase que nos permitirá controlar las acciones que realicemos con los formularios de una manera más simple: SimpleFormController

El caso de uso a desarrollar es uno bien simple de registro de usuarios, los requerimientos son los siguientes:

1. Si el actor o persona que va a registrar al usuario no está autenticada en el sistema entonces redirigirla hacia una página para que se autentique.

Solución a 1. Extensión de la clase HandlerInterceptorAdapter para implementar nuestro propio interceptor de solicitudes hacia un controlador específico, en este caso el controlador es un SimpleFormController, el componente que verificará la existencia del usuario en el contexto de sesion es el Interceptor.

2. Uso de etiquetas de formulario de spring, la libreria a usar será:

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

Ahora veamos el código:

Lo primero que tenemos que hacer es implementar nuestro objeto Command, en este caso el objeto command es un javabean simple:

Usuario.java

package pe.com.slcsccy.springmvc.dominio;
import java.util.Date;

public class Usuario {

private String codigo;
private String nombres;
private String apellidos;
private String perfil;
private String multisesion;
private Boolean habilitado;
private String[] aplicaciones;
private String nacionalidad;
private Date fechaRegistro;
private Date fechaCese;

//Continuan setters and getters....

}

Ahora vamos a crear nuestro controlador:

UsuarioFormController.java

package pe.com.slcsccy.springmvc.controllers;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.ArrayList;

import java.util.Map;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.propertyeditors.CustomDateEditor;

import org.springframework.validation.BindException;

import org.springframework.web.bind.ServletRequestDataBinder;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.SimpleFormController;

import pe.com.slcsccy.springmvc.dominio.Usuario;

import pe.com.slcsccy.springmvc.facade.Facade;

public class UsuarioFormController extends SimpleFormController {

private Facade facade;

@Override

protected Object formBackingObject(HttpServletRequest request) throws Exception {

Usuario usuario = null;

String coUsuario = request.getParameter("coUsuario");

if (coUsuario != null && !coUsuario.equals("")) {

usuario = facade.getUsuarioService().buscar(coUsuario);

} else {

usuario = new Usuario();

}

return usuario;

}

/**

Este método es llamado antes de que el formulario sea procesado, aquí

es donde colocamos el modelo de datos que el formulario necesita utilizar,

por ejemplo si vas a registrar un usuario necesitas asignarle un perfil de una

lista, la lista la obtenemos del DAO por aquí

@Override

public Map referenceData(HttpServletRequest request) {

Map modelo = new HashMap();

ArrayList perfiles = facade.getPerfilService().listar();

ArrayList aplicaciones = facade.getAplicacionService().listar();

ArrayList nacionalidades = facade.getNacionalidadService().listar();

modelo.put("aplicaciones", aplicaciones);

modelo.put("perfiles", perfiles);

modelo.put("nacionalidades", nacionalidades);

return modelo;

}

/**

* Este método permite registrar editores personalizados para ciertos campos

* de nuestro objeto command, en este caso el objeto command es un usuario

* el cual tiene dos campos de fechas pero de tipo Date, lo que hacemos aquí

* es asociar los valores del request a los tipos Date con una fecha

* personalizada, recuerda que el request.getParameter("campo") te devuelve

* siempre un valor null o un String por lo que la transformación a Date

* lo realiza el editor personalizado declarado aquí(Binding)

@Override

protected void initBinder(HttpServletRequest request,

ServletRequestDataBinder dataBinder) throws ServletException {

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));

}

/**

* hacemos un postprocesamiento de los datos que el usuario a enviado,

* en este caso solo le asignamos a la variable de multisesion un valor N.

* este campo de multisesion está relacionado a un checkbox y en el

* objeto command el campo es detipo String, si el usuario no ha marcado

* el checkbox entonces su valor es null, pero en la base

* el valor solo debe ser ó N ó S. Aqui cambiamos el valor null por un más

* significativo.

@Override

protected void onBindAndValidate(HttpServletRequest request, Object command, BindException errors)

throws Exception {

Usuario usuario = (Usuario)command;

usuario.setMultisesion(usuario.getMultisesion()==null?"N":"S");

}

/**

* Método que se encargará del registro del usuario en la base de datos

* después de que las validaciones fueron exitosas(no hubo errores)

@Override

protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response,

Object command, BindException errors) throws Exception {

Usuario usuario = (Usuario) command;

int coError = facade.getUsuarioService().registrar(usuario);

if (coError == 0) {

return new ModelAndView("forms/vistaOk");

} else {

return new ModelAndView("forms/vistaError");

}

/**

* @return the facade

public Facade getFacade() {

return facade;

}

/**

* @param facade the facade to set

public void setFacade(Facade facade) {

this.facade = facade;

}

Ahora declaramos la clase que validará los datos que ingrese el usuario:

UsuarioValidator.java

package pe.com.slcsccy.springmvc.validators;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import pe.com.slcsccy.springmvc.dominio.Usuario;

public class UsuarioValidator implements Validator {

public boolean supports(Class clase) {
return Usuario.class.isAssignableFrom(clase);
}

/**
* Método principal que será llamado antes de que pase por el controlador
* si la lista de errores contiene al menos un elemento, regresará al
* formulario
*/
public void validate(Object object, Errors errores) {
Usuario usuario = (Usuario) object;
if(usuario.getAplicaciones().length==0)
errores.rejectValue("aplicaciones", "errores.aplicacionesReq");
ValidationUtils.rejectIfEmpty(errores, "codigo", "errores.codigoReq","Mensaje 1");
ValidationUtils.rejectIfEmpty(errores, "apellidos", "errores.apellidosReq","Mensaje 2");
ValidationUtils.rejectIfEmpty(errores, "nombres", "errores.nombresReq","Mensaje 3");
}
}

Los ultimos componentes a crear serán los interceptores:
LoginInterceptor.java
package pe.com.slcsccy.springmvc.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class LoginInterceptor extends HandlerInterceptorAdapter {

/*
* Este método debe de asegurar que al controller solo le lleguen solicitudes
* que cumplan ciertos datos del negocio, como que el usuario este autenticado por ejemplo,
* recordar que el objeto handler en el argumento es el controller hacia al cual
* se dirige la solicitud.
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
/*Solo retornamos true...*/
return true;
/*Si no queremos ir hacia la vista apropiada entonces:*/
/*if(true){
throw new ModelAndViewDefiningException(new ModelAndView("exception/noAutenticado"));
}else return true;*/
}

/*
* Este meétodo puede hacer un postprocesamiento de la solicitud, por ejemplo
* puede cambiar la vista hacia la cual el controller respondió
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mav)
throws Exception {
}
}

Otro interceptor para que veas como funcionan en forma encadenada o en chain.
LoginAduanasInterceptor.java
package pe.com.slcsccy.springmvc.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class LoginAduanasInterceptor extends HandlerInterceptorAdapter {

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("Interceptor de Adunas ejecutandose en el preHandle()");
return true;
//Si no queremos ir hacia la vista apropiada entonces
/*if(true){
throw new ModelAndViewDefiningException(new ModelAndView("exception/noAutenticado"));
}else return true;*/
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mav)
throws Exception {
System.out.println("Interceptor de Aduanas ejecutandose en el postHandle()");
}
}

Me estaba olvidando lo más importante, el formulario jsp, allí está:
usuarioForm.jsp
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Gestión de Usuarios</title>
</head>
<body>
<form:form commandName="usuario">
Codigo: <form:input path="codigo" /><form:errors path="codigo"/><br/>
Nombres: <form:input path="nombres" /><form:errors path="nombres"/><br/>
Apellidos: <form:input path="apellidos" /><form:errors path="apellidos"/><br/>
Fecha Registro: <form:input path="fechaRegistro" /><form:errors path="fechaRegistro"/><br/>
Fecha Cese: <form:input path="fechaCese" /><form:errors path="fechaCese"/><br/>
Perfiles:<form:select path="perfil">
<form:option value="">SELECCIONE</form:option>
<form:options items="${perfiles}" itemValue="coPerfil"itemLabel="dePerfil"/>
</form:select><form:errors path="perfil"/><br/><br/><br/><br/>


Habilitado:<form:checkbox path="habilitado"/><br><br/>
MultiSesion:<form:checkbox path="multisesion" value="S"/><br><br/>

Aplicaciones:
<form:checkboxes path="aplicaciones" items="${aplicaciones}" itemValue="coAplicacion" itemLabel="deAplicacion"/>
<form:errors path="aplicaciones"/><br/>
<br/><br/>

Nacionalidad:
<form:radiobuttons path="nacionalidad" items="${nacionalidades}" itemValue="coNacionalidad" itemLabel="deNacionalidad"/>
<form:errors path="nacionalidad"/><br/>
<br/><br/>
<input type="submit" value="Registrar Usuario"/>
</form:form>
</body>
</html>

Y por ultimo la integración de todos los componentes con beans de spring que debes de colocar en el front controller <controller>-servlet.xml

frontController-servlet.xml
...

<bean id="loginInterceptor" class="pe.com.slcsccy.springmvc.controllers.LoginInterceptor"/>
<bean id="loginAduanasInterceptor" class="pe.com.slcsccy.springmvc.controllers.LoginAduanasInterceptor"/>




<bean id="handlerMappingSeguro" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<l-- recuerda que los inteceptores son llamados en el orden en que son declarados-->
<ref bean="loginInterceptor"/>
<ref bean="loginAduanasInterceptor"/>
</list>
</property>
<property name="urlMap">
<map>
<entry key="/aduanas/usuarioForm.do" value-ref="usuarioFormController"/>
</map>
</property>
</bean>


<bean name="usuarioValidator" class="pe.com.slcsccy.springmvc.validators.UsuarioValidator"/>


<bean id="usuarioFormController" class="pe.com.slcsccy.springmvc.controllers.UsuarioFormController">
<property name="facade" ref="facade"/>
<property name="sessionForm" value="true"/>
<property name="commandName" value="usuario"/>
<property name="commandClass" value="pe.com.slcsccy.springmvc.dominio.Usuario"/>
<property name="formView" value="forms/usuarioForm"/>
<property name="successView" value="forms/usuarioRegistrado"/>
<property name="validator" ref="usuarioValidator"/>
</bean>
...

Eso es todo por el momento, animate a hacer tu propia aplicación con todos los componentes, en el próximo post hablaré sobre como podemos crear componentes que permitan descargar hacia Excel y Pdf mediante poi e itext integrado con spring.

Spring MVC Implementando Internacionalización

2009-08-22T21:57:00.000-07:00

La internacionalización de tu aplicación consiste en hacerla accesible no solo para las personas localizadas en un país(con un determinado lenguaje, como el español para nosotros), sino tambien para aquellas personas en otros países(como Inglaterra, Francia ó Italia, que leen inglés, francés, italiano) La internacionalización consiste básicamente en que el texto que muestra tu aplicación en un determinado lenguaje pueda ser visto en otro lenguaje si cambiar nada de código, es decir si desde Italia accedo a tu aplicación entonces todo el texto tiene que estar en italiano, si desde Inglaterra accedo a tu aplicación entonces todo el texto tiene que estar en inglés. Pero, ¿como implementamos esto? ¿cuál es la mejor manera?. A veces cuando no se tiene un conocimiento profundo de la tecnología realizamos la aplicación sin tener en cuenta este punto osea implementamos todas los texto solo en nuestro lenguaje, para muestra un ejemplo:

- Si tenemos un pedaz de código en una página jsp como el siguiente:

Usuario: <input type="text" name="usuario"/>

Clave: <input type="text" name="clave"/>

-Entonces el texto(ó etiquetas) Usuario y Clave siempre van a aparecer en español para cualquier tipo de usuario(sea inglés, italiano, alemán...)

La solución está en asociar claves a las etiquetas y centralizar esta asociación en un archivo de propiedades, teniendo un archivo por cada lenguaje que desee soportar nuestra aplicación. El código jsp anterior se puede cambiar por lo siguiente:

<spring:message code="etiq.usuario"/><input type="text" name="usuario"/>

<spring:message code="etiq.clave"/><input type="text" name="clave"/>

Y el archivo de propiedades para tres idiomas sería:

1. Para soporte español(por defecto cuando el sufijo no es especificado)

mensajes.properties

etiq.titulo = Spring Framework

etiq.usuario = Usuario
etiq.clave = Clave

2. Para soporte inglés
mensajes_EN.properties
etiq.titulo = Spring Framework
etiq.usuario = User
etiq.clave = Password

3. Para soporte italiano
mensajes_IT.properties
etiq.titulo = Spring Framework
etiq.usuario = Utente
etiq.clave = Chiave

Cuando la aplicación sea invocada esta va a detectar el lenguaje del navegador y va a utilizar el archivo de propiedades apropiado.

Bueno, ahora veamos como Spring soporta todo este contexto de internacionalización. A diferencia de los post anteriores ahora vamos a agregar a la aplicación un contenedor de beans(un ApplicationContext.xml) adicionando al descriptor de despliegue lo siguiente:

<!--

Una variable de contexto que tendrá como valor el archivo de configuración del contenedor de beans.

-->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/applicationContext.xml</param-value>

</context-param>

<!--

Un listener de contexto que usará el archivo anterior para instanciar todos los beans que contiene

-->

<listener><listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class></listener>

Una vez declarado la ruta del contenedor de beans ahora lo definimos:

ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<!--

Declaración del bean que obtendrá el archivo y que a su vez lo hará disponible al resto de la aplicación(ya no tenemos que colocar los mensajes en duro) ahora podemos centralizar estos mensajes en un archivo mensajes.properties, este archivo debe de estar en la raiz de tu classpath, osea /WEB-INF/classes

-->

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

<property name="basename"><value>mensajes</value></property>

</bean>

</beans>

Los archivos de propiedades con los textos en cada idioma debemos de colocarlos en la raiz del classpath, es decir en /WEB-INF/classes . Esta carpeta quedaría como:

/WEB-INF/classes/mensajes.properties

/WEB-INF/classes/mensajes_EN.properties

/WEB-INF/classes/mensajes_IT.properties

Una vez configurada la aplicación procedemos a probarla con un archivo jsp:

index.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="spring" uri="http://www.springframework.org/tags" %>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title><spring:message code="etiq.titulo"/></title>

</head>

<body>

<form action="/usuario/procesar.do" method="POST">

<spring:message code="etiq.usuario"/><input name="usuario" type="text"/>

<spring:message code="etiq.clave"/><input name="clave" type="text"/>

</form>

</body>

</html>

Para finalizar, este tipo de diseño simplifica el desarrollo y mantenimiento de tu aplicación, ya no tienes que estar buscando en las miles de líneas de código en tu aplicación, todos los mensajes y textos los centralizas en un archivo de mensajes y si quieres cambiar algo, pues solo lo haces allí.

Spring MVC implementando la interface Controller

2009-08-22T13:24:00.001-07:00

En los 2 post anteriores hemos visto como podemos implementar un controlador(la C en MVC) mediante anotaciones, para aquellos a quienes no les guste este tipo de implementación pues hay una forma un poco más extensa y un tanto vieja, esta forma es mediante la implementación de la interface Controller, allí las va el código:

1. En el Front Controller(-servlet.xml) de tu aplicación declara el siguiente bean:

<!--

El siguiente bean mapeará las solicitudes /login/procesar.do hacia el controlador pe.com.slcsccy.springmvc.controllers.LoginController, estas solicitudes serán procesadas por el metodo: handleRequest(HttpServletRequest,HttpServletResponse) que deacuerdo al procesamiento ó lógica de negocio retornará hacia la vista apropiada

-->

<bean name="/login/procesar.do" class="pe.com.slcsccy.springmvc.controllers.LoginController">

<property name="vistaOk" value="iniciar"/>

<property name="vistaError" value="error"/>

</bean>

2. Crea una clase que implemente la interface Controller y agregale la lógica de negocia que tu quieras:

package pe.com.slcsccy.springmvc.controllers;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.Controller;

import pe.com.slcsccy.springmvc.dominio.Usuario;

public class LoginController implements Controller {

private String vistaOk;

private String vistaError;

Método definido en la interfaz Controller e implementado aquí para dar soporte a las solicitudes cuyo patrón URL está declarado en el Front Controller(frontController-servlet.xml)

public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

System.out.println("VistaOk:"+getVistaOk());

System.out.println("VistaError:"+getVistaError());

String usuarioRequest = request.getParameter("usuario");

if ("ccacique".equals(usuarioRequest)) {

/* Creamos los datos que supuestamente los obtenemos con un Service */

Map datosLogin = new HashMap();

Usuario usuario = new Usuario();

usuario.setNombres("Carlos Alberto");

usuario.setApellidos("Cacique Yupanqui");

usuario.setCodigo("ccacique");

datosLogin.put("usuario", usuario);

/* El constructor de ModelAndView recibe como parametros el nombre de la

vista hacia la cual vamos a responder y el modelo de datos que hemos obtenido.*/

return new ModelAndView(getVistaOk(), datosLogin);

} else {

Map datosError = new HashMap();

datosError.put("mensaje", "Usuario incorrecto");

return new ModelAndView(getVistaError(), datosError);

}

public String getVistaOk() {

return vistaOk;

}

public void setVistaOk(String vistaOk) {

this.vistaOk = vistaOk;

}

public String getVistaError() {

return vistaError;

}

public void setVistaError(String vistaError) {

this.vistaError = vistaError;

}

3. Define las vistas, para el caso solo 2 páginas jsp; error.jsp e iniciar.jsp

error.jsp:

<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Pagina de Error</title>
</head>
<body>PAGINA DE ERROR:
<c:out value="${mensaje}"/>
</body>
</html>

iniciar.jsp
<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>Aplicación J2EE</title></head>
<body>Bienvenido: <c:out value="${usuario.apellidos}"/>,<c:out value="${usuario.nombres}"/>
</body>
</html>

Comparando la forma de implementación de Controllers ya sea mediante anotaciones(@Controller) o mediante la implementación de la interfaz Controller(como vimos en este post), pues la tendencia es ir hacia lo que es anotaciones, con las anotaciones podemos prescindir de declarar los controllers en el FrontController, lo unico que tenemos que hacer es escanear el contexto del contenedor en busca de estereotipos y es el contenedor quien se encargará de detectar e instanciar los controllers adecuados, recuerda que el escaneo lo realizamos con la siguiente declaración:
<context:component-scan base-package="pe.com.slcsccy.springmvc.controllers"/>

Si aún así pues no te animas por las anotaciones pues en los siguientes post vamos a ver algo más de controllers más detallados y especificos para un problema particular.

Spring MVC Usando @Controller y Formularios

2009-08-20T23:03:00.000-07:00

En el post anterior vimos como podemos usar el estereotipo @Controller para mapear las solicitudes con la anotación @RequestMapping a métodos, esta vez vamos a ver como podemos usar formularios, validarlos y hacer uso de una clase estereotipada(denuevo @Controller) que controle y mapee adecuadamente las solicitudes que se hagan con el formulario, para esto la configuración de la aplicación no ha cambiado(no he modificado web.xml ni frontController-servlet.xml del post anterior y que voy a reutilizar).

Veamos el primer archivo cliente:

<a href="${pageContext.request.contextPath}/forms/usuario.do">Registrar Usuario</a>

La línea anterior la podemos colocar en cualquier archivo jsp y lo que hará es solicitar al controlador(UsuarioController.java) que me retorne la página donde voy a registrar al usuario, la clase estereotipada UsuarioController.java es la siguiente:

package pe.com.slcsccy.springmvc.controllers;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.ModelAttribute;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.SessionAttributes;

import org.springframework.web.bind.support.SessionStatus;

import pe.com.slcsccy.springmvc.dominio.Usuario;

import pe.com.slcsccy.springmvc.validacion.UsuarioValidador;

@Controller

@RequestMapping("/forms/usuario.do")

@SessionAttributes(types = Usuario.class)

public class UsuarioController {

/**

Este método es el que se ejecutará cuando las solicitudes tengan el patrón URL de la forma /forms/usuario.do y sean del tipo GET, es decir desde un link a href, desde un URL, desde javascript o cuando en el formulario html el atributo method sea GET o no esté especificado.

@RequestMapping(method = RequestMethod.GET)

public String inicializarFormulario(Model model) {

Al formulario le enviamos los datos por default de un usuario, este método actua como el inicializador o constructor del formulario

Usuario usuario = new Usuario();

model.addAttribute(usuario);

return "forms/usuario";

}

Este método será ejecutado solo cuando el patrón URL del formulario sea /forms/usuario.do y además el método del formulario que envía los datos solo sea POST, el detalle de los argumentos de los métodos es el siguiente:

@param @ModelAttribute contiene todos los datos del usuario que ha sido enviado desde el formulario

@param BindingResult, BindinResult es una interface, lo que hace Spring es crear un objeto que implementa esta interface,especificamente Spring implementa org.springframework.validation.BeanPropertyBindingResult este objeto se enlazará el objeto usuario enviado para permitir realizar las validaciones necesarias, extiende de Errors.

@param SessionStatus, objeto que determina si el PROCESAMIENTO de la session a sido completado o no, podemos usar este objeto para indicar a la aplicación que el PROCESAMIENTO de la session ha sido completado y que los atributos en él ya no son necesarios.

@RequestMapping(method = RequestMethod.POST)

public String procesarFormulario(@ModelAttribute Usuario usuario,

BindingResult resultado, SessionStatus estado) {

/* Validamos los datos del usuario */

new UsuarioValidador().validar(usuario, resultado);

/* Si no hay errores limpiamos la session y redireccionamos */

if(!resultado.hasErrors()){

/* Limpiamos los objetos de session para este procesamiento*/

estado.setComplete();

/* redireccionamos al método inicializarFormulario */

return "redirect:usuario.do";

}

/* Si hay errores los mostramos en el formulario */

return "forms/usuario";

}

La clase anterior usa un validador que es el siguiente:

UsuarioValidador.java

package pe.com.slcsccy.springmvc.validacion;

import org.springframework.util.StringUtils;

import org.springframework.validation.Errors;

import pe.com.slcsccy.springmvc.dominio.Usuario;

public class UsuarioValidador {

public void validar(Usuario usuario, Errors errors) {

if (!StringUtils.hasLength(usuario.getCodigo())) {

errors.rejectValue("codigo", "required", "required");

}

if (!StringUtils.hasLength(usuario.getNombres())) {

errors.rejectValue("nombres", "required", "required");

}

if (!StringUtils.hasLength(usuario.getApellidos())) {

errors.rejectValue("apellidos", "required", "required");

}

Espero haber sido lo suficientemente claro en los comentarios java, si tienes dudas no dudes en comentar.

La clase anterior será llamada cuando el usuario hace click en un enlace como:

<a href="${pageContext.request.contextPath}/forms/usuario.do">Registrar Usuario</a>

La clase será llamada porque el url(href) satisface el patrón declarado en la clase:

@RequestMapping("/forms/usuario.do") y el método a ejecutar será inicializarFormulario, porque dicho método está anotado para que le lleguen todas las solicitudes GET @RequestMapping(method = RequestMethod.GET) debes de recordar que una de las formas de realizar solicitudes GET es mediante links(href) en las páginas html.

Una vez ejecutado el método, este instanciarà un objeto usuario y lo devolverá en el modelo de datos a la siguiente vista:

usuario.jsp

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ page contentType="text/html" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Registro de Usuarios</title>

</head>

<body>

<form:form modelAttribute="usuario">

Codigo: <form:input path="codigo" /><form:errors path="codigo"/><br/>

Nombres: <form:input path="nombres" /><form:errors path="nombres"/><br/>

Apellidos: <form:input path="apellidos" /><form:errors path="apellidos"/><br/><br/><br/>

<input type="submit" value="Registrar Usuario"/>

</form:form>

</body>

</html>

Podemos ver el código html generado y notar que el atributo method(del formulario) es POST, entonces cuando le demos al botón "Registrar Usuario" este procesamiento será enviado hacia el método procesarFormulario de la clase UsuarioController.

Eso es todo por el momento, si tienes alguna duda puedes resolverla comentando...

Spring MVC Usando Controllers con Anotaciones

2009-08-18T21:47:00.000-07:00

Veamos como podemos implementar una pequeña aplicación en Spring que use SpringMVC con anotaciones de la manera más fácil posible.

Aquí estan los componentes:

1. Descriptor de despliegue(web.xml):

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5"

xmlns="http://java.sun.com/xml/ns/javaee"

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">

<!--

Declaración del servlet que Spring utilizará como Front Controller

para nuestra aplicación.

-->

<servlet>

<servlet-name>frontController</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>frontController</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

<session-config>

<session-timeout>30</session-timeout>

</session-config>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

2. Front Controller de SpringMVC(frontController-servlet.xml)

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<!--

La siguiente declaración buscará todos los estereotipos(Clases declaradas

con las anotaciones @Service,@Component,@Controller,@Repository)

en el paquete pe.com.slcsccy.springmvc.controllers una vez identificado el

estereotipo entonces el contenedor instanciará el bean y por lo tanto estará

listo para ser utilizado por la aplicación

-->

<context:component-scan base-package="pe.com.slcsccy.springmvc.controllers"/>

<!--

El siguiente bean configura las propiedades prefijo(prefix) y sufijo(suffix)

de Internalresourceviewresolver, el cual resuelve nombres de vistas lógicas

retornadas por los controladores(en el ejm:clases en el paquete controllers)

Por ejemplo, un nombre de vista lógico podría ser "resultadoPlanillaQuinta"

entonces esta vista será mapeada a "/WEB-INF/jsp/resultadoPlanillaQuinta.jsp"

-->

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"

p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>

</beans>

3. Un Controller de la aplicación(PlanillaController.java) que mapeará las solicitudes a métodos en esta clase:

package pe.com.slcsccy.springmvc.controllers;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

@Controller

public class PlanillaController {

Si el método en el controller esta mapeado pero no retorna nada, entonces

Spring lo que hará es buscar una vista con el mismo nombre que el patron

del mapping pero sin la extensión, es decir buscara un archivo jsp con el

siguiente nombre: iniciarApp.jsp, este archivo debe de estar en /WEB-INF/jsp/

@RequestMapping("/iniciarApp.do")

public void iniciarAplicacion() {

System.out.println("Inicio de la aplicación.");

}

El siguiente método acepta todas las solicitudes que vienen del patrón URL(en realidad es una ruta directa) /planilla/procesar.do,este patrón lo declaramos en la anotaciòn @RequestMapping, como salida tenemos un nombre de vista que va estar relacionado a un resolvedor de vistas, quién resolverá el recurso(archivo jsp) a presentar.

@RequestMapping("/planilla/procesarQuinta.do")

public String procesarQuinta(@RequestParam("periodo") String periodo, ModelMap modelo) {

modelo.addAttribute("periodo", periodo);

return "planilla/resultadoPlanillaQuinta";

}

@RequestMapping("/planilla/procesarCuarta.do")

public String procesarCuarta(@RequestParam("periodo") String periodo, ModelMap modelo) {

modelo.addAttribute("periodo", periodo);

return "planilla/resultadoPlanillaCuarta";

}

Este método difiere con los 2 anteriores en el tipo de retorno, ahora el

tipo de retorno no es una cadena sino un ModelMap, este modelMap debe

contener el modelo de datos a ser presentado en la vista, en los métodos

anteriores colocabamos el modelMap como un argumento al método y después

usabamos ese modelMap para colocar atributos(modelo de datos) que iban

a ser pintados en la vista. En este método la vista es resuelta hacia el

mismo URL que lo solicitó, es decir la vista se resuelve hacia:

/WEB-INF/jsp/planilla/cierre.jsp, recordar que el prefijo: WEB-INF/jsp/

y el sufijo son declarados en el frontController:

frontController-servlet.xml, ModelMap si revisas las fuentes de Spring extiende

LinkedHashMap que es una forma especializada de HashMap

@RequestMapping("/planilla/cierre.do")

public ModelMap cerrarPlanilla(@RequestParam("periodo") String periodo) {

/*Aquí consulta compleja a la base de datos para sacar los nombres*/

String[] nombres = {"Carlos","Alberto","Cacique","Yupanqui"};

return new ModelMap("nombres",nombres);

}

4. Ahora solo veamos los archivos jsp:

4.1 cierre.jsp (/WEB-INF/jsp/planilla/cierre.jsp)

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Cierre de Planilla</title>

</head>

<body>

<br><br>Planilla Cerrada<br><br>

<table>

<c:forEach var="nombre" items="${nombres}" varStatus="status">

<tr>

<td>${status.index}</td>

<td>${nombres[status.index]}</td>

</tr>

</c:forEach>

</table>

</body>

</html>

4.2 resultadoPlanillaCuarta.jsp (/WEB-INF/jsp/planilla/resultadoPlanillaCuarta.jsp)

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Resultado planilla Cuarta</title>
</head>
<body>
La planilla fue procesada para el periodo ${periodo}
</body>
</html>

4.2 resultadoPlanillaQuinta.jsp (/WEB-INF/jsp/planilla/resultadoPlanillaQuinta.jsp)
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Resultado planilla Quinta</title>
</head>
<body>
La planilla fue procesada para el periodo ${periodo}
</body>
</html>

El desarrollo de esta pequeña aplicación fué realizada con Spring 2.5.6, y el propósito es ver como podemos usar anotaciones en la capa de control de una aplicación MVC. Las anotaciones vistas fueron @Controller y @RequestMapping.

Podemos ver como las solicitudes que enviamos a la aplicació se mapean correctamente probando de la siguiente manera, en el URL de tu navegador puedes poner:

http://<server>:<puerto>/<app>/planilla/cierre.do?periodo=200908
http://<server>:<puerto>/<app>/planilla/procesarQuinta.do?periodo=200908

y debería ejecutar el método adecuado sgún el mapping y redirigirse a la vista apropiada.