AOP con Spring 2 y Anotaciones

En este post voy a mostrar como hacer uso de la Programación Orientada a Aspectos (AOP en ingles) que es un de las dos grandes características de Spring junto a la inyección de dependencia Gracias a la AOP se pueden encapsular los diferentes conceptos que componen una aplicación en entidades bien definidas, eliminando las dependencias entre cada uno de los módulos (Wikipedia).

Para el uso de AOP vamos a usar la librería Spring 2 y el uso de las anotaciones que es la forma más sencilla y práctica de configurarlo. En este ejemplo haremos una simple clase que permitirá el registro del tiempo que tardan en ejecutarse los métodos de los servicios de la aplicación.

Las librerías a añadir al proyecto deben de ser como mínimo las 3 siguientes, añadiendo el core de spring y las necesarias para el uso de AOP y las anotaciones.

 org.springframework
 spring
 2.5.6


 org.springframework
 spring-aop
 2.5.6


 org.springframework
 spring-aspects
 2.5.6

En el fichero de configuración de Spring debemos incluir las siguientes líneas:

- Configurar el fichero para realizar el correcto uso de etiquetas.

- configuracion para los aop. que permite coger las clases configuradas mediante aspect

- configuracion para las anotaciones

La clase de ejemplo que nos permitiría registrar el tiempo que tardan en realizar los metodos de los services es:

@Component
@Aspect
public class LogTimeAspect {
 private static final Logger LOGGER = Logger.getLogger(LogTimeAspect.class);
 @Pointcut("execution(* es.home.service.impl.*.*(..))")
 public void logCheck() {
  // Metodo vacio a proposito. Permite hacer el poincut que requerimos
 }
 @Around("logCheck()")
 public Object profile(final ProceedingJoinPoint pjp) throws Throwable {
  final Signature signature = pjp.getSignature();
  LOGGER.info("Init - " + signature.getDeclaringTypeName() + " - " + signature.getName());
  final long start = System.currentTimeMillis();
  final Object output = pjp.proceed();
  final long elapsedTime = System.currentTimeMillis() - start;
  LOGGER.info("Init - " + signature.getDeclaringTypeName() + " - " + signature.getName());
  LOGGER.info("Method execution time: " + elapsedTime + " milliseconds.");
  return output;
 }
}

- Con la anotación @Component indico que es un componente de Spring y que sea registrado y tenido en cuenta por la aplicación, y con la la anotación @Aspect que la clase es utilizada como un aspecto.

- Con la anotación @Pointcut declaramos un 'Punto de Corte', es decir que indicamos a la aplicación cuando queremos que se ejecute un determinado codigo (En este caso el incluido dentro del método). Con la declaración que le sigue indicamos cuando queremos ejecutarlo. En nuestro caso le indicamos que en todos los métodos de todas las clases de un determinado paquete de la aplicación (en es.home.service.impl están las clases y métodos a registrar).

- Con la anotación @Around, indicamos que se ejecute el código del método asociado antes y despues del ejecutado por un determinado 'Punto de Corte' en este caso logCheck. Por lo que podremos medir el tiempo antes de comenzar el método y despues de ejecutarse el método, y con su resta saber el tiempo de ejecución total.

En la documentación de Spring podéis encontrar que esto no es mas que la punta del iceberg y se pueden configurar los Poincuts de varias formas y también la existencia de otras anotaciones que permiten la ejecución de código al asociarse al Poincut de otras formas. Aquí la documentación oficial