La programmazione orientata agli aspetti (AOP) complementa quella orientate agli oggetti (OOP), adottando il concetto di “aspetto”: un aspetto non è altro che una modularizzazione di un concetto comune a più classi (la gestione delle transazioni può essere ad esempio considerata un aspetto).
Se utilizziamo Spring, gli aspetti possono essere definiti usando un approccio schema-based (quindi attraverso xml) o usando annotazioni (stile AspectJ).
Oltre all'aspetto, alcuni punti di fondamentale importanza nella comprensione dell'Aspect-Oriented Programming sono:
- joint point: è un punto all'interno del ciclo di esecuzione di un programma; in Spring AOP un joint point coincide sempre con l'esecuzione di un metodo.
- advice: si tratta dell'azione presa da un aspetto in un particolare joint point.
- pointcut: è un predicato che corrisponde a uno o più joint point
- target: sono gli oggetti interessati da uno o più aspetti
- proxy AOP: è un oggetto creato dal frame work AOP per la gestione degli aspetti
Gli advice sono quindi associati a pointcut che corrispondono a particolari joint point di oggetti target.
Se per esempio vogliamo eseguire un metodo A prima che venga invocato un metodo B su un oggetto O (che nel nostro caso costituisce il target), allora il “metodo A” diventa il nostro advice, il “metodo B” diventa il nostro joint point per cui definiremo un point cut che faccia corrispondere al joint point “metodo B”, l'advice “metodo A”.
Tipi di advice
Esistono naturalmente diversi tipi di advice:
- before advice: un'azione (advice) che viene eseguita prima di un join point.
- after returning advice: un'azione che viene eseguire dopo che un joint point viene completato senza eccezioni.
- after throwing advice: un'azione che viene eseguita se un joint point produce un'eccezione.
- around advice: un'azione che viene eseguita prima e dopo l'invocazione di un joint point.
Abilitare il supporto AspectJ con Spring
Per utilizzare gli aspetti in stile AspectJ (con annotazioni) è necessario abilitarne il supporto ed effettuare l'autoproxing dei bean: questo significa che Spring determinerà quali bean sono interessati da uno o più aspetti ed automaticamente genererà un proxy per tali bean, per intercettare l'invocazione dei joint point interessati da pointcut ed assicurare l'esecuzione degli advice.
Il supporto AspectJ in Spring viene abilitato includendo il seguente elemento nel file di configurazione di spring:
<aop:aspectj-autoproxy/>Dichiarare un aspetto
Con il supporto AspectJ abilitato, ogni bean definito nell'application context ed annotato con @AspectJ costituisce un aspetto.
<bean id=”mio_aspetto” class=”MiaClasse”>
// ...
</bean>
@Aspect
public class MiaClasse {
// ...
}L'aspetto contiene al suo interno la definizione di pointcut ed advice.
Volendo utilizzare un approccio schema-based, la precedente definizione verrebbe tradotta in:
<aop_config>
<aop:aspect ref=”mio_aspetto”>
// ...
</aop:aspect>
</aop:config>Dichiarare un pointcut
La dichiarazione di un pointcut è composta da due parti: la firma di un metodo comprendente nome e parametri e un predicato che determina quali metodi sono interessati dal poincut.
In AspectJ un pointcut è definito attraverso l'annotation @Pointcut
@Pointcut("execution(* metodoInteressato(..))")
private void mioPointcut() { //... }Nel precedente esempio viene definito un pointcut "mioPointcut" che corrisponde all'esecuzione di "metodoInteressato".
Le espressioni pointcut possono essere combinate usando &&, || e !.
Volendo utilizzare un approccio schema-based, la precedente definizione verrebbe tradotta in:
<aop_config>
<aop:aspect ref=”mio_aspetto”>
<aop:pointcut id=”miopointcut” expression=”execution(* metodoInteressato(..)” />
</aop:aspect>
</aop:config>Dichiarare advice
Un advice è associate ad un'espressione pointcut e può essere eseguito prima e/o dopo l'esecuzione del metodo che è interessato dal pointcut.
L'advice Before viene dichiarato in un aspetto usando l'annotation @Before e viene eseguito prima dell'esecuzione del metodo interessato dal pointcut.
@Aspect
public class Mio Aspetto {
@Before (“mioPointcut”)
public void azionePrecedente() {
// ...
}
}Volendo utilizzare un approccio schema-based, la precedente definizione verrebbe tradotta in:
<aop:config>
<aop:aspect ref=”mio_aspetto”>
<aop:pointcut id=”miopointcut”
expression=”execution(* metodoInteressato(..)” />
<aop:before pointcut-ref=”miopointcut”
method=”azionePrecedente” />
</aop:aspect>
</aop:config>L'advice after-returning viene eseguito subito dopo l'esecuzione regolare (senza eccezione) di un metodo interessato dal pointcut corrispondente:
@Aspect
public class Mio Aspetto {
@AfterReturning (“mioPointcut”)
public void azioneSuccessiva() {
// ...
}
}A volte si ha la necessità di accedere al valore restituito dal metodo interessato dal pointcut nel seguente modo:
@Aspect
public class Mio Aspetto {
@AfterReturning (pointcut=“mioPointcut”, returning=”valore”)
public void azioneSuccessiva(Object valore) {
// ...
}
}Il valore dell'attributo returning deve corrispondere al nome dell'argomento del metodo advice.
@AfterThrowing viene invece utilizzato per un advice che deve essere eseguito dopo l'esecuzione del metodo interessato dal pointcut che produce un'eccezione.
@Around invece viene utilizzato per un advice che deve essere eseguito prima e dopo l'esecuzione del metodo interessato dal pointcut.
