Professora: Aline Vasconcelos apires@iff.edu.br Programaçã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

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.

Boa modularidade Código do Apache

Boa modularidade Código do Apache Parse XML

Boa modularidade Código do Apache Parse XML Busca de Padrões de URLs

Falta de modularidade Código do Apache Parse XML Busca de Padrões de URLs Log

Mais falta de modularidade Código do Apache Parse XML Busca de Padrões de URLs Log Segurança

O que temos aqui? Falta de Modularidade Código Espalhado If (user not authorized) { error (“Mensagem de erro 1”); } Falta de Modularidade Código Espalhado Código Redundante

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!!!

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

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.

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

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

Implementações Mais conhecidas: AspectJ Composition Filters Hyper/J DemeterJ Nem tanto, mas interessantes: Jmangler (outro)

Integração

AspectJ (http://eclipse.org/aspectj/) Uma extensão da linguagem Java para o tratamento de Aspectos. ajc: compilador e weaver de bytecode Java. Processo de weaving: ------- ------ ASPECTOS Application Jar File ------- ------ ----- WEAVING Aplicação + Aspectos

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.

AspectJ: Alguns Conceitos Exemplos de JoinPoints: Method Calls Method Executions Object Instantiations Constructor Executions Field References Handler Executions

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

AspectJ Uma aplicação Exemplo:

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));

AspectJ Uma aplicação Exemplo:

AspectJ: Exemplos de Pointcuts 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));

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())

AspectJ: Advices Before: é 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: é 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 Throwing, After.

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.

AspectJ: Advices Exemplos around(): move() { System.out.println("about to move"); proceed(); System.out.println(“object moved"); }

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.

AspectJ: Expondo Contexto em Pointcuts 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: SetXY(fe, x, y) { System.out.println(fe + " moved to (" + x + ", " + y + ")."); } ADVICE!

AspectJ: Programando Aspectos aspect Logging { private OutputStream logStream = System.err; 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() { logStream.println("about to move"); }

Vantangens x Desvantagens 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.

Vantangens x Desvantagens 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.

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/

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?