Programmazione AOP con AspectJ

JJ — n. 3 — marzo marzo-apri -aprile le 2007 2007

Programmazione AOP con AspectJ di Mattero Baccan ` passati ad anni di programmazione ad ogDopo anni di programmazione strutturata, si e getti. Ora si inizia a parlare di POP (Post (Post Object Programming Programming), ), e delle tecnologie tecnologie correla` appunto una di queste tecnologie. Vediamo te. AOP (Aspect Oriented Programming), e di cosa si tratta, tratta, con esempi esempi pratici pratici e l’utilizzo l’utilizzo di un compilatore gratuito gratuito come AspectJ. AspectJ.

Matteo Baccan

E` uno specialista di progettazione e sviluppo C++, C++ , JA JAV VA e AOP. E` ideatore del portale JobCrawler.it JobCrawler.it e speaker in importanti eventi Java (Javaday, JIP Day).

pubblicato su WWW.INFOMEDIA.IT 

stampa digitale da Lulu Enterprises Inc. stores.lulu.com / infomedia infomedia I

nfomedia Infomedia Infomedia e` l’impresa editoriale che da quasi venti anni ha raccolto raccolto la voce dei programmatori, programmatori, dei sistemisistemisti, dei professionisti, degli studenti, dei ricercatori e dei professori d’informatica italiani. Sono più di 800 gli autori che hanno realizzato per le testate Computer Programming, Dev, Login, Visual Basic Journal e Java Journal, molte migliaia di articoli tecnici, presentazioni di prodotti, tecnologie, protocolli, strumenti di lavoro, tecniche di sviluppo e semplici trucchi e stratagemmi. Oltre 6 milioni di copie distribuite, trentamila pagine stampate, fanno di questa impresa la più grande ed influente realtà dell’editoria specializzata nel campo della programmazione e della sistemistica. In tutti questi anni le riviste Infomedia hanno vissuto della passione di quanti vedono nella programmazione non solo la propria professione ma un’attività vitale e un vero divertimento. Nel 2009, Infomedia e` cambiata radicalmente adottando un nuovo modello aziendale ed editoriale e si è è organizzata attorno ad una idea di Impresa Sociale di Comunit a, a` , partecipata da programmatori e sistemisti, separando le attività di gestione dell’informazione gestite da un board comunitario professionale e quelle di produzione gestite da una impresa strumentale. Questo assetto è in linea con le migliori esperienze internazionali e rende Infomedia ancora di pi u` parte della Comunit a` nazionale nazionale degli sviluppatori di software. Infomedia e` media-partner di manifestazioni ed eventi in ambito ambito informatic informatico, o, collabora collabora con molti dei pi ù importanti editori informatici italiani come partner editoriale e fornitore di servizi di localizzazione in italiano di testi in lingua inglese.

L’impaginazione automatica di questa rivista e` realizzata al 100% con strumenti Open Source usando OpenOffice, Emacs, BHL, BHL, LaTeX, Gimp, Inkscape e i linguaggi Lisp, Python e BASH

For copyright copyright information information about the contents contents of Java Journal, please see the section “Copyright” at the end of each article if exists, otherwise ask authors. Infomedia contents is © 2007 Infomedia and released as Creative Commons2.5 Commons2.5 BY-NCBY-NC-ND.TuringClub ND.TuringClub content content is © 2007 Turing Club released as Creative Commons 2.5 BY-ND. Le informazioni di copyright sul contenuto di Java Journal sono riportate nella sezione “Copyright” alla fine di ciascun articolo o vanno richieste direttamente agli autori. Il contenuto Infomedia e` © 2007 Infomedia e rilasciato con Licenza Creative Commons 2.5 BY-NC-ND. Il contenuto Turing Club e` © 2007 Turing Club e rilasciato con Licenza Creative Commons 2.5 BY-ND. Si applicano tutte le norme di tutela dei marchi e dei segni distintivi. E` in ogni caso ammessa la riproduzione riproduzione parziale o totale dei testi e delle immagini per scopo didattico purch´ e vengano vengano integral integralmente mente citati gli autori autori e la completa completa identificazione della testata. Manoscritti e foto originali, anche se non pubblicati, non si restituiscono. restituiscono. Contenuto pubblicitario inferiore al 45%. La biografia dell’autore riportata nell’articolo e sul sito www.info www.infomedia media.it .it e` di norma norma quella quella dispon disponibi ibi-le nella nella stampa stampa dell’a dell’arti rticol colo o o aggio aggiorna rnata ta a cura dell’a dell’auto utore re stesso. stesso. Per aggio aggiorna rnarla rla scriver scriveree a info@infom info@infomedia. edia.it it o farlo in autonomia autonomia all’indiri all’indirizzo zzo / moduli / biografia http: // mags.programmers.net mags.programmers.net moduli / biografia

JAVA Journal

focus

Programmazione AOP con AspectJ Dopo anni di program Dopo programmaz mazion ionee struttur strutturata ata,, si è pas passat satii ad anni di programm programmazi azione one ad oggetti oggetti.. Ora si inizia a parlare di POP (Post Object Programming), e delle tecnologie correlate. AOP (Aspect Oriented Programming), è appunto una di queste tecnologie. Vediamo di cosa si tratta, con esempi pratic pra ticii e l’u l’util tilizz izzoo di di un un comp compila ilator toree grat gratuit uitoo come come Asp Aspect ectJJ.

>> di Matteo Baccan ([email protected])

Perché AOP

P

rogettare una libreria di funzioni o un framework di classi, è sicuramente un’operazione lunga e laboriosa. Occorre capire i problemi che si avranno, il modo col quale astrarli e generalizzarli, ma soprattutto prevedere, nel modo più completo possibile, le nuove esigenze che si potrebbero avere, per evitare di trovarsi, durante lo sviluppo, in problemi architetturali. Esistono però delle esigenze orizzontali ad un framework, che dovrebbero far parte di tutte le classi, ma, per evitare di sporcare tutto il codice, si tende a non integrarle, ad integrarle parzialmente, o a delegarle al programma chiamante. Esempi classici di queste esigenze sono la gestione degli errori, il debug degli oggetti, il controllo formale dei parametri e così via. Cosa vuol dire affrontare in modo generalizzato queste problematich problematiche? e? Sicuramente significa creare dei sorgenti ridondanti, copiare dei frammenti di codice da un metodo all’altro, astrarre esigenze in interfacce ed obbligare le classi ad implementarle. Fino ad arrivare agli assurdi delle dipendenze circolari, schemi dai quali diventa complicato uscire. Quando poi l’esigenza orizzontale muta, ne risente l’intero framework, creando delle destabilizzazioni nel codice: se il tutto non è stato progettato più che bene, ci si può trovare di fronte alla riscrittura di varie classi, che non dipendon dipendono o direttamente dalla modifica della funzionalità orizzontale, ma semplicemente sono impattate in quanto utilizzatrici dirette della funzionalità ormai obsoleta.

54

n.3 - marzo/aprile 2007

Lo scopo di AOP è quello di isolare un’esigenza orizzontale, racchiuderla all’interno di una regola ( as( as pect), pect ), ed applicarla solamente nei punti in cui serve, senza impattare minimamente la classe che ne trarrà vantaggio. Questo vuol dire che, le persone che sviluppano una classe e quelle che la arricchiscono con un aspect aspect,, possono tranquillamente tranquillamente far parte di due team di sviluppo diversi, dato che lavorano su due set di classi differenti, che si fondono per creare un unico bytecode, che sarà quello che andrà ad essere utilizzato in fase di runtime. Sorgenti diversi, impatti minimi al cambio delle funzionalità delle classi, possibilità di aggiungere comportamenti senza modificare il framework che deve essere arricchito, queste sono le caratteristiche principali di AOP. AOP.

AspectJ Lo strumento di cui parleremo in questo articolo è AspectJ,, un compilatore gratuito, che si appoggia a AspectJ javac e permette di integrare, all’interno delle proprie classi, degli aspect. degli aspect. Questo compilatore è facilmente scaricabile da: http: //www.eclipse.o //www .eclipse.org/aspectj/, rg/aspectj/, e si installa con la classica invocazione da riga comando: java -jar aspectj1.5.0.jar. Una volta installato, viene creata una cartella su disco, generalmente c:\aspectj1.5\, c:\aspectj1.5\, che conterrà sia il compilatore che le librerie per poterlo utilizzare. Il passo successivo sarà quello di mettere in path la directory c:\aspectj1.5\bin e in classpath il jar di AspectJ: c:\aspectj1.5\lib\aspectjrt.jar.

JAVA Journal

FIGURA 1

focus

Struttura delle classi senza AOP

Fatte queste due operazioni basilari, siamo pronti per utilizzare AspectJ e creare crea re le prime applicazioni applicazion i AOP. Iniziamo quindi ad introdurre alcuni concetti di base.

Concetti di base Alla base della programmazio programmazione ne AOP c’è il concetto di cros scutting concern (CC), traducibile in interesse trasversale. Quando si parla di CC, si fa riferimento ad un requisito che può essere pensato in modo autonomo, ed applicato in più punti, all’interno del progetto che si sta sviluppando, senza essere necessariamente legato alla funzionalità che si intende sviluppare. Il poter astrarre un requisito, per poi applicarlo in modo orizzontale, ci permette di racchiudere la problematica in quello che viene definito aspect. All’interno di un aspect, sono poi presenti le regole che indicano dove applicarlo. Il vantaggio di un aspect è appunto il fatto di essere racchiuso all’interno di un proprio sorgente, dove non vi è dipendenza pendenz a diretta rispetto alle classi dove verrà applicato. Per questo motivo, è possibile uno sviluppo parallelo di requisiti. Sarà poi compito del compilatore, nel nostro caso AspectJ, fondere regole e classi, all’interno dello stesso framework. Pro viamo via mo ora ad app approf rofond ondire ire que questi sti con concet cetti ti con de degli gli ese esemp mpi. i.

Chiaramente, la partenza di tutto è un framework Chiaramente, preventivamente costituito, sul quale vogliamo aggiungere aggiunger e il controllo d’accesso. Perché non modificare direttamente il framework? Le ragioni potrebbero essere molteplici, come il non disporre dei sorgenti del framework, oppure il dover applicare tali modifiche solo ad un progetto che lo utilizza, ma non a tutte le applicazionii che lo utilizzano, evitando quindi di applicazion aggiungere codice inutile dove non serve. Se vogliamo analizzare la problematica, dal punto di vista dell’Obje dell’Object ct Orientation (OO), il primo approccio che potrebbe venire in mente, in questo caso, è quello di creare una classe di controllo accessi, modificare il sorgente della classe che deve aggiungere la funzionalità, inserirvi un metodo di controllo e modificare tutti i sottometodi che devono essere controllati, con la chiamata a questo metodo. Questo approccio obbliga, necessariamente, la modifica di gran parte del codice della classe, rendendo, di fatto, il controllo d’accesso una funzionalità obbligatoria, in ogni ambito in cui la classe è utilizzata. In un’ottica di riutilizzo del framework, si traduce nel aver introdotto qualcosa che servirà solamente in un certo caso specifico, ma non nella totalità dei casi in cui verrà utilizzato il framework stesso. Ne consegue una struttura similare a quella presente in Figura 1. Vediamo invece cosa cambia, nel momento in cui decidessimo di creare un aspect. Ciò che viene stravolto totalmente è il modo col quale applicare il controllo d’accesso. Non occorre più modificare le classi o i framework che devono supportare questo nuovo requisito, ma basta creare singolarme singolarmente nte il requisito, all’interno di un aspe ct , definire quando deve essere applicato e compilarlo insieme al codice del framework. Questa modalità permette di aggiungere del codice, ad applicazioni già scritte, senza bisogno di modificarle. Le classi quindi, non devono ereditare da un qualcosa, ma è quel qualcosa che si inserisce nelle classi. Ne risulta, quindi, una struttura simile a quella mostrata nella Figura 2 , dove non si parla più di ereditarietà della classe di controllo degli accessi, ma di utilizzo.

Log degli accessi Ipotizziamo di dover controllare tutti gli accessi ad una certa classe. Le ragioni potrebbero essere svariate: un controllo di utilizzo, un test di performance o l’applicazione di un controllo di accesso. L’idea è quella di creare un as pect, in grado di intercettare tutti gli accessi ad un certo metodo di una certa classe, visualizzandoli a video.

FIGURA 2

Struttura delle classi con AOP


55

JAVA Journal

focus

zializzazione di un oggetto; Advice execution: all’esecuzione di un Advice.

Classe Demo public class Demo { public static void main(String[] args){ Demo d = new Demo(); d.go(); }

•

public Demo(){} public String cVar = “”; public void go(){ metodo1( “PAR1” ); System.out.println( “passo 100 a Metodo2 [“ +metodo2( 100 ) +”]” ); } public void metodo1( String cPar ){ System.out.println( System.out.p rintln( “Metodo1 chiamato con parametro stringa [“ +cPar +”]”); } public String metodo2( int n ){ System.out.println( System.out.p rintln( “Metodo2 chiamato con parametro numerico [“ +n +”]”); return “valore di ritorno*2 (“ +(n*2) +”)”; } }

LISTATO 1

Elementi fondamentali della programma programmazione zione AOP Chiarita la differenza di approccio rispetto alla programmazione Object Oriented, vediamo di scendere maggiormente in dettaglio, rispetto a AOP, introducendo un set minimale di costrutti, con i quali è possibile creare qualsiasi tipo di aspect e di conseguenza poter sfruttare appieno questo paradigma di programmazione. I costrutti che occorre conoscere sono: oin Point: è il punto di esecuzione di un programma: il richiamo di un metodo o l’assegnazio l’assegnazione ne di una variabile d’istanza; Pointcut: è il meccanismo che permette di selezionare su quali Join Point andrà ad agire un Advice; Advice: è il codice codice che deve essere essere eseguito nel Join Point selezionato dal Pointcut; Aspect: è l’insieme l’insieme di Advice e Pointcut.

•

•

•

•

In base a queste descrizioni, se volessimo definire definire cos’è un aspect potremmo dire: è una regola che indica il punto dove deve essere eseguito del codice. Il concetto di base è molto semplice, ma allo stesso modo molto potente. Vediamo ora di capire quali sono i Join Point sui quali possiamo agire: •

•

•

•

• •

56

Method execution/call: execution/call: durante l’esecuzione o il richiamo di un metodo; Constructor execution/call: durante l’esecuzione o il richiamo di un costruttore; Class initialization: all’atto dell’inizializzazione di una classe; Field read/write: alla scrittura o lettura in una variabile d’istanza; Exception Exceptio n handler: quando si verifica un’eccezione; Object initialization/pre-initialization: all’atto dell’ini-


Con queste direttive, si riescono a coprire tutte le casistiche di una normale struttura ad oggetti. Vediamo ora le caratteristiche che possono avere i singoli costrutti, per meglio comprendere come e quando applicarli

Applicazione di un Join Point

Come abbiamo spiegato nel paragrafo precedente, un Join Point , può essere applicato sia in fase di esecuzione, sia in fase di richiamo di un certo metodo. La domanda più spontanea che può venire in mente è: perché questa differenza? In effetti, aggiungere del codice in un solo punto, all’interno di un metodo, o aggiungerlo in ogni sua esecuzione, non cambia il risultato che si vuole ottenere. Cambia però a livello di risparmio di codice e cambia soprattutto se non si può modificare direttamente il sorgente della classe che intendiamo controllare. Partiamo da un caso reale: si vuole condizionare l’utilizzo di un certo metodo di una certa classe. Ipotizziamo che, tale metodo, sia all’interno di una classe di cui disponiamo il sorgente. In questo caso, il punto migliore per poter applicare l’ aspect è nel momento dell’esecuzione, quindi dentro il metodo stesso. Se però il metodo non ci è stato dato in chiaro, perché contenuto in una classe di cui abbiamo solo la libreria (.jar), l’unico modo con cui possiamo applicare l’ aspect è al momento del suo utilizzo. Sicuramente questo secondo modo di utilizzare un aspect è più prolisso, ma è l’unico modo col quale possiamo applicarlo in questo contesto.

Esistono delle esigenze orizzontali ad un framework, che dovrebbero far parte di tutte le classi

JAVA Journal

focus

Call / Execution

L’idea è quella di

Proviamo quindi a creare un Aspect, partendo dalla classe Demo presente nel Listato 1: La classe d’esempio dispone di due metodi. Il primo non restituisce alcun risultato, mentre il secondo, restituisce un risultato String. Quello che dobbiamo creare ora è un aspect, come illustrato di seguito:

Aspect aspect Logging { pointcut primo_metodo(): call( void Demo.metodo1(Stri Demo.metodo1(String)); ng)); pointcut primo_metodo2() primo_metodo2():: execution( String Demo.metodo2(int Demo.metodo2(int)); )); void around(): primo_metodo() { System.out.println(“Prima”); proceed(); System.out.println(“Dopo”); } String around(): primo_metodo2() { System.out.println(„Prima2“); String cRet = proceed(); System.out.println(“Dopo2”); return cRet; } }

Un aspect è sintatticamente molto simile ad una classe, di cui ricorda molto la struttura. Le differenze sono minime, ma importanti. Al posto del token token class, per indicare un aspect, occorre scri vere “ aspect”. Dopo la definizione del nome, possiamo passare a definire i pointcut e soprattutto i punti in cui devono agire: se al richiamo, call, del metodo o se alla sua esecuzione, execution. Una volta decisa la modalità, possiamo indicare quale gruppo di metodi, o singolo metodo, deve essere impattato. Nel nostro caso si è deciso di indicare i due metodi della classe Demo. Ultimo punto da affrontare, è quello di creare un advice, nel quale inserire il codice da eseguire. Anche l’ advice advice ha una propria sintassi, data dal ritorno del metodo da arricchire, dalla modalità di utilizzo, nel nostro caso around, cioè “attorno” al metodo che stiamo modificando, e da un proprio nome. Una volta definito, possiamo creare tutto il codice Java che desideriamo, ricordandoci di utilizzare il metodo proceed() per attivare il metodo che si stava modificando. Per compilare queste righe con AspectJ è sufficiente chiamare il compilatore ajc passando, tramite una @, il nome del file contenente l’elenco dei sorgenti da compilare, come in questo esempio: ajc @files.lst. A questo punto, invocando l’esecuzione della classe Demo (java demo), otterremo l’ouput:

creare un aspect, in grado di intercettare tutti gli accessi ad un certo metodo di una certa classe Esecuzione Prima Metodo1 chiamato con parametro stringa [PAR1] Dopo Prima2 Metodo2 chiamato con parametro numerico [100] Dopo2 passo 100 a Metodo2 [valore di ritorno*2 (200)] L’effetto è quello di avere, prima e dopo l’esecuzione dei due metodi, la visualizzazione di due messaggi. Chiaramente, se al posto dei messaggi ci fosse stato il controllo d’accesso, avremmo risolto in modo ottimale la problematica, senza impattare la classe Demo.

Staticinitialization Altro punto interessante, nel quale applicare un aspect, è l’inizializzazione l’inizializz azione di un oggetto tramite un costrutto static. L’inizializzazione statica viene applicata tutte le volte in cui, in una classe, si ha l’esigenza di creare un qualcosa di comune a più istanze della classe stessa. Un esempio potrebbe essere la lettura di un file di configurazione, o la creazione dati statici. Tale inizializzazione avviene una sola volta sola, in tutto il programma. Potrebbe però essere interessante modificarne il comportamento o sempliceme semplicemente nte notificarne l’esecuzio l’esecuzio-ne. Anche in questo caso c’è un apposito pointcut da definire. Come si può notare nel prossimo listato, la cosa che cambia è la direttiva staticinitializati staticinitialization on da passare al pointcut. Per quanto riguarda l’ advice advice, la sintassi è la stessa del caso precedente. La cosa che varia è la presenza di void come valore di di ritorno, dato che le inizializzazioni inizializzazioni non hanno hanno un valore di ritorno.

Staticinitialization aspect Logging { pointcut primo_metodo() : staticinitialization( Demo );


57

JAVA Journal

focus

void around() : primo_metodo() { proceed(); } }

Set/Get

This/Target aspect Logging { pointcut primo_metodo() : execution( * *.go() ) && this(Demo2); void around(): primo_metodo() { proceed(); }

Così come possiamo controllare l’accesso ad un metodo, è possibile controllare l’accesso ad una variabile d’istanza, sia in lettura che in scrittura. Per fare questo è possibile utilizzare un pointcut dove indicare quale variabile, di quale advice, classe, andare a controllare. Per quanto riguarda l’ advice rimane tutto invariato, come nel caso del metodo:

Set/Get

pointcut primo_metodo2() : execution( * *.go() ) && target(Demo); void around(): primo_metodo2() { proceed(); } }

aspect Logging { pointcut primo_metodo() : set( String Demo.cVal ); pointcut primo_metodo2() : get( String Demo.cVal ); void around() : primo_metodo() { proceed(); } String around() : primo_metodo2() { String c; c = proceed(); return c; } }

Questa modalità permette di aggiungere del codice, ad applicazioni già scritte, senza bisogno di modificarle

This/Target

Un’altra modalità di attivazione, specificabile all’interno di un pointcut è data dalla classe di attivazione. Ipotizziamo di avere più classi che hanno un metodo comune chiamato go. Invece di specificare N pointcut, uno per ogni metodo di ogni classe, possiamo indicarne uno solo, utilizzando la wildcard “*”. Un esempio potrebbe essere “ pointcut pc(): execution( * *.go() )”: dato qualsiasi metodo go, di qualsiasi classe, con qualsiasi valore di ritorno, gestisci il pointcut pc(). Chiaramente, tutto funziona correttamente, nel caso in cui ci siamo poche classi. Quando invece si utilizzano framework molto grandi, potrebbe essere necessario limitare la capacità di questo pointcut. Per questo sono stati introdotte le estensioni this( classe ) e target( classe ). Tramite questi due costrutti è possibile limitare un pointcut all’interno di una certa classe (this) o solamente quando viene chiamato in una certa classe (target), come esposto in seguito:

Args

Altro filtraggio possibile sui pointcut è dato dai parametri passati. È infatti possibile utilizzare delle wildcard e parallelamente indicare che, i parametri gestiti dal metodo che si intende controllare, sono di un certo tipo. In seguito è presente un esempio di utilizzo di args() collegato a tutti i metodi che ricevono come argomento un oggetto String.

Args aspect Logging { pointcut primo_metodo() : execution( void *.*(*) ) && args( String ); void around() : primo_metodo() { System.out.println(“Prima”);

58


JAVA Journal

focus

proceed(); System.out.println(“Dopo”); } }

Advice Ora che abbiamo ben compreso come creare dei poin tcut, vediamo quali tipo di esecuzione è possibile far fare ad un adv advice ice . Oltre ad arou nd, osservato negli esempi precedenti, è possibile anche indicare before se vogliamo eseguire del codice prima del poin tcut , o aft after, er, se lo vogliamo eseguire dopo. Da notare che un adv advice ice è di per se molto simile ad un metodo, in quanto, come un metodo: • • •

di questo tipo di programmazione, ma solo i concetti base, che permettono di capire come iniziare a programmare. Come si può notare, il concetto base di AOP è molt molto o sempl ice. Serv Servono ono poch poche e righ righe e di codi codice ce per arricchire in modo concreto, molte classi di nuove funzionalità. Piuttosto, il problema di AOP è la sua giovane età. Il supporto per questo tipo di programmazione non è ancora molto diffuso, anche se inizia a essere presente in alcuni ambienti di sviluppo. Inoltre, pensare in AOP, richiede un ulteriore passo in avanti, rispetto alla programmaz programmazione ione Object Oriented, passo di cui non si sente ancora l’esigenza diffusa. Come tutte le cose, il tempo ci potrà dare ragione o potrà cancellare completamente questo approccio postobject oriented.

Segue delle regole di accesso per essere eseguito Può generare un’eccezione Può fare riferimento all’ asp aspect ect corrente tramite this

Al contr c ontrario ario di un u n met odo però: p erò: • •

•

Non ha un nome Non può essere chiamato direttamente, è il sistema che lo esegue Ha accesso ad alcune variabili valorizzate all’interno di this che possono servire a prendere informazioni sui join poin t catturati: thisJoinP thisJoinPoint oint

Un aspect è una regola che indica il punto dove deve essere eseguito

Altr o aspet Altro a spetto to inte interess ressant ante e degli de gli adv advice ice è quello di poter essere eseguiti dopo il ritorno di un valore da un metodo, oppure nel momento di un’eccezione nel codice.

del codice

Advice su eccezione Ultimi, ma non meno importanti, sono gli Advi ce su eccezione. Chiaramente, anche in questo caso, esiste una sintassi ben precisa, che ricalca molto quella vista per i metodi. Si tratta di definire sempre il momento in cui intercettare l’eccezione (ex: aft after) er) , indicare che si vogliono gestire le eccezioni: throwing e definire su quali metodi si intende farlo, nel caso del listato seguente sono stati indicati tutti i metodi: “* *.*()”.

Bibliografia [1] http://www.eclipse.org/aspectj/, AspectJ [2] http://www.eclipse.org, il progetto Eclipse [3] http://www.eclipse.org/aspectj/downloads.php, la pagina di download di AspectJ [4] http://www.baccan.it/index.php?sezione=webbit2 004, dove poter scaricare i sorgenti d’esempio analizzati in questo articolo.

Advice su eccezione aspect Logging { after() throwing: call(* *.*()) { System.out.println(“ERRORE”); } }

Note Biografiche

è uno specialista di progettazione e sviluppo C++, JAVA e AOP. È ideatore del portale JobCrawler.it e speaker in importanti eventi Java (Javaday, JIP Day). Attualmente si occupa di analisi presso un importante operatore di telefonia mobile. Può essere contattato tramite il suo sito http: //www.baccan.it. Matteo Baccan

Conclusioni Questo articolo è un’introduzione alla programmazione AOP. AOP. Non sono stati toc cati i conc etti più compless i


59

Programmazione AOP con AspectJ

Recommend Documents