Descripción

AspectJ es una extensión del lenguaje Java para poder utilizar la programación orientada a aspectos dentro de esta tecnología. La consecuencia de ser una extensión de Java es que cualquier programa valido para Java lo va a ser para AspectJ ya que el bytecode AspectJ es compatible con la jvm.

Historia

Los inicios de AspectJ se remontan en la empresa Xerxo PARC donde un conjunto de ingenieros intentaban reducir la complejidad de las aplicaciones utilizando la programación orientada a aspectos, tiempo después crearon un lenguaje específico para programar con AOPAspectJ.

AspectJ actualmente

A dia de hoy AspectJ es un proyecto de la fundación Eclipse y es uno de los lenguajes d'aop más utilizados en la plataforma Java (ver plataformas), se podría decir que se ha convertido en un estándar dentro de la programación orientada a aspectos en Java siendo utilizado en diferentes proyectos.

Para utilizar AspectJ de manera integrada con IDEs existe soporte en Eclipse mediante un plugin llamado AJDT (AspectJ Development Tools).

¿Qué puedo hacer con AspectJ?

Dejando de banda las ventajas que proporciona la programación orientada a aspectos, el utilizar AspectJ te proporciona dos características importantes. Por una parte la implementación transversal dinámica y otra implementación transversal estática.

La implementación transversal dinámica permite cambiar la ejecución de u programa, es decir, modificar el código existente o añadir más código por lo que dotamos a nuestas clases de un comportamiento adicional que no tienen "codificadas". Un ejemplo podría ser el siguiente, cada vez que la aplicación ejecutase el método XXX() comprobase si la persona logeada en el sistema tiene capacidad para ejecutar este método y actuar en consecuencia. La implementación de XXX() no sabe absolutamente nada de seguridad, de eso se encarga el aspecto en cuestión.

La implementación estática (static crosscuting} permite modificar la estructura estática de un programa con lo que permite añadir métodos, variables, o incluso extender clases o implementar interficies.

Un ejemplo de como implementar una interfaz con AspectJ mediante c

declare parents: Sensor implements Controlable;
 public void Sensor.control(String mensaje) {
		//bla bla bla
	}

En el código de la clase Sensor no se ve por ningún sitio la interfaz Controlable ni la implementación del método, mágia.

¿Como se programa en AspectJ?

Si ya se tiene experiencia con Java programar con AspectJ no tiene porque ser complicado, ya que al tratarse de una extensión del propio lenguaje Java, programar con AspectJ es como si se programase con Java con pequeñas modificaciones en el lenguaje, especialmente en las reglas de composición, lo que serían los pointcuts.

Antes de empezar a ver como se programa un aspecto con AspectJ es importante tener claros la terminología básica que hay dentro de este lenguaje de programación.

• Aspecto: Representa una funcionalidad del programa. En AOP un aspecto representan un requerimiento que esta distribuido por toda la aplicación, como por ejemplo el típico ejemplo de el sistema de logging o seguridad.
• JoinPoint: Toda aplicación de software ejecuta llamadas a métodos, constructores, etc en su ejecución. Se llama JoinPoint a cualquier punto de ejecución de una aplicación.
• PointCut: Los pointcuts se encargan de definir que JointPoint y bajo que circunstancias se quiere que se dispare el PointCut. Por ejemplo, un PointCutejecutame se desea que se active en todos los métodos start() dentro del package com.javaconganas".
• Advice: Dentro del advice se específica la lógica que quiere que se ejecute cuando se aplican los puntos de corte.

Un ejemplo práctico

En nuestra fase de desarrollo queremos tener un control de lo que se está ejecutando, el problema es que tenemos muchas clases y métodos para controlar por que decidimos crear un Aspecto de Logging. Con esto ganamos dos cosas, centralizamos todo el proceso de Logging en un fichero por lo que ya no tenemos que implementar el logging en cada método o donde sea que queramos controlar y por otra parte no perdemos tanto tiempo implementando el sistema de logging ya que lo tenemos todo centralizado. El código para implementar un Aspecto de logging para el método run de la clase Test es el siguiente.

public aspect LoggingAspect {
    pointcut log() : execution(* Test.run(int));
    after() : log() {
        Signature sig = thisJoinPoint.getSignature();
        System.out.println("Despues " + sig.toString() + " - " + thisJoinPoint.getTarget() + " - (args: "
                + thisJoinPoint.getArgs().length + ")");
    }
    before() : log() {
        Signature sig = thisJoinPoint.getSignature();
        System.out.println("Antes " + sig.toString() + " - " + thisJoinPoint.getTarget() + " - (args: "
                + thisJoinPoint.getArgs().length + ")");
    }
}

Como se observa en el código anterior, le estamos diciendo en el pointcut que intercepte la llamada a run(int) dentro de la clase Test, a partir de ahí es cosa vuestra jugar con los puntos de corte. Podéis pasar por completo del getSignature(), simplemente es para obtener información.

Prerrequisitos

• ¿Sé que es la AOP?

Referencias

• Sitio web oficial de AspectJ.
• Hola mundo en AspectJ.

Checklist

• Sé que es un punto de corte?
• Sé que es un advice?

¿Y ahora?

• Documentación oficial