AspectJ: differenze tra le versioni

Versione delle 06:31, 21 ott 2018

Versione attuale delle 03:06, 28 lug 2025

(11 versioni intermedie di 10 utenti non mostrate)

Riga 1:

{{F|linguaggi di programmazione|aprile 2012}}

{{Linguaggio di programmazione

|autore = Eclipse Foundation

|data = 2001

|utilizzo = estensione per Java

|paradigmi = programmazione orientata agli aspetti

|tipizzazione = Statica

}}

'''AspectJ''' è un'estensione di [[Java (linguaggio di programmazione)|Java]] per aggiungere a Java stesso i cosiddetti ''aspetti''. AspectJ rappresenta lo strumento primario, in ambito Java, per avvalersi della [[programmazione orientata agli aspetti]].

== Storia ==

L'estensione AspectJ venne sviluppata a partire delladalla fine degli anni '90 presso il laboratorio [[Xerox Palo Alto Research Center|Xerox PARC]], dietro la guida di [[Gregor Kiczales]], co-autore nel 1996 del primo paper che descrive la programmazione orientata agli aspetti<ref>{{Cita pubblicazione|nome=G.|cognome=Kiczales|data=1996-12-01|titolo=Aspect-oriented programming|rivista=ACM Computing Surveys (CSUR)|volume=28|numero=4es|ppp=154|accesso=2018-10-21|doi=10.1145/242224.242420|url=httphttps://dl.acm.org/citation.cfm?id=242224.242420}}</ref>. La prima release pubblica dell'estensione risale al 2001<ref>{{Cita pubblicazione|nome=Gregor|cognome=Kiczales|data=2001-06-18|titolo=An Overview of AspectJ|editore=Springer-Verlag|pp=327–353327-353|accesso=2018-10-21|url=httphttps://dl.acm.org/citation.cfm?id=646158.680006|nome2=Erik|cognome2=Hilsdale|nome3=Jim|cognome3=Hugunin}}</ref>.

==Concetti base==

Riga 9 ⟶ 16:

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

I ''pointcut'' 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 unaun 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 (programmazione)|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 pointcut definiscono quando gli spettatori salgono sul palcoscenico, ossia il momento in cui gli aspetti modificano il normale flusso del programma.

===Advice===

Riga 21 ⟶ 28:

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ù pointcut e uno o più advice, 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 41 ⟶ 48:

indica l'esecuzione di un qualsiasi blocco catch(IOException e) { .. } che gestisce un'eccezione di tipo IOException.

get ( int A.numero )

set (byte B.valore )

Riga 58 ⟶ 65:

adviceexecution()

Ci sono anche altri tipi di join point in aspectj, ma visto che il linguaggio è ancora in evoluzione, qui ci si è limitati a descrivere solo quelli più frequentemente usati, che probabilmente saranno presenti anche nelle future versioni di aspectj, successive alla versione 1.1 cui l'autore fa riferimento.

In aspectj esistono inoltre delle espressioni che permettono di definire degli insiemi di join point;

l'espressione

Riga 143 ⟶ 150:

l'effetto di questo advice è di far stampare come messaggio a video, prima che il metodo termini, la parola '''arrivederci'''.

Un advice può definire esso stesso il pointcut da cui dipende; in altre parole, la seguente [[sintassi]] in aspectj è corretta:

after(): execution (void faQualcosa(..)) {System.out.println("arrivederci");

Riga 160 ⟶ 167:

}

Bisogna ricordare che in java un metodo può terminare regolarmente oppure lanciando un'eccezione: aspectj permette di distinguere questi due casi.

Si [[veda]] il seguente codice:

after() returning punto1() : { System.out.println("tutto regolare");

Riga 171 ⟶ 178:

}

quest'altro verrà eseguito solo se il metodo faiQualcosa ha lanciato un'eccezione.

Inoltre un advice del tipo after (..) returning può avere a disposizione il dato che il metodo contenuto nel poincut restituisce, ad esempio è possibile scrivere

after (int a) returning : call(int moltiplica(int,int)) {

// qui andrebbe il codice da eseguire ..

// che ha accesso alla variabile int a

// contenente il valore restituito da int moltiplica

}

Riga 187 ⟶ 194:

===Aspetti===

Un aspetto modella una problematica trasversale dell'applicazione. Può contenere al suo interno definizioni di pointcut, advice, 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:

<syntaxhighlight lang="java" line="1">

<pre>

1.import java.io.* ;

2.public privileged aspect Prestaz {
final byte[] acapo = {0x0a} ;

0x0a

3. File ris ;

};

4. RandomAccessFile fl ;

3. File ris ;

5. public Prestaz() { try { ris = new File("RisulTato.txt") ;

6. ris.delete()RandomAccessFile fl;

7. ris.createNewFilepublic Prestaz() ;{

try {

8. fl = new RandomAccessFile(ris,"rw") ;

5. public Prestaz() { try { ris = new File("RisulTato.txt") ;

ris.delete();

ris.createNewFile();

8. fl = new RandomAccessFile(ris, "rw") ;

9. } catch (IOException eccez) { }
}

10. private pointcut punto1(): execution(void main(..)) ;

11. private long start1 ;

12. private long stop1 ;

13. private pointcut punto2(): execution(void stampa(String)) ;

14. private long start2 ;

15. private long stop2 ;

16. before() : punto1() {
start1 = System.currentTimeMillis() ;

17. }

18. after() : punto1() {
stop1 = System.currentTimeMillis() ;

19. long temp = stop1 -start1 start1;

20. Long t = new Long(temp) ;

21. String data = t.toString() ;

22. String nome = "void main(..)" ;

23. try {
fl.write(nome.getBytes()) ;

24. String st = " : tempo di esecuzione (ms) : " ;

25. fl.write(st.getBytes()) ;

26. fl.write(data.getBytes()) ;

27. fl.write(acapo) ;

28. } catch (IOException eccez) { }
}

29. before() : punto2() {
start2 = System.currentTimeMillis() ;

30. }

31. after() : punto2() {
stop2 = System.currentTimeMillis() ;

32. long temp = stop2 -start2 start2;

33. Long t = new Long(temp) ;

34. String data = t.toString() ;

35. String nome = "void stampa(String)" ;

36. try {
fl.write(nome.getBytes()) ;

37. String st = " : tempo di esecuzione (ms) : " ;

38. fl.write(st.getBytes()) ;

39. fl.write(data.getBytes()) ;

40. fl.write(acapo) ;

41. } catch (IOException eccez) { }
}

}

42. }

</syntaxhighlight>

</pre>

alla riga 2 c'è la dichiarazione 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 pointcut 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.

Riga 286 ⟶ 307:

avrà l'effetto opposto.

===''Inter-Type declarations''===

In aspectj un aspetto può alterare la struttura stessa degli oggetti aggiungendo ad essi metodi, attributi e costruttori oltre a quelli che già possiede. Bisogna però fare attenzione a non creare conflitti: i metodi, i costruttori e gli attributi che un aspetto aggiunge ad un oggetto non devono sovrapporsi a metodi, costruttori e attributi che l'oggetto già ha. In parole povere, un aspetto può aggiungere dei metodi, degli attributi o dei costruttori, purché non siano già definiti dall'oggetto stesso.

La sintassi delle inter-type declarations è molto semplice: la dichiarazione

public int Game.time;

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

Riga 296 ⟶ 318:

aggiunge un attributo di tipo stringa name 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 advice dell'aspetto, ma non dai metodi della classe Ship.

public int Game.score () {

// codice che ritorna il punteggio del gioco...

}

Riga 306 ⟶ 328:

}

per far sì che Game abbia un costruttore che accetta come parametro ununa stringa.

== Note ==

<references/>

== Altri progetti ==

{{interprogetto}}

== Collegamenti esterni ==

*{{cita web|httphttps://www.eclipse.org/aspectj/|Home page progetto AspectJ}}

{{portale|informatica}}

[[Categoria:Linguaggi di programmazione]]