AspectJ: differenze tra le versioni

Versione delle 00:44, 19 lug 2008

Versione delle 00:47, 19 lug 2008

Riga 1:

{{W}}

'''AspectJ''' è un linguaggio basato su javaJava per aggiungere a javaJava stesso i cosiddetti aspetti. È uno dei modi utilizzati, in ambito javaJava, per avvalersi dell' Aspect Oriented Programming ([[Programmazione orientata agli aspetti]]).

==Concetti base==

===Join point e pointcutspointcut===

Un concetto basilare di '''AspectJ''' è quello di join point. Un join point può essere intuitivamente definito come un certo istante nell' esecuzione del programma; ogni chiamata a un qualsiasi metodo di un oggetto qualunque potrebbe essere un join point, così come leggere il valore di una variabile , creare un oggetto o modificare il valore di una variabile.

I pointcutspointcut invece descrivono le situazioni particolari che si vengono a creare durante l' esecuzione del programma. Un pointcut è cioè una sorta di [[variabile booleana]] il cui valore dipende da una certo insieme di join point, che in un dato momento dell' esecuzione del programma possono essere ''veri'' o ''falsi''.

È possibile definire un pointcut in maniera estremamente dettagliata; si può ad esempio definire un pointcut che sia valido quando un qualsiasi metodo della [[Classe (informatica)|classe]] A viene chiamato, o ancora, definire un pointcut che è valido quando un metodo di un oggetto di classe A chiama il [[metodo]] xyz(int a ,int b) di un oggetto di classe B, oppure un pointcut che sia valido quando viene eseguito il metodo B.exec(String s) tranne nel caso in cui il suddetto metodo venga chiamato da un membro della classe F. È anche possibile definire un pointcut che sia valido quando uno qualunque di un certo insieme di metodi specificato dal programmatore viene chiamato.

Un pointcut può contenere informazioni sui join point che lo compongono, quali ad esempio gli argomenti del metodo chiamato (se il pointcut contiene un join point definito dalla chiamata di un metodo) o lo specifico oggetto cui era diretta la chiamata (sempre che il pointcut contenga un join point consistente nella chiamata di un metodo di un oggetto). Facendo riferimento alla metafora precedente, i pointcutspointcut definiscono quando gli spettatori salgono sul palcoscenico , ossia il momento in cui gli aspetti modificano il normale flusso del programma .

===Advices===

Gli advicesadvice sono degli insiemi di istruzioni che vengono eseguite

quando un certo pointcut diventa valido . è importante notare che un advice può contenere esso stesso la definizione del pointcut che lo attiva. Un advice nella sua esecuzione può accedere ad eventuali

informazioni sui join point che lo compongono che il pointcut può

fornirgli . Sempre con riferimento alla metafora del teatro , gli advicesadvice definiscono cosa fanno gli spettatori sul palcoscenico.

===Aspect===

Le unità elementari dell' OOP sono gli oggetti , raggruppati in

classi ; le unità fondamentali dell' AOP sono gli aspetti . Un aspetto normalmente contiene uno o più pointcutspointcut e uno o più advicesadvice , oltre a metodi e attributi , come le normali classi . Un aspetto modella una certa 'problematica trasversale' (cioè comune a più oggetti) del problema da risolvere ; per esempio , poniamo di dover effettuare uno stesso controllo sui valori di input su più metodi appartenenti a classi differenti. Supponendo che tali oggetti non siano legati tra loro da relazioni di ereditarietà , nell' OOP si dovrebbe implementare tale controllo in ogni classe ;nell'AOP è invece sufficiente implementare un unico aspetto che abbia un pointcut definito come un OR logico tra un insieme di join point che corrispondono all' esecuzione dei metodi che ci interessano , che contenga al suo interno un advice che restituisca un errore se gli argomenti del metodo eccedono i valori prefissati .

===AspectJ in dettaglio===

Riga 80 ⟶ 81:

call(void A.*(..))

Questa espressione indica l'insieme dei join point generati dalla chiamata di un qualsiasi metodo void appartenente alla classe A .

====''PointcutsPointcut''====

Un pointcut è un join point ,oppure una intersezione o una unione tra join point , o piu? informalmente , una certa situazione che si viene a creare durante l?esecuzione del programma . Un pointcut nella sua definizione comprende uno o piu? join point : un semplice esempio di pointcut definito a partire da un unico join point è il seguente :

Riga 88 ⟶ 89:

pointcut pc() : call(void doSomething(int))

I pointcut possono inoltre rendere accessibili al codice presente negli advicesadvice che vi fanno riferimento alcuni dati presi dai join point che fanno parte della loro definizione : per esempio ,

pointcut pc(int i): call (void doSomething(int)) && args(i)

Riga 94 ⟶ 95:

mette a disposizione dell'advice una variabile int i che sarà inizializzata al valore del parametro intero passato al metodo

void doSomething(int n) . Vale la pena notare che il pointcut definito qui sopra è formalmente una intersezione ,ossia un and logico tra due insiemi di join point definiti dalle due espressioni call (void doSomething(int)) e args( int i) : quest' ultima espressione indica tutti

i join point che accettano come input un unico parametro di tipo int . Facendo riferimento a pointcutspointcut che nelle loro definizioni hanno , tra gli altri , anche dei join point di tipo call , è possibile che essi indichino all' advice l'oggetto che effettua la chiamata e quello che la riceve . Prendiamo ad esempio il pointcut wait , così definito :

pointcut wait(A1 ac, B2 bd) : call(void wait()) && this(ac) && target(bd)

Riga 129 ⟶ 130:

pointcut restart() : cflowbelow(execution(void wait()))) && call(void resume(int)) ;

In questo caso , dall' insieme dei join point generati da void wait() vengono selezionati solo quelli generati da void resume() ; in pratica ,questo pointcut diventerà valido solo quando void resume() verrà chiamato dall'interno del metodo void wait() oppure verra' chiamato dall' interno di un altro join point che è stato generato , direttamente o indirettamente , dall' esecuzione di void wait() . Altre due parole chiave usate di frequente nella definizione dei pointcutspointcut sono within e withincode .

Con within(nomeClasse) si indica l'insieme dei join point corrispondenti all' esecuzione di codice che sia , a livello di sorgenti , parte della classe nomeClasse . Ad esempio:

Riga 141 ⟶ 142:

====Advices====

Gli advicesadvice sono degli insiemi di istruzioni che vengono eseguiti prima ,dopo oppure al posto di alcuni pointcut. In questo testo vengono trattati i primi due casi , visto che la semantica del terzo (advice di tipo 'around' ) è ancora in corso di definizione . Gli advice che vengono eseguiti prima che un pointcut diventi valido sono definiti dalla parola chiave before : prendiamo ad esempio il seguente codice :

Riga 205 ⟶ 206:

====Aspetti====

Un aspetto modella una problematica trasversale dell' applicazione. Può contenere al suo interno definizioni di pointcut, advicesadvice, attributi e metodi,implementare un'interfaccia od estendere una classe; il viceversa ovviamente non vale.

Esistono aspetti astratti e aspetti concreti, esattamente così come esistono classi astratte e classi concrete; però, a differenza dell'OOP, nell'AOP un aspetto concreto non può estendere un altro aspetto concreto, ma solo un aspetto astratto.

Un esempio è il seguente :

Riga 264 ⟶ 265:

alla riga 2 c'è la dichiazione dell'aspetto. Gli aspetti possono essere privati o pubblici, esattamente come le classi, ma possono anche essere privilegiati ('privileged') oppure no: un normale aspetto rispetta il principio dell'information hiding, mentre uno privilegiato no. In parole povere, solo gli aspetti dichiarati come 'privileged' hanno la visibilità degli attributi e dei metodi privati di una classe, e di conseguenza solo gli aspetti privilegiati possono contenere al loro interno dei pointcutspointcut che nella loro definizione facciano riferimento a join point corrispondenti, per esempio, al get o al set di un attributo privato dell' oggetto o all'esecuzione di un metodo privato. L'aspetto in esame alla riga 2 viene dichiarato come un aspetto pubblico privilegiato.

Un aspetto, esattamente come qualsiasi altro oggetto, può avere uno o più costruttori:

Riga 316 ⟶ 317:

aggiunge un attributo di tipo intero e di nome 'timè alla classe Game , mentre

private String Ship.name ;

aggiunge un attributo di tipo stringa 'namè alla classe Ship .è importante notare che questo attributo è stato dichiarato come privato dall' aspetto, e quindi questo attributo sarà visibile solo dai metodi e dagli advicesadvice dell' aspetto, ma non dai metodi della classe Ship.

Public int Game.score () {