Interceptores con Spring AOP

Hola a todos de nuevo.. estos días me he encontrado bastante ocupado por los parciales en la U y viendo trámites para sacar mi licencia de conducir (brevete) que ia sale :d. Ahora que todo está tranquilo en el trabajo me he animado por escribir un poco más acerca de Spring AOP, en este caso con sus Interceptores.  Estoy también analizando las propuestas que hacen en sus comentarios para futuros post.

Bueno había ya realizado un artículo en donde explicaba la forma de realizar métodos transaccionales con Spring AOP en transacciones-con-hibernate-y-Spring-AOP .

Ahora más bien veremos de lo que se tratan los interceptores y su utilidad en la bitácora de las aplicaciones en conjunto con log4j. Para empezar teóricamente definiremos el concepto de interceptor.

AOP son las siglas en ingles de Programación orientada al aspecto (Aspect Oriented Programming). Además, como sabemos la definición más simple de AOP es “una manera de eliminar codigo duplicado”. Un ejemplo práctico para la utilidad del AOP, es generar un interceptor, que inspeccionará el codigo que se va a ejecutar, permitiendo por lo tanto realizar ciertas acciones como : trazas cuando el método es llamado (bitácora), modificar los objetos devueltos o envio de notificaciones.

¿Qué es un interceptor?

Vimos hasta ahora que con Spring podemos delegar la creación de objetos, e inyectarles dependencias. Además, sabemos que usamos interfaces para castear los objetos que nos devuelve o inyecta Spring, de forma tal de poder lograr una real independencia de las implementaciones.
¿Qué pasaría entonces si, en tiempo de ejecución, se pudieran crear clases que intercepten los llamados y realicen acciones adicionales? Es decir, el poder agregar comportamiento en tiempo de ejecución, sin tocar el código.
Este es el concepto de los interceptores. Un interceptor es una clase que cumple con cierta interfaz, y su objetivo es "interponerse" en la ejecución de un método. Así, un interceptor es capaz de ejecutarse antes de un método dado, realizar acciones, y luego continuar con la ejecución normal (o abortarla).
Este tipo de concepto se conoce como Programación Orientado a Aspectos.

Un interceptor muy útil, por ejemplo, podría ser de log: algo que intercepte todas las llamadas a los objetos de Negocio y deje registrado la hora de la invocación, los parámetros, el valor de retorno, etc.

Configurando Nuestro Interceptor

Para configurar el Spring AOP con interceptor, nuestra aplicación deberá contar con las siguientes librerías:

• spring.jar
• log4j-1.2.14.jar
• commons-logging-1.1.jar
• cglib-2.1.jar
• aopalliance.jar
• aspectjrt.jar
• aopalliance.jar

Todos estos y algunos más los puedes obtener en la siguiente dirección  download lib .

Configurando el applicationContext.xml

<beans xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 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/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
              ">
 
<!-- *********** INI :  DATASOURCE CONFIGURATION ************ -->    
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="/WEB-INF/jdbc.properties"/>
    </bean>
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">        
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>       
    </bean>   

 <!-- *********** INI : IBATIS CONFIGURATION  ************* -->   
   
     <!-- SqlMap setup for iBATIS Database Layer -->
    <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
        <property name="configLocation">
            <value>classpath:/gob/minedu/capacitacion/persistency/ibatis/sql-map-config-cxa.xml</value>
        </property>
        <property name="dataSource"><ref local="dataSource"/></property>     
    </bean> 

<!-- ************ INI: INTERCEPTOR DAO  ************** -->
<aop:config  proxy-target-class="true"> 
      <aop:pointcut id="businessOperation" expression="execution(* gob.minedu.capacitacion.*.dao.ibatisImpl.*.*(..))"/>
      <aop:advisor advice-ref="logInterceptor" pointcut-ref="businessOperation"/> 
</aop:config>

<bean id="logInterceptor" class="gob.minedu.shared.common.util.LogInterceptor"/>

<import resource="application-service.xml"/>

</beans>

Explicaremos lo relevante para este artículo.. las otras partes del applicationContext.xml han sido explicadas en anteriores artículos. Analizando la configuración del interceptor.

• 
  
  En vista de que no existe un TransactionManager es necesario poner proxy-target-class="true".
• 
  
  aop:pointcut : Punto de corte definido por patrones de nombres o expresiones regulares. La estructura de la expresión depende de la estructura de nuestra aplicación.
• 
  
  aop:advisor advice-ref="logInterceptor", referencia a la clase que implementa el aspecto. Se insertan en la aplicación en los Puntos de Corte.

Implementación de la clase interceptora LogInterceptor.java

package gob.minedu.shared.common.util;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;


/**
 * @author Pedro.Rios
 *
 */
public class LogInterceptor implements MethodInterceptor {
 private static final Logger log = Logger.getLogger(LogInterceptor.class);
 
 public Object invoke (MethodInvocation metodo) throws Throwable {
  
 log.debug("INI DAO: Clase Invocada "+metodo.getMethod().getDeclaringClass().getSimpleName() +" Metodo solicitado "+metodo.getMethod().getName());
 
 //Generamos la lista de argumentos que recibe el metodo separados por una coma   
    String arguments = new String();               
    for (int i = 0; i < metodo.getArguments().length; i++) {   
        arguments += metodo.getArguments()[i] + " ,";                
    }   
       
    // el metodo recibe al menos un argumento quitamos el espacio y la coma del final   
    if (arguments.length()> 0) {   
        arguments = arguments.substring(0, arguments.length() - 2);   
    }   
    log.debug("Argumentos: "+arguments);
 
 Object obj = metodo.proceed();
 log.debug ("FIN DAO: El método ha devuelto : "+obj);
 return obj;
 }
}

Definición del archivo log4j.properties

log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.stdout.threshold=DEBUG

log4j.logger.org.ibatis=INFO
log4j.logger.org.apache=INFO
log4j.logger.org.springframework=INFO

#Sql: log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Connection=INFO
#Resultado sql: log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.ResultSet=INFO

Si no sabes como configurar el log4j y donde ubicar el archivo.properties puedes ver el web.xml del artículo  http://periospino.blogspot.com/2010/03/integrando-struts-spring-ibatis.html 

Con eso es suficiente para integrar Spring con Log4j.

De todas formas ya se viene un artículo explicando al detalle el uso de Log4j.

Para mayor informacíón:

• wiki/Interceptores_Con_Spring
• Tutorial de AOP
• Aplicación de SpringAOP

Bueno amigos me despido y hasta la próxima publicación... Espero sus comentarios.