Programação Orientada a AspectosProgramação Orientada a Aspectos

Pós-Graduação em Análise, Projeto e Gerência de Sistemas de Informação

Professora: Aline Vasconcelos

apires@iff.edu.br

2

Programação Orientada a Aspectos

O que é AOP???? Algo Novo??!! AOP: Aspect Oriented Programming

(Programação Orientada a Aspectos)

Técnica que permite separar os interesses transversais (crosscutting concerns) dos interesses-base de um sistema, fazendo com que o software se torne mais inteligível, e, conseqüentemente, facilitando a sua Manutenção e Reutilização (Kiczales et al., 1997).

Minimiza impacto das Manutenções, evitando o espalhamento de código. Diminui riscos de efeitos colaterias (side effects) durante as mudanças.

3

Boa modularidade

Código do Apache

4

Boa modularidade

Código do Apache

Parse XML

5

Boa modularidade

Código do Apache

Parse XML

Busca de Padrões de URLs

6

Falta de modularidade

Código do Apache

Parse XML

Busca de Padrões de URLs

Log

7

Mais falta de modularidade

Código do Apache

Parse XML

Busca de Padrões de URLs

Log

Segurança

8

O que temos aqui?

Falta de Modularidade Código Espalhado Código Redundante

If (user not authorized) {

error (“Mensagem de erro 1”);

}

9

Custo de Código Espalhado

Código Redundante Mesmo pedaço de código em vários lugares

Dificuldade de Entendimento Dificuldade de Manutenção

Necessidade de encontrar todo o código espalhado (ou embaraçado)

... e verificar que em todos os pontos as alterações foram feitas corretamente

... e ter certeza de não fazer besteira por acidente

… Riscos de Efeitos Colaterais em Manutenções!!!

10

Qual é a idéia da AOP?

●A Ortogonalidade é inerente a sistemas complexos

●Criar uma estrutura natural para a modularização deste tipo de código

●Como?

●Com suporte de linguagens e ferramentas

11

O que são Aspectos?

Classificamos códigos ortogonais como Preocupações Ortogonais

Ou PO Ou Crosscutting concerns

E chamamos de Aspectos(Aspects) as PO’s bem modularizadas

E AOP a programação orientada a modularização das Pos.

12

Características da AOP Non-disruptive technology:

É possível continuar usando OOP É possível utilizar com sistemas já

existentes Não modifica o código fonte

Não é difícil de aprender(?) Bom suporte de ferramentas Integração com várias IDE's

13

Aplicações

Log Persistência Distribuição Otimização Segurança Design Patterns Regras de Negócio!

14

Implementações Mais conhecidas:

AspectJComposition FiltersHyper/JDemeterJ

Nem tanto, mas interessantes:Jmangler(outro)

15

Integração

16

------------------

AspectJ (http://eclipse.org/aspectj/)

Uma extensão da linguagem JavaJava para o tratamento de AspectosAspectos.

ajcajc: compilador e weaver de bytecode Java.

Processo de weaving: -------------------

ASPECTOS

Application Jar File

WEAVING

Aplicação + Aspectos

17

AspectJ: Alguns Conceitos

Join Points: pontos bem definidos no fluxo de controle do programa onde o aspecto pode inserir o código ortogonal.

Pointcuts: conjunto de join points onde o código será inserido.

Advices: código que é executado quando um join point é alcançado no fluxo de controle do programa.

Aspects: unidade de modularidade para requisitos ortogonais. Comportam-se como classes Java, mas podem incluir também as construções do AspectJ.

18

AspectJ: Alguns Conceitos

Exemplos de JoinPoints: Method Calls

Method Executions

Object Instantiations

Constructor Executions

Field References

Handler Executions

19

AspectJ: Alguns Conceitos

Exemplos de Pointcuts:

call (signature)

execution (signature)

get (signature) e set (signature)

exception handler

Etc. For a complete list, take a look at:

http://www.eclipse.org/aspectj/doc/released/progguide/quick.html#quick-pointcuts

20

AspectJ

Uma aplicação Exemplo:

21

AspectJ: Exemplos de Pointcuts

call(void Point.setX(int)) – toda chamada de método para “void setX(int)” em objetos do tipo Point serão interceptadas pelo aspecto.

call(void Point.setX(int)) || call(void Point.setY(int))

Toda chamada de método para “void setX(int)” em objetos do tipo Point e chamadas de método para “void setY(int)” serão interceptadas pelo aspecto.

call(void FigureElement.setXY(int,int)) || call(void Point.setX(int)) || call(void Point.setY(int)) || call(void Line.setP1(Point)) || call(void Line.setP2(Point));

22

AspectJ

Uma aplicação Exemplo:

23

AspectJ: Exemplos de Pointcuts

pointcut move():

call(void FigureElement.setXY(int,int)) call(void FigureElement.setXY(int,int)) || ||

call(void Point.setX(int)) || call(void Point.setX(int)) ||

call(void Point.setY(int)) || call(void Point.setY(int)) ||

call(void Line.setP1(Point)) || call(void Line.setP1(Point)) ||

call(void Line.setP2(Point)); call(void Line.setP2(Point));

24

AspectJ: Exemplos de Pointcuts

É possível especificar pointcuts utilizando “wildcards”, ou seja, especificando propriedades de métodos:

call(void Figure.make*(..))

call(public * Figure.* (..)) É possível especificar pointcuts com base no fluxo

de execução:

cflow(move())

25

AspectJ: Advices

BeforeBefore: é executado quando um join point é alcançado, porém antes que o programa prossiga com o join point. Por exemplo, para o join point “method call”, o advice é executado antes que o método comece a rodar, logo que os seus argumentos são avaliados.

After:After: é executado depois que o programa finaliza a execução do join point. Por exemplo, para o join point “method call”, o advice é executado depois que o método é executado, mas antes que o controle retorne ao chamador. Existem 3 tipos: After Returning, After After Returning, After Throwing, After.Throwing, After.

26

AspectJ: Advices Exemplos

before(): move() { System.out.println("about to move"); }

after() returning: move() { System.out.println("just successfully moved"); }

around() - Around advice em um join point é executado assim que o join point é alcançado, e tem o controle a respeito de quando o programa deve prosseguir com o join point.

27

AspectJ: Advices Exemplos

around(): move() { System.out.println("about to move");

proceed();System.out.println(“object

moved"); }

28

AspectJ: Expondo Contexto em Pointcuts

Valores expostos por um Pointcut em seu Joinpoint podem ser usados no código do Advice:

Existem 3 Pointcuts primitivos que são usados para publicar estes valores:

This: objeto atualmente sendo executado.

Target: objeto alvo de uma chamada, por exemplo.

Args: argumentos de uma chamada de método.

29

AspectJ: Expondo Contexto em Pointcuts

pointcut setXY(FigureElement fe, int x, int y):pointcut setXY(FigureElement fe, int x, int y): call(void FigureElement.setXY(int, int)) && target(fe) && args(x, y);

after(FigureElement fe, int x, int y) returning:after(FigureElement fe, int x, int y) returning: SetXY(fe, x, y)SetXY(fe, x, y) { System.out.println(fe + " moved to (" + x + ", " + y + ")."); }

ADVICE!ADVICE!

30

AspectJ: Programando Aspectos

aspect Loggingaspect Logging { private OutputStream logStream = System.err;

pointcut move():pointcut move():

call(void FigureElement.setXY(int,int)) || call(void Point.setX(int)) ||

call(void Point.setY(int)) || call(void Line.setP1(Point)) || call(void Line.setP2(Point));

before(): move()before(): move() { logStream.println("about to move"); } }

31

Vantangens x Desvantagens

Vantagens da AOP:Vantagens da AOP: Boa Modularidade. Separação de Requisitos Funcionais e

Não-Funcionais no Código. Evita espalhamento de código e

efeitos colaterais em Manutenções. Suporte tecnológico. etc.

32

Vantangens x Desvantagens

Desvantagens da AOP:Desvantagens da AOP: A Composição de Aspectos não é um problema

simples. Aprendizado de uma nova tecnologia. Necessidade de se tratar os Aspectos desde o

início do Ciclo de Vida. Impacto no processo de compilação. Impacto nos processos de testes e depuração

da aplicação. Onde está o erro??? Manutenção e Evolução da Aplicação envolverá

a manutenção e evolução dos Aspectos.

33

Referências

AspectJ - http://www.aspectj.org HyperJ - http://www.alphaworks.ibm.com/tech/hyperj DJ – http://www.ccs.neu.edu/research/demeter/DJ/ Composition Filters –

http://trese.cs.utwente.nl/composition_filters/

34

QUESTÕES DE PESQUISA

AOP x Triggers and Stored Procedures x ….. to represent Business Rules. X Other approaches to represent crosscutting concerns.

How is testing and debugging the application with Aspects? How it evolves?