Conceitos fundamentais do AspectJ

Existem vários tipos de pointcuts, usados consoante a query que é necessário escrever para capturar os joinpoints pretendidos. De todos os tipos de jointpoints, existem alguns que importa realçar pela sua especificidade.

Um dos quais é o within() (Formalmente designado como “Lexical-Structure based” pointcut).

Este tipo, é usado para capturar todos os pontos de junção  dentro do corpo de uma classe ou aspecto. Desta forma, não é de estranhar que a sua principal utilidade passe pela exclusão dos pontos de junção presentes nos aspectos.

Existem outros dois tipos de pointcuts que importa referenciar, já que foram particularmente importantes no desenvolvimento do nosso programa: O this() e o target(). Estes pointcuts capturam os joinpoints tendo por base os tipos de objectos em tempo de execução.

Tipicamente, de cada vez que é feita uma invocação de um método, esta invocação é efectuada a partir de um método de instância (métodos possuindo uma instância implícita – acessível através de “this”) ou de um método de classe (métodos “estáticos”).

No contexto de uma execução, o this() refere-se ao objecto “actual” e o target ao objecto onde o método está a ser invocado.

Na figura seguinte, podemos observar um caso típico de invocação onde ambos os tipos existem. Mas há existem casos particulares onde não existe this, target ou nenhum deles.

Por exemplo, quando a invocação é feita a partir de um método de classe (“estático”), como o main(), não existe caller ou this(). Quando o método invocado é estático (por exemplo em Math.sin() não existe callee ou target().

Finalmente, pode nem existir nenhum deles, caso tanto o método chamador como o método invocado sejam estáticos (no caso da invocação do Math.sin() a partir do main() por exemplo. Em suma, o caller (this) é o objecto em cujo método é feita a invocação (call).

O callee (target) é o objecto através do qual se faz a invocação. Existem ainda joinpoints onde o objecto target não está (ainda) disponível.

Na figura seguinte, por exemplo, na invocação da instrução ptx = new Point(199,123); dá-se caso do objecto ainda não estar criado. Assim, o seus this será MyClass, mas o target será null.

Conselhos (Advices)

É ainda necessário descrever que acção ou acções o sistema deverá executar nos pointcuts. Para isto, falta introduzir um último conceito: o conselho (advice).

Se os pontos de corte (pointcuts) são os pontos de execução de um programa onde pretendemos realizar operações,  os conselhos (advices) permitem-nos, na prática, especificar as ditas operações. Para especificar um conselho é – naturalmente – obrigatório associá-lo a um ponto de corte (pointcut), que por sua vez é um subconjunto de todos os pontos de junção (joinpoints) presentes no sistema.

Para além disso, é possível também indicar o momento mais indicado para que o código presente no concelho seja executado: antes (before), “em torno” (around) e depois (after) do instante capturado pelo ponto de corte (pointcut).

Na realidade, existem 3 tipos de after. O after(), que é sempre executado, o after() returning que apenas é executado quando o método associado ao ponto de junção retorna e o after() throwing  que é apenas executado quando o método associado ao ponto de junção lança uma exepção.

Um conselho com execução “em torno” do jointpoint pode alterar ou simplesmente substituir o código capturado pelo declarado dentro do conselho.

Continuado com o exemplo da 2ª figura, podemos escrever um concelho que simplesmente escreva no ecrã a seguinte frase: “Olá, estive por aqui”.

Em primero lugar, é necessário especificar o momento de execução do conselho. Neste exemplo, escolhemos before(), i.e., o código do conselho deve ser executado antes do código presente no corpo do método.

Em seguida, especificamos qual o nome do ponto de corte à qual devemos associar o conselho. Seria, igualmente possível especificar directamente o ponto de corte directamente na assinatura do conselho (por exemplo: before():execution(public void umMetodo(..));)

A vantagem na utilização de nomes para referenciar os advices aos pointcuts é simplesmente uma questão prática de reutilização de código.

Uma vez definido o código do conselho, podemos ver a sua hipotética execução na figura seguinte.

 

 

O passo inicial é a invocação do ajc (compilador do AspecJ) indicando explicitamente todos os ficheiros necessários à compilação (é possível passar uma biblioteca já compilada através de ficheiros .jar, por exemplo).

De seguida, executa-se o código e assiste-se à execução do código do conselho no local (aliás, imediatamente antes) do local que foi capturado pelo ponto de corte. Apesar de neste exemplo se usar o before(), o identificador after() teria uma semelhante prestação (executando depois do resto do código).

Contudo, o around() tem um funcionamento um pouco diferente e vale a pena realçar o seu funcionamento uma vez que é o tipo de conselho que mais usamos ao longo da implementação da nossa ferramenta, uma vez que nos permite uma melhor simplicidade e organização do código.

Por outro lado, consegue-se garantir, de uma forma mais forte, que o ponto de corte pertence ao mesmo evento da execução do programa.

Este tipo especial de conselho tem a particularidade de “envolver” a execução, permitindo continuar com a execução original, alterar o seu contexto ou simplesmente substituir as instruções originais por outras instruções. Se dentro do conselho, pretendermos executar o código original, é necessário usar uma palavra especial – proceed().

Na figura seguinte, damos um exemplo de uma utilização simples do around(). Começamos por identificar o pointcut e de seguida o código que deverá ser executado, neste caso, um simples bloco try/catch que irá lançar uma excepção em caso de existência de algum erro.