Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila AspectJ 1 5 4 Diego Pacheco PDF
Apostila AspectJ 1 5 4 Diego Pacheco PDF
Diego Pacheco
Dezembro/2007
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Sumrio
1. Conceitos Bsicos sobre AOP ........................ Error! Bookmark not defined.-1
Objetivos .................................................................................................................................... 0
Conceitos Bsicos .................................................................................................................. 0
Concerns VS Crosscuting Concerns ............................................................................ 0
Aspectos .................................................................................................................................... 0
Pilares do AspectJ ............................................................................................................... 0
Mecanismos de Weaving ................................................................................................... 0
Exerccios ............................................................................................................................... 0
2. Join Points e Pointcuts ....................................... Error! Bookmark not defined.
Objetivos .................................................................................................................................... 0
Pointcuts................................................................................................................................... 0
Suporte ao Java 5 ................................................................................................................ 0
Anotaes para Pointcuts ................................................................................................ 0
Join point Match com anotaes ................................................................................. 0
Recursos Avanados em Pointcuts .............................................................................. 0
Declarao de erros e warnings ................................................................................... 0
Injeo de anotaes............................................................................................................ 0
Exerccios ................................................................................................................................. 0
3. Advice........................................................................... Error! Bookmark not defined.
Objetivos .................................................................................................................................... 0
Tipos de Advices ................................................................................................................... 0
ThisJoinPoint........................................................................................................................ 0
Aspects........................................................................................................................................ 0
inner-type declarations ................................................................................................... 0
Exercicos ................................................................................................................................. 0
4. Recursos Adicionais.............................................. Error! Bookmark not defined.
Objetivos .................................................................................................................................... 0
AspectJ com Anotaes ...................................................................................................... 0
Declare Soft ............................................................................................................................. 0
DBC ............................................................................................................................................. 0
Exerccios ................................................................................................................................. 0
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Objetivos
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Conceitos Bsicos
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Pilares do AspectJ
O AspectJ possui classes como na linguagem Java, porm com mais recursos
ao desenvolvedor, essas classes so chamados de Aspects. Os aspectos tem entidades
especiais que no existem nas classes Java comuns, so elas:
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Aspects
Aspects so os artefatos do AspectJ para criao dos componentes de natureza
crosscuting, como se fosse uma classe Java porm, para necessidades globais.
Aspectos tem a seguinte estrutura bsica:
package <<Nome do pacote se existir>>;
import <<Import java/AspectJ se existir>>;
public aspect <<Nome do aspecto padro java >> {
// Pointcuts
// Advices
}
dos
advices
possvel
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
executar
qualquer
cdigo
Java.
Mecanismos de Weaving
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Load Time:
Vantagens:
Desvantagens:
Mais lento
Compile time
Vantagens:
Desvantagens:
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Exerccios
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
2. Pointcuts
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Objetivos
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Pointcuts
Chamada de mtodo
Execuo de mtodo
Chamada de construtor
Execuo de construtor
Pre-inicializao
Inicializao
Inicializao esttica
Handler
Exemplo:
package br.com.targettrust.aop.pointcuts;
public aspect PointcutSample {
pointcut nomePointcut(): call (void metodoX());
}
package br.com.targettrust.aop.pointcuts;
public aspect PointcutLogicalOperators {
pointcut operadorAnd(): call ( String
br.com.targettrust.aop.java.domain.model.Pessoa.getNome() )
&&
call ( String
br.com.targettrust.aop.java.domain.model.PessoaFisica.getNome() );
pointcut operadorOr(): call ( String
br.com.targettrust.aop.java.domain.model.Pessoa.getNome() )
||
call ( String
br.com.targettrust.aop.java.domain.model.Pessoa.getEndereco() );
pointcut operadorNot(): call ( ! String
br.com.targettrust.aop.java.domain.model.Pessoa.getNome() );
}
Para os 11 joinpoints, os pointcuts equivalentes so: call, execution, get, set, preinicialization,
inicialization, staticinicialization, handler e adviceexecution.
A figura abaixo resume o contexto de cada um destes pointcuts de forma geral.
Call VS Execution
Para capturar a execuo de um mtodo podemos utilizar tanto o operador call como o
operador execution. Porm existem algumas diferenas dos mesmos.
Quando utilizamos o operador call com o operador withincode o funcionamento
diferenciado, considerando a expresso pointcut: call(void metodo()) && withincode(void
metodo()). Esse pointcut s ser atingido se o mtodo estiver fazendo chamas recursivas.
O operador execution j considera que o programa est em execuo ento a expresso:
execution(void metodo()) equivale a call(void metodo()) && withincode(void metodo()).
Outro aspecto importante que o call no captura chamadas de procedncias superiores para
mtodos no estticos, ou seja, somente para mtodos da prpria classe e os mtodos que
estejam em uma classe pai, porm, que sejam estaticos.
A regra geral : se voc deseja capturar algum trecho de cdigo em particular para realizar
algum tracing por exemplo, utilize execution. Mas se voc deseja capturar um mtodo com
uma assinatura particular que normalmente utilizado em aspectos que vo para produo,
utilize call.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
A verso 1.5.X do AspectJ prove suporte completo aos recursos do Java 5.0 como:
varargs, anotaes, retorno co-variante, enumerations, generics e autoboxing.
O AspectJ prove um set muito rico de recursos para anotaes que sero bem detalhadas na
sequncia. Os recursos de auto-boxing so transparentes para o AspectJ, ou seja, no h
diferenas em join points, pointcuts ou advices entre primitivos e wrappers.
Exemplo:
as
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
mesmas
limitaes.
reteno
permitir,
AnnotatedElement
para
isso
utilizamos
reflection,
existe
atravs
dos
mtodos:
getAnnotation(),
uma
interface
getAnnotations(),
isAnnotationPresent().
Por padro annotations no so herdadas no mecanismo padro de herana do Java.
Mas possvel fazer herana utilizando a annotao @Inherited.
O AspectJ Prove anotaes bem como alternativa a sua syntax de aspectos, existe um
conunto de annotation para a utilizao do AspectJ .
No Java 5.0 quando usamos alguma Collection no tipada o compilador emite um
warning, podemos eliminar esse warning com uma annotation, isso existe no AspectJ
tambm, pois possvel que o compilador AspectJ no consiga estabelecer nenhum
join point para seu pointcut ento, para evitar warnings podemos utilizar a annotation
@SuppressAjWarnings.
No AspectJ Podemos colocar anotaes em: aspectos, mtodos, atributos, construtores,
advice, iner-type declaration com aspectos. No podemos utilizar annotation em
declaraes de pointcus.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Expresso
Exemplo de uso
(@Executavel * *)
(!@Executavel * *)
(@Executavel @Runnable * * )
( @(Executavel || Runnable) * *)
annotation @Runnable
@(br.targettrust..*)
Expresso
Exemplo de uso
@Criavel new(..)
Qualquer
construtor
que
tenha
annotation @Criavel
!@Criavel new(..)
annotation @Criavel.
Tbela 2.1 Exemplos com anotaes e operadores lgicos para construtores
Poderamos ainda utilizar mais operadores lgicos como || ou &&, ainda seria possvel
elaborar expresses mais complexas, quando fazemos um pointcut para construtor
utilizamos a propriedade initialization, mas podemos usar outras propriedades juntas a
esta.
Para fazer as expresses sobre atributos, usamos o padro Java Bean e os mtodos
getters/setters. Veja abaixo um exemplo de como utilizar esse recurso com annotations.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
possivel gerar warnings e at mesmo erros com aspectos, isso se torna muito
interessante por exemplo para evitar que desenvolvedores acessem mtodos
@Deprecated. Esse recurso pode ser utilizado para o reforo de contratos e at mesmo
para evitar o acoplamentos de cdigo.
Quando usamos warnigs o mecanismo do AspectJ no impede a compilao, ou
seja, o mecanismo de weaver acontece sem problemas, porm quando declaramos
erros como se existissem erros sintticos no cdigo e ele no compilasse, logo isso
impossibilitaria a execuo do programa.
Veja no cdigo a baixo exemplos de como utilizar os recursos do AspectJ para
declarao de erros e warnings, neste mecanismo no necessrio ter um advice
relacionado ao pointcut, este um caso especial em que o pointcut fica sem um advice
explcito.
package br.com.targettrust.aop.pointcuts.annotation.erroswarnings;
public aspect JoinPointMacthWithAnnotationErrosWarnings {
declare warning :
within(br.com.targettrust.aop.pointcuts.annotation.erroswarnings.java.*)
&& call(* faz*(..))
: "Voc no deve chamar metodos com o prefixo faz*";
declare error
:
within(br.com.targettrust.aop.pointcuts.annotation.erroswarnings.java.*)
&& call(* deleteAll*(..))
: "Voc no deve deletar tudo tche!!!";
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Injeo de Annotaes
Classes
Mtodos
Construtores
Atributos
: @Campo;
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Exerccios
1) Faa um aspecto que intercepte toda criao de objetos que o construtor receba
uma String.
2) Faa um aspecto que intercepte toda execuo de mtodos que recebam um Map
como argumento.
3) Faa um aspecto que declare erros se o desenvolvedor instanciar algum objeto do
tipo ArrayList.
4) Faa um aspecto que injete annotations em objetos de pacotes dao.
5) Faa um aspecto que intercepte todas os getters que tenha a anotao @Serializavel
no target.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
3. Advice
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Objetivos
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Advices
Before
Around
After
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Tipos de Advices
Before: Esse tipo de advice executado antes da execuo do pointcut. Supondo que
voc declarou um pointcut que pega todas as execues mtodos que retornem um
double, com o advice before voc tem o controle antes da execuo do mtodo. Esse
advice permite modificar os parmetros do mtodo, ideal para fazer todo o tipo de
inicializao. Outra boa aplicao para este advice para validaes, podemos fazer
validaes antes da execuo de determinados mtodos.
Veja abaixo exemplos de uso do advice before em aspectos com AspectJ.
public aspect BeforeSimple {
before():
call(* *.*save(Object)) {
System.out.println("Simples execucao antes do metodo.");
}
}
O Advice acima captura todas as execues do mtodo save que recebe um Object
como parmetro. Foi utilizado pointcuts em linha por questes de facilidades. Esse
advice s imprime uma mensagem na tela.
Seria possvel fazer validaes neste advice e com isso poupar tempo dos
desenvolvedores e garantir que todos os acessos ao banco sejam menos custosos. Para
exemplificar isso o advice acima foi alterado, veja o resultado na figura abaixo.
before(Object x):
call(* *.*save(Object)) &&
args(x)
{
if (x==null)
throw new RuntimeException("No pode salvar um objeto nulo!");
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
After: Este tipo de advice executado depois da execuo do pointcut. Supondo que
voc declarou um pointcut que pega todas as execues mtodos que retornem um
double, com o advice after voc tem o controle posterior execuo do mtodo.
Esse tipo de advice permite modificar o retorno de um mtodo. til para aplicar filtros
e adicionar informaes a grafos de objetos. Este tipo de recurso pode ser utilizado
para realizaes de bind dos mais diversos tipos, como por exemplos de-paras.
Veja abaixo exemplos de uso do advice before em aspectos com AspectJ.
public aspect AfterSimple {
after():
call(* *.*save(Object)){
System.out.println("Simples execucao depois do metodo.");
}
}
Outra forma de usar o advice after com o retituring que permite capturar o retorno
da execuo de algum pointcut. Esse recurso pode ser usado de forma opcional. No
exemplo abaixo mostra como utilizar o recurso.
after()
returning(Object o):
call(public Object *.*.find()){
String x = (String)o;
x += "123";
System.out.println("retorno: " + x);
}
Este advice pega o retorno do mtodo find, sendo que esse mtodo retorna um objeto.
No advice foi feito um cast para String e adicionado o sufixo 123 na String original e
depois impresso na tela.
O Advice after ainda possui o recurso de throwing que serve para capturarmos aps o
levantamento de Exception. Veja abaixo um exemplo de uso desse recurso.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
O Advice do tipo after ainda possui mais uma forma, a throwing, com isso podemos
realizar operaes aps um mtodo levantar uma determinada exception por exemplo.
Esse recurso faz com que o advice seja executado apenas se a Exception corretamente
definida na expresso pointcut for lanada. Veja a baixo um exemplo prtico de como
usar o after throwing.
after()
throwing(Exception e):
call(public void *.*.delete()) {
System.out.println("Erro! Mensagem: " + e.getMessage());
}
informar
uma
exception
especfica,
como
por
exemplo
FileNotFoundException.
Este recurso muito bom para aplicar logs e todo o tipo de controles ps erro. Outra
aplicao seria na tolerncia a falha, em um sistema assncrono poderamos disparar
um segundo processo caso determinado erro ocorra.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Around: Com certeza este o tipo de advice mais poderoso e mais utilizado. Com esse
advice podemos interferir na execuo do mtodo de forma que possamos:
Impedir a execuo
Modificar os parmetros
Modificar o retorno
Levantar um Exception
Engolir um Exception
Esse advice abre uma imensa gama de possibilidades. Quando utilizamos around
necessrio especificar uma sintaxe um pouco diferente dos outros advices, dentre as
diferenas existe o proceed(). Este mtodo faz com que a execuo do mtodo
prossiga. Para o mesmo ocorrer necessrio informar os parmetros do mtodo,
podemos repassar os parmetros originais, novos ou modificados.
int around():
call(public int *.*.soma(int,int)){
System.out.println("Around advice modificando valores constante 1");
return 1;
}
Veja no exemplo
Neste exemplo foi utilizado o recurso args para recuperar os argumentos do mtodo
soma2 e esse argumentos x,y foram referenciados dentro do advice around.
No final executado o proceed que executa o mtodo real com os parmetros.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
ThisJoinPoint
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Descrio
getArgs()
getSignature()
getSourceLocation()
getClass()
getKind()
getTarget()
getStaticPart()
getThis()
Quando estamos em um advice do tipo after ou before e existe uma expresso call(),
possvel acessar informaes do joint point passado quando ele existe, para isso
usamos a varivel thisEnclosingJoinPointStaticPart.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Aspects
Aspectos no so instanciados
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
package br.com.targettrust.aop.aspect.java;
class A{
public void func(){}
}
class B{
public void func(){}
}
public class SingletonTeste {
public static void main(String[] args) {
A a = new A();
B b = new B();
a.func();
b.func();
}
}
Supondo que temos as trs classes acima, a classe A e B com o mtodo func() e uma
classe main com a instanciao e invocao dos mtodos func() de A e B. Agora se
quisssemos contrar quantas vezes o mtodo func() foi chamado. poderamos fazer um
aspecto conforme este abaixo:
package br.com.targettrust.aop.aspect;
public abstract aspect PaiBurro {
protected String nome = "Aspecto Contador";
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
far
com
que
AspectJ
levante
um
exception:
org.aspectj.lang.NoAspectBoundException.
Por default aspectos tem as mesmas regras de acesso e privilgios que o Java tem, mas
podemos modificar essas polticas tornando o aspecto privilegiado. Quando um
aspecto privilegiado, o mesmo pode acessar variveis protected e at mesmo
variveis private. Porm esses recursos s so vlidos para innertype declarations feitas
pelo mesmo aspecto ou por outros.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Inner-Type Declarations
Recurso do AspectJ que permite adicionar membros nas classes de forma dinmica.
Com este recuroso podemos adicionar atributos a um classe Java e utilizar essa
informao para algum processamento em algum advice de um aspecto.
No difcil adicionar mtodos a classes Java com os recursos de inner-type
declarations do AspectJ, podemos inclusive fazer com que determinada classe
implemente um set de interfaces.
Como mencionado anteriormente, possivel modificar at mesmo as regras de acesso
do Java, assim um aspecto privilegiado pode acessar mtodos proteced e at mesmo
private.
Para adicionar uma classe ou interface na hierarquia de uma classe em um aspecto
podemos usar o recurso declare parents.
O cdigo abaixo mostra como adicionar a Classe br.com.A como classe pai da classe
br.com.B.
declare parents: br.com.B extends br.com.A;
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
No exemplo acima est sendo adicionda uma List<Porta> no objeto casa. Perceba que
o atributo est sendo adicionado de forma privada, isso significa que no poder ser
acessada de fora da classe a no ser que o aspecto seja privilegiado.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Para adicionar mtodos a uma classe ( Isso necessrio quando implementamos uma
interface via aspectos) podemos fazer conforme o exemplo abaixo.
public void Casa.pintar(Cor c){
System.out.println("Pintando a casa de cor:" + c);
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Exerccios
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
4. Recursos Adicionais
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Objetivos
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
recursos
de
anotaes
disponveis
no
AspectJ
1.5.X
esto
no
pacote
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
atributo
throwing.
Com o advice do tipo @Around existe o problema do proceed() que no pode ser
chamado no meio do cdigo Java, se no voc ter um erro de compilao, para
manter um bom design e a compatibilidade de compilao do mecanismo de
annotaes
do
Inner-type declarations
int
int
int
int
soma(int a,int b)
sub(int a,int b)
multi(int a,int b)
div(int a,int b)
{
{
{
{
return
return
return
return
a+b;
a-b;
a*b;
a/b;
}
}
}
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
package br.com.targettrust.aop.annotation.innertype;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
@Aspect
public class AnnotationInnerTypeAspect {
@DeclareParents(
value="br.com.targettrust.aop.annotation.innertype.clazz.*",
defaultImpl=PotenciaImpl.class)
public Potencia implementadores;
}
Aspecto
cima
faz
grande
jogada.
Atravs
da
anotao
declarar
um
warning
basta
utilizar
anotao
determinar quais classes ficaram com erros. Claro que tambm necessrio um String
do tipo final para ser a mensagem de erro.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Declare Soft
Esse recurso foi introduzido apartir do AspectJ 1.5.X. um recurso muito importante
com ele podemos fazer com que as Exceptions do Java sejam encapsuladas em uma
Exception do
RuntimeException. Se a exceo que for utilizada para o soft for uma Exception que
estende RuntimeException voc receber um warning e o soft no ir ocorrer.
A Exception do AspectJ que vai ser a encapsuladora de sua exeo ser a
org.aspectj.lang.SoftException. Esse recurso til para tratar os erros provocados
porventura por aspectos.
Veja como utilizar o recurso no exemplo abaixo:
package br.com.targettrust.aop.declaresoft;
public class MinhaExcpetionChata extends Exception {
private static final long serialVersionUID = 1L;
public MinhaExcpetionChata(String msg) {
super(msg);
}
public MinhaExcpetionChata(String msg,Throwable rootCause) {
super(msg,rootCause);
}
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
package br.com.targettrust.aop.declaresoft.java;
import org.aspectj.lang.SoftException;
import br.com.targettrust.aop.declaresoft.MinhaExcpetionChata;
public class DeclareSoftTest {
public void fazAlgo() throws Exception {
throw new MinhaExcpetionChata("Exception chata mesmo");
}
public static void main(String[] args) {
try {
DeclareSoftTest dst = new DeclareSoftTest();
dst.fazAlgo();
} catch (SoftException se) {
System.out.println(" 1 - SoftExcetion: " +
se.getWrappedThrowable());
} catch (Exception e) {
System.out.println(" 2 - Exception: " + e);
}
}
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Pela implementao da classe Java podemos ver que no foi implementado nenhum
tipo de validao para atender o contrato DBC que foi estipulado previamente.
Provavelmente se esta classe fosse executada do jeito que ela se encontra, teramos
srios problemas. Agora vamos ver o aspecto que ter a implementao DBC.
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
package br.com.targettrust.aop.dbc;
import java.math.BigDecimal;
public aspect DBCAspect {
private
pointcut debitarPointcut(BigDecimal b):
execution(public BigDecimal *.debitar(BigDecimal)) &&
args(b) &&
within(br.com.targettrust.aop.dbc.*);
before(BigDecimal b): debitarPointcut(b){
if (b.doubleValue()<1)
throw new
RuntimeException("O Metodo ContaCorrente.debitar(BigDecimal) "
+ " no pode receber um valor menor que 1! Valor: " +
b.doubleValue());
}
before(BigDecimal b): debitarPointcut(b){
if (b.doubleValue()>1000.0)
throw new
RuntimeException("O Metodo ContaCorrente.debitar(BigDecimal) "
+ "no pode receber um valor maior que 1.000! Valor: " +
b.doubleValue());
}
after(ContaCorrente cc):
execution(public BigDecimal *.debitar(BigDecimal)) &&
target(cc) &&
within(br.com.targettrust.aop.dbc.*)
{
BigDecimal saldo = cc.consultaSaldo();
if (cc.consultaSaldo().doubleValue()<=0){
cc.creditar(new BigDecimal(5d).subtract(saldo));
throw new
RuntimeException("Erro a contacorrente no pode ter saldo"
+"negativo! Valor: " + saldo.doubleValue());
}
if (cc.consultaSaldo().doubleValue()<=4){
cc.creditar(new BigDecimal(5d).subtract(saldo));
throw new
RuntimeException("Erro a contacorrente no pode ter saldo"
+ "menor que 5 reais! Valor: " + saldo.doubleValue());
}
}
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Exerccios
1) Faa um aspecto utilizando anotaes que faa tracing. Este aspecto deve
mostrar todos os parmetros do mtodo e o seu retorno tambm. Chame o
mtodo execute (String proc, Object inst) vrias vezes em uma classe de testes.
2) Declare um erro utilizando anotaes para quando for utilizando a classe
java.util.HashMap() em uma classe TesteMapEx02 com os mtodos usaMap() e
testaMap().
3) Baseado no exercicio anterior, faa o mesmo, s que agora gere um warning,
utilizando anotaes tambm.
4) Utilizando os conceitos de DBC faa um aspecto que valide as seguintes
premissas:
1 Pr condies:
1. O hotel no aceita hospedes de cabelo verde.
2. O hotel no aceita chekin antes das 10:00hs.
2 Ps condies:
1. Ao sair do hotel deve-se pagar a conta.
2. Ao sair do hotel deve-se deixar 20% de gorjeta.
3 Invariantes:
1. Para alugar o quarto a pessoa deve ter, no mnimo R$
500,00.
Para esse execcio implemente a interface Hotel que segue:
Package br.com.targettrust.aop.advice.after.java;
import java.math.BigDecimal;
public interface Hotel {
public void checkIn(String corCabelo,
int horaEntrada,
BigDecimal dinheiroQueVoceTem);
public BigDecimal getTotalConta();
public void checkOut(BigDecimal vindeDaPropina);
}
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
HTTP://DIEGO-PACHECO.BLOGSPOT.COM