Spring AOP stopwatch

Uno de los usos que podemos dar a la programacion orientada a aspectos (AOP) es medir el tiempo que tarda un metodo en ejecutarse. Vamos a ver como podemos usar el framework de Spring con AOP para medir el tiempo que tarda un metodo de una clase en ejecutarse

Lo primero sera crear una clase que haga una operacion sencilla

package es.rubenjgarcia.aop;

public class Foo {

	public void bar()
	{
		for (int i = 0;i<10000000;i++)
		{
			String foobar = "foobar";
			foobar.replaceAll("o", "i");
		}
	}
}

Este es el metodo al que vamos a medir el tiempo que tarda en ejecutarse. Lo siguiente es añadir las dependencias al proyecto Maven

<dependencies>
        <!-- Spring AOP -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>3.2.8.RELEASE</version>
	</dependency>
        <!-- Necesario para Spring AOP -->
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.7.3</version>
	</dependency>
        <!-- Dependencia para la inicializacion del contexto Spring-->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>3.2.8.RELEASE</version>
	</dependency>
        <!-- Para ejecutar tests de Spring -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>3.2.8.RELEASE</version>
		<scope>test</scope>
	</dependency>
        <!-- Junit para probar nuestro proyecto -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.11</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Con esto ya tenemos todas las dependencias necesarias, ahora empecemos a crear el codigo que hara el trabajo

package es.rubenjgarcia.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.util.StopWatch;

@Aspect
public class FooAspect {

	@Around("execution(* es.rubenjgarcia.aop.Foo.*(..))")
	public Object measureMethod(ProceedingJoinPoint pjp) throws Throwable
	{
		StopWatch sw = new StopWatch();
		Object retVal;
		try
		{
			sw.start(pjp.getTarget()+"."+pjp.getSignature());
			retVal = pjp.proceed();
		}
		catch (Throwable e)
		{
			throw e;
		}
		finally
		{
			sw.stop();
			System.out.println(sw.prettyPrint());
		}
		return retVal;
	}
}

Lo primero que vemos en la clase es la anotacion @Aspect que indica que la clase controla aspectos. El unico metodo que hemos definido measureMethod tiene una anotacion, @Around. Esta anotacion sirve para decirle que queremos que este metodo se ejecute “alrededor” de nuestro metodo, es decir, que tenemos el control del metodo antes de su ejecucion y podemos ejecutarlo cuando queramos o incluso no ejecutarlo, ademas de poder devolver otro valor en vez de el que nos devuelve la ejecucion de nuestro metodo

Esta anotacion siempre va acompañada de la definicion que vemos entre parentesis, aqui es donde indicamos los metodos que queremos que sean interceptados. En el caso del ejemplo le hemos dicho que queremos capturar los metodos de cualquier tipo (* – public, protected, …) de la clase es.rubenjgarcia.aop.Foo con cualquier nombre (*) y con cualquier argumento ( (..) ). Para mas informacion sobre como parametrizar esto puedes mirar aqui

El metodo recibe un argumento de tipo ProceedingJoinPoint. Este objecto contiene la informacion del metodo que se va a ejecutar asi como la posibilidad de ejecutarlo

Para medir el tiempo creamos un StopWatch y lo iniciamos dandole el nombre de nuestra clase y el nombre del metodo

Para ejecutar el metodo llamamos al metodo proceed del objeto ProceedingJoinPoint que hemos recibido en nuestro metodo. Por ultimo paramos el reloj y sacamos por pantalla el resultado

Lo siguiente es crear las clases de configuracion de Spring. Al usar Spring AOP solo podemos usar estos aspectos con clases que maneje Spring. Para esto vamos a crear una clase de configuracion de nuestro contexto

package es.rubenjgarcia.aop;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class ConfigBean {

    @Bean
    public Foo foo() {
        return new Foo();
    }
	
    @Bean
    public FooAspect fooAspect() {
        return new FooAspect();
    }
}

El proposito de esta clase es configurar todo el contexto de Spring. En vez de usar una configuracion basada en XML, a partir de la version 3 de Spring se pueden usar anotaciones para configurar el contexto. Para configurar el contexto hay que anotar una clase con la anotacion @Configuration

Usando la anotacion @EnableAspectJAutoProxy le indicamos a Spring que habilite AOP para nuestra aplicacion

La anotacion @Bean es la que inyecta nuestros beans en el contexto para poder usarlo mas adelante

Con esto todo nuestro proyecto ya esta listo para ser probado. Solo necesitamos crear un test que pruebe si todo ha ido correctamente

package es.rubenjgarcia.aop.test;

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;

import es.rubenjgarcia.aop.ConfigBean;
import es.rubenjgarcia.aop.Foo;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=ConfigBean.class)
public class TestAOP {

	@Autowired
	private Foo foo;
	
	@Test
	public void test()
	{
	    foo.bar();
	}
}

Debemos indicar que queremos ejecutar nuestro test unitario con la clase SpringJUnit4ClassRunner para que Spring se inicialice. Ademas hay que indicar como vamos a configurar el contexto, en este caso usamos la clase ConfigBean que hemos creado indicandolo en la anotacion @ContextConfiguration

La anotacion @Autowired que tiene nuestro atributo foo es la que se encarga de inyectar el bean Foo que vamos a usar. Si ejecutamos el test lo que veremos sera algo parecido a esto

StopWatch '': running time (millis) = 4885
-----------------------------------------
ms     %     Task name
-----------------------------------------
04885  100%  es.rubenjgarcia.aop.Foo@4a5f2db0.void es.rubenjgarcia.aop.Foo.bar()

Si quieres descargarte el codigo puedes hacerlo desde mi cuenta en Github pulsando en el siguiente boton

Comparte este articuloShare on FacebookShare on Google+Tweet about this on TwitterShare on LinkedIn

Comentarios

comentarios