PM 17/10

// notasdogarcia.blog.com

// Revisão
// A prova é na segunda dia 24, a aula de quarta dia 19 é para exclarecimento de dúvidas.

CONCEITO Revisão:
  pointcut são os pontos que se deseja acessar no código.

CONCEITO Revisão:
  advices são os códigos que desejamos executar ao atingir os point cuts.

CONCEITO Revisão:
  Tipos de advices:
  - before -> executa antes do pointcut
  - after  -> executa depois do pointcut
  - around -> substitui a chamada do pointcut pela chamada do advice.(normalmente voce vai adicionar essa chamada ao advice para não se perder o significado do código)

CONCEITO Revisão:
  proceed(); é uma função que é usada dentro de um advice do tipo around para chamar a função do pointcut.
  Assim voce pode usar o around e dentro dele chamar a função original.

CONCEITO Revisão:
  Tipos de advice2:
  - call, nesse caso o código do advice é inserido na função mãe do pointcut, ou seja, no ponto onde a função é chamada.
  - execution, nesse caso o advice é inserido dentro da própria função detectada como pointcut.

  A principal diferença entre o call e o execution é que o escopo de cada um é diferente.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Cruzando os dois tipos de advices e explicando o funcionamento de cada um:

  call before: O advice é inserido antes da chamada da função no código da função mãe do pointcut.
  call after:  O advice é inserido depois da chamada da função no código da função mãe do pointcut.
  call around: O advice substitui a função, e para isso deve-se usar proceed() para chama-la novamente permitindo que voce distribua o código ao redor do proceed.

  execution before: O advice é inserido bem ao inicio do código da função do pointcut.
  execution after: O advice é inserido imediatamente antes do return da função do pointcut.
  execution around: O advice substitui todo o código da função.

  Exemplo de chamada de uma função de um pointcut, e dos pontos onde cada tipo de advice entraria:
  No exemplo abaixo b() é a função do pointcut e a() é a função que chama b, ou seja a função mãe.

  A.a()
  {
    ...
    // call before
    B.b(); // call around (substituindo a chamada)
    // call after
    ...
  }

  B.b()
  {
    // execution before
    ... // execution around (subtituindo o código)
    // execution after
  }

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

public aspect Nome
{
    pointcut NomePoint1(): expressão regular;

    pointcut NomePoint2(): expressão regular;

    pointcut NomePoint3(): expressão regular;

    ...

    call before(int n): nome(parametros){
      código java normal
    }

    long around(int n) : factoriaOperation(n){
      código java normal. esse é o advice.
    }

    after(int n): nome(parametros){
      código java normal
    }
}

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

CONCEITO:
  Dois tipos especiais de exp. regular para pointcuts:

  Como acessar os campos de uma classe em um pointcut? (ou seja como colocar um pointcut para funcionar durante a alteração ou leitura de uma variável de uma classe?)
  Para isso usa-se:
    set(campoDaClasse);
    get(campoDaClasse);

Exemplo:

  pointcut alteraX(): set(int Point.x);

  Assim sempre que houver uma alteração do valor do struct Point.x um advice será chamado.

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

CONCEITO Revisão:
  target(f) é usado nas ER dos pointcuts, essa "função" irá coletar o objeto que chamou a função do pointcut, ou seja o "this" dessa função.

CONCEITO Revisão:
  args(a,b,c) também usado nas ER dos pointcuts coleta os parâmetros da função detectada pelo pointcut, se a função possuir mais de 3 parâmetros,
  os 3 primeiros são associados a a,b e c.

CONCEITO Revisão:
  this(t) é usado também nas ERs e tem o mesmo significado que o target() em advices do tipo execute.
  porém em advices do tipo call, é diferente, ela básicamente guarda em t, o valor do ponteiro "this" chamado no mesmo escopo do de inserção do pointcut.

  Assim, se eu chamo this na função a() (do exemplo acima) eu receberei como retorno o struct A.
  E se faço isso na função b() recebo como retorno o struct B.

  Exemplo de uso:

    pointcut nomePoint1(f,a,b,c,t): expRegular && target(f) && args(a,b,c) && this(t);

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

  Agora suponha a função:

  a.x()
  {
    return g.y();
  }

Suponha que eu queira saber o valor de a e de g? se eu usar um pointcut do tipo call, eu posso usar o this para receber o valor de a e o target para o valor de g.

Se voce chamar o this para um pointcut do tipo execution o seu valor na verdade será igual ao do target. portanto só faz sentido fazer isso para calls.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

// ( weaver é o nome do "compilador" dos aspectos )

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Um aspecto pode possuir atributos, ou seja declarar objetos:

  private Map _factorialCache = new HashMap();

  Essa declaração deve ser feita entre os pointcuts e os advices, já que será usada dentro dos códigos dos advices.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Outra função especial para se usar nas ERs dos pointcuts:

  cflowbelow(exp regular) detecta se na pilha de execução há uma chamada a essa função, isso é usado no pointcut.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

CONCEITOs Revisão:
  Transversalidade dinâmica:
    Isso é quando voce modifica o fluxo de execução de um programa.
    (é isso que temos feito mudando as funções)

  Tranversalidade estática:
    É quando se redefine a estrutura estática do programa.
    Ou seja, voce pode mecher nas classes, adicionar implementações e extensões.
    // No caso parece que essas alterações só poderão ser usadas pelos advices de qualquer forma.

ex: de aspecto estatico:

aspect A
{
  declare parents: SomeClass implements Runnable;
  public void SomeClass.run(){ .... };
}

// Fim da aula.