Control de excepciones con Spring su AOP y las anotaciones

A través de las anotaciones y los aspectos de Spring 3 tendremos una forma sencilla de controlar las excepciones en un conjunto de métodos.

Una de las grandes virtudes de Spring es la programación orientada a aspectos, y con ella se pueden hacer cosas muy interesantes y realizar este mismo ejemplo de múltiples formas. Aquí pondremos un sencillo ejemplo de captura de excepciones.

Para empezar crearemos la anotación con la cual queremos realizar el control de excepciones. Aquí indicamos a que tipo de elementos queremos que afecte al anotación (a través de @Target) y en que fase queremos que sea tenida en cuenta (a través de Retention). Target es más claro de entender pero Retention nos permite indicar si va a ser tenida en cuenta la anotación solo en el código fuente (SOURCE), en la compilación (CLASS) o durante su ejecución (RUNTIME).

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExcepcionControl {
}

Luego creamos la clase que contendrá el aspecto y que indicará en que casos y que acciones realizar en caso de que se de la acción a controlar. Los aspectos nos permiten controlar acciones que se realizan de forma general en toda la aplicación y no en una única clase. Una vez creada una clase que funcione como aspecto a través de la anotación @Aspect, debemos indicar que un 'Pointcut' que será aquella zona donde queremos que se vean afectadas las acciones a tomar, y un 'Advice' que son las acciones a tomar.

@Aspect
@Component
public class ExceptionAspect {

 private static Logger LOGGER = Logger.getLogger(ExceptionAspect.class);
 
 @Pointcut("@annotation(es.home.almacen.bbdd.annotation.ExceptionControl)")
 protected void exceptionControl() {}
 
 @Around("exceptionControl()")
 public Object catchException(ProceedingJoinPoint joinpoint) throws Throwable {
  Object exit = null;
  try {
   exit = joinpoint.proceed();
  } catch (Exception except) {
   LOGGER.error("Excepcion capturada en el advice: "+except.getMessage(), except);
   throw  new AlmJpaRepoException(except);
  }
  return exit;
 }
}

Como hemos comentado anteriormente, se puede realizar esto mismo de multiples formas y esto no es más que un ejemplo. Para ver una información más detallada lo mejor es ver la documentación oficial de Spring. Aquí vemos como indicamos que el punto de control será la anotación ExceptionControl y como en el catchException capturamos cualquier excepción y la traducimos o realizamos por ellas las acciones pertinentes.

Por último solo nos queda los ficheros de configuración, en el application context de spring indicamos que vamos a utilizar aspectos y que sean tenido en cuenta:

 
 
....

Y en el pom.xml indicamos las librerías a utilizar, en nuestro caso hemos utilizado Spring 3.

 3.1.2.RELEASE
 1.7.0 

 
   
   
 org.springframework.data
 spring-data-jpa
 ${jpa.data.version}
    
    
    
        org.springframework
        spring-aop
        ${spring.version}
    
    
        org.aspectj
        aspectjrt
        ${aspectj.version}
    
    
        org.aspectj
        aspectjweaver
        ${aspectj.version}
    

Un ejemplo de uso sería el siguiente, donde no necesitariamos capturar las excepciones sino que el aspecto se encargaría de ello:

@ExceptionControl
public Page findSearchDiscs(final String nombre, final String grupo,final Pageable pageable) {
 return dao.findSearchDiscs(nombre, grupo, pageable);
}