Spring Framework

Core e AOP

J2EE Applications

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

Le caratteristiche desiderabili

DRY principleModularityInformation hidingSeparation of Concerns

DRY Principle

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

Modularity

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

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.

Separation of Concerns

Significa focalizzare su una cosa alla volta

Caratteristiche principali

Lightweight containerStrato di astrazione per transazioniStrato di astrazione JDBCIntegrazione AOP Piena integrabilità con i frameworks più diffusi

Spring lightweight container

Configurazione centralizzata degli oggetti applicativi e dei loro collegamentiNon invasivo (le classi non devono implementare particolari interfaces o estendere classi del frameworkAssembla un sistema complesso a partire da componenti disaccoppiati (POJO)

Astrazione per Transazioni

Integra un transaction manager “preconfezionato” utilizzando le funzionalità AOPDemarca le transazioni a livello di configurazione senza dover gestire a codice le problematiche legate alla specificità del contesto.

Strato di astrazione JDBC

Uniforma la gestione delle transazioniSi integra con le più diffuse tecnologie ORMClassi di supporto (templates)DAO layer semplificatoRiduzione possibilità errori

Funzionalità AOP

Approccio AOP integratoSupporto di una parte del progetto “AspectJ” Proxy-based systemAOP full language support

I moduli di Spring

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.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsd"></beans>

XML BASED Configuration MetadataAttenzione: l’import degli xsd deve essere eseguito in base alle funzionalità implementate

Istanziare i beans

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

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 >

… 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.

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.

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>

Constructor Argument index

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

Best practise

E’ preferibile l’utilizzo di “setter injection”Alcune proprietà possono essere opzionaliIl risultato sarà un xml più snello e controllabileSi evitano dipendenze circolariIn alcuni casi, es. codice legacy, potrebbe essere opportuno o necessario l’uso di “constructor injection”

Property values

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

Laboratorio

Esempio bean-refEsempio Costructor Inection

Una Enterprise Application tipica

Domain model

Class

Attributes

attributes

Class

Attributes

attributes

Class

Attributes

attributes

Data access

DAOs/Repository

Business Services

Service 1

Service 2

Service 3

Web Tier

Action A

Action B

Action C

Costruiamola con Spring

Costruzione di POJO per il domain modelCostruzione di DAO per Data AccessCostruzione di Servizi Gestione delle transazioniEsempio utilizzo Hibernate

Laboratorio

Applicazione gestione corsi

Aspect Oriented Programming

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

Spring AOP

framework proxy-basedJava + ‘weaver’Soluzione AOP più utilizzataIntegrata con Spring containerLimitato uso (execution) dei join pointsSufficiente nel 90% dei casi

Weaving : linking aspects with other application types or objects to create an advised object. This can be doneat 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.

L’unità base di un aspetto

AspectAttributes

Behaviours

WHERE (pointcuts)

WHAT (advice)

use

access

Pointcuts

E’ un’espressione con una sintassi simile a Regular ExpressionsSpring NON valida l’espressioneDefinisce, in Spring, quando viene eseguito un metodo con una determinata signature

Join points (method execution)

Un ‘method execution’ join point si verifica quando viene eseguito un metodoLe informazioni che possono essere usate per il join point:

Nome del metodoTipo parametroTipo restituitoEccezione dichiarata

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:BeforeAfterAfter returningAfter throwingAround

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

After Advice

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

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.

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.

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

Proxy system

Le classi devono implementare un’interfaceIl file di configurazione deve contenere il tag:

<aop:aspectj-autoproxy/>Attenzione all’uso del puntatore ‘this’

Si riferisce al proxy Si riferisce all’advice

Ancora sul transaction manager

La versione precedente di Spring (2.0) utilizzava un proxy per la gestione delle transazioniLa versione attuale utilizza un advice bean

Potenzialità di AOP

Possibilità di modellare, all’interno di un sistema:TransactionsSecurityRemotingTracingProfilingFailure handlingManagementCaching….