Il documento descrive il framework Spring e il suo approccio all'Aspect-Oriented Programming (AOP) per la gestione di applicazioni J2EE. Viene evidenziata l'importanza di principi di design come modularità, separazione delle preoccupazioni e acquisizione dell'informazione, sottolineando le capacità del contenitore Spring per configurazione centralizzata, gestione delle transazioni e semplificazione dell'accesso ai dati. Inoltre, viene fornita un'analisi dettagliata della configurazione dei bean e delle pratiche consigliate per l'uso di AOP in contesti complessi.

1. Spring Framework
Core e AOP

2. J2EE Applications
Composte da più “blocchi” in collaborazione
tra loro
Utilizzano containers invasivi per la gestione
di aspetti (transazioni,ecc.)
Spesso non rispettano il principio “1:1” –
design level requirements-implementation

3. Le caratteristiche desiderabili
DRY principle
Modularity
Information hiding
Separation of Concerns

4. DRY Principle
Ogni sottosistema dovrebbe avere una
rappresentazione singola, non ambigua,
autoritativa.

5. Modularity
Un’unità in cui gli elementi strutturali sono
strettamente legati tra loro e poco legati con
le altre unità

6. Information hiding
Ogni modulo è caratterizzato dalla sua
conoscenza della decisione di design che
nasconde agli altri. La sua interfaccia o
definizione è scelta per rivelare il meno
possibile sul suo funzionamento.

7. Separation of Concerns
Significa focalizzare su una cosa alla volta

8. Caratteristiche principali
Lightweight container
Strato di astrazione per transazioni
Strato di astrazione JDBC
Integrazione AOP
Piena integrabilità con i frameworks più
diffusi

9. Spring lightweight container
Configurazione centralizzata degli oggetti applicativi
e dei loro collegamenti
Non invasivo (le classi non devono implementare
particolari interfaces o estendere classi del
framework
Assembla un sistema complesso a partire da
componenti disaccoppiati (POJO)

10. Astrazione per Transazioni
Integra un transaction manager
“preconfezionato” utilizzando le funzionalità
AOP
Demarca le transazioni a livello di
configurazione senza dover gestire a codice
le problematiche legate alla specificità del
contesto.

11. Strato di astrazione JDBC
Uniforma la gestione delle transazioni
Si integra con le più diffuse tecnologie ORM
Classi di supporto (templates)
DAO layer semplificato
Riduzione possibilità errori

12. Funzionalità AOP
Approccio AOP integrato
Supporto di una parte del progetto
“AspectJ”
Proxy-based system
AOP full language support

13. I moduli di Spring

14. Il file spring-context
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>
XML BASED Configuration Metadata
Attenzione: l’import degli xsd deve essere eseguito in base alle
funzionalità implementate

15. Istanziare i beans
In fase di startup i beans vengono pre-istanziati
come singletons
Gli eventuali errori vengono rilevati subito senza
attendere un tempo indefinito
In ogni caso i beans possono essere istanziati
quando richiesto (lazy-init)
Ciascun bean può essere configurato affinchè
venga restituita una istanza (scope="prototype“)

16. Definizione di un bean
<bean id="dataSource" class="org.springframework.jdbc.
datasource.DriverMana gerDataSource">
<property name="driverClassName“ value="com.mysql.jdbc.
Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/corsi" />
<property name="username" value="myUser" />
<property name="password" value="myPassword" />
</bean >

17. … e di un altro bean che lo usi..
<bean id="empDAO" class="refbeanexample.EmployeeDAO">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
Il bean sarà iniettato con la property “dataSource” dopo essere stato
istanziato dal container e tramite il “setter” method.

18. D.I. tramite costruttore
<bean id="empDAO2" class="refbeanexample.EmployeeDAO">
<constructor-arg>
<ref local="dataSource"/>
</constructor-arg>
</bean>
Il risultato è il medesimo ma il bean è iniettato quando è
istanziato.

19. Constructor Argument type matching
<bean id="exampleBean" class="examples.ExampleBean"
>
<constructor-arg type="int" value="7500000"/>
<constructor-arg type="java.lang.String" value="42"/>
</bean>

20. Constructor Argument index
<bean id="exampleBean" class="examples.
ExampleBean">
<constructor-arg index="0" value="7500000"/>
<constructor-arg index="1" value="42"/>
</bean>

21. Best practise
E’ preferibile l’utilizzo di “setter injection”
Alcune proprietà possono essere opzionali
Il risultato sarà un xml più snello e
controllabile
Si evitano dipendenze circolari
In alcuni casi, es. codice legacy, potrebbe
essere opportuno o necessario l’uso di
“constructor injection”

22. Property values
Il valore di una property è fornito tramite una
stringa leggibile.
Spring effettua automaticamente la
conversione nel tipo richiesto dalla property
Esistono forme “contratte” per specificare i
valori di java.util.Properties

23. Laboratorio
Esempio bean-ref
Esempio Costructor Inection

24. Una Enterprise Application tipica
Web Tier
Action Action Action
A B C
Business Services
Service
Service Service
3
1 2
Data access Domain model
Class Class
Class
Attributes Attributes
DAOs/ Attributes
Repositor attributes attributes
attributes
y

25. Costruiamola con Spring
Costruzione di POJO per il domain model
Costruzione di DAO per Data Access
Costruzione di Servizi
Gestione delle transazioni
Esempio utilizzo Hibernate

26. Laboratorio
Applicazione gestione corsi

27. Aspect Oriented Programming
Spring 2.0 (2006) e AspectJ 5 (2005)
AOP è un approccio quindi una scelta per
risolvere determinate problematiche
Comunemente usato per la gestione delle
transazioni in Spring grazie anche ad alcuni
built-in beans

28. Spring AOP
framework proxy-based
Java + ‘weaver’
Soluzione AOP più utilizzata
Integrata con Spring container
Limitato uso (execution) dei join points
Sufficiente nel 90% dei casi
Weaving : linking aspects with other application types or objects to create an advised object. This can be done
at compile time (using the AspectJ compiler, for example), load time, or at runtime.
Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime .

29. L’unità base di un aspetto
Aspect
Attributes
Behaviours
u
WHERE (pointcuts) s acces
e s
WHAT (advice)

30. Pointcuts
E’ un’espressione con una sintassi simile a
Regular Expressions
Spring NON valida l’espressione
Definisce, in Spring, quando viene eseguito
un metodo con una determinata signature

31. Join points (method execution)
Un ‘method execution’ join point si verifica
quando viene eseguito un metodo
Le informazioni che possono essere usate
per il join point:
Nome del metodo
Tipo parametro
Tipo restituito
Eccezione dichiarata

32. Advices
Ogni dichiarazione di advice è associata con un
pointcut expression
Il codice dell’advice viene eseguito nel join point verificato
dal pointcut expression
Rispetto al join point, l’advice può essere eseguito:
Before
After
After returning
After throwing
Around

33. Before advice
“gira” prima di un join point verificato. Non
può modificare i valori degli argomenti, non
può influenzare il funzionamento del flusso
logico se non lanciando una exception

34. After Advice
“gira” dopo un join point verificato, non può
modificare il valore di ritorno, né influenzare
il flusso computazionale; tranne lanciando
una exception.

35. After Returning advice
“gira” dopo un ritorno eseguito da un join
point verificato. Non può modificare il valore
di ritorno e non può modificare il flusso
computazionale, tranne lanciando una
exception.

36. After throwing
“gira” dopo aver lasciato un join point
verificato da una condizione di exception.
Non può influenzare il flusso ma può a sua
volta lanciare una exception.

37. Around
“gira” sia prima che dopo un join point
verificato. Può determinare se, quando e
come deve continuare il flusso
computazionale, può cambiare gli
argomenti, gli oggetti ed i valori di ritorno.
Per motivi di performance utilizzarli solo
quando non è possibile usare gli altri

38. Proxy system
Le classi devono implementare un’interface
Il file di configurazione deve contenere il tag:
<aop:aspectj-autoproxy/>
Attenzione all’uso del puntatore ‘this’
Si riferisce al proxy
Si riferisce all’advice

39. Ancora sul transaction manager
La versione precedente di Spring (2.0)
utilizzava un proxy per la gestione delle
transazioni
La versione attuale utilizza un advice bean

40. Potenzialità di AOP
Possibilità di modellare, all’interno di un sistema:
Transactions
Security
Remoting
Tracing
Profiling
Failure handling
Management
Caching
….