Introduzione a Spring
JUG Genova Meeting
18/09/2007
Corrado Alesso – Carlo Bonamico

Cos'è?
Spring è un framework che semplifica
lo sviluppo di applicazioni Java
e in particolare J2EE
promuovendo l'uso di best practice di design

secondo un modello di sviluppo POJO-based

Plain Old Java Object

Storia
Rod Johnson scrive, nel 2002, il libro Expert One-on-
One J2EE Design and Development in cui vengono
delineati i limiti di J2EE e proposti pattern architetturali
che sono alla base di Spring
Il progetto Spring nasce dai sorgenti descritti nel libro e
diventa un progetto Open Source ufficialmente nel
2003 su SourceForge
Spring 2.0 esce nel 2006
attualmente in attesa di Spring 2.5 :-)

Overview

Principi Architetturali
Inversion of Control

è il framework che chiama il mio codice e non
−
viceversa
Dependency Injection

il singolo oggetto dichiara le proprie dipendenze,
−
ma non le istanzia/cerca
è il framework che le risolve, istanzia e ritorna
−

Inversion of Control (IoC)
The “Hollywood Principle”
Lo dicevano i
produttori di
Hollywood agli
Don't call me, I'll call you aspiranti attori
:-)
Ribaltamento di responsabilita' tra due entità
L'entità più astratta invoca i metodi
dell’entità più concreta
Esempio: in un GUI framework, è la classe Button che crea gli
eventi e chiama gli event handler definiti da me per
notificarglieli, non sono le mie classi che chiedono a Button
se ci sono eventi da gestire

Realizzare un’ architettura
modulare: problemi
Gli oggetti dipendono gli uni dagli altri

ad esempio un servizio A ha bisogno di un servizio B
−
In prima battuta, posso disaccoppiarli definendo

un'interfaccia IB che B implementa
scrivo il codice di A in funzione di IB invece che di B
−
Problema: da qualche parte, qualcuno deve fare

IB b = new B();
−
Chi lo fa?

Inversion of Control
e gestione delle dipendenze
Approccio del newbie

Scrivere wiring code (difficilmente manutenibile) per rendere
disponibili gli oggetti tra loro
● A crea B
Approccio tradizionale

“Framework/Container, dammi l'oggetto X, mi serve”
● A chiede B al container (es. JNDI)
● A chiede B ad un singleton/registry
IoC

“Applicazione, tieni l'oggetto X, ti serve”
● Il container crea B e lo passa ad A

Dependency Injection (DI)
Dependency Injection e' un tipo particolare di IoC
per cui le dipendenze di un oggetto (i suoi
collaboratori) vengono “iniettate” nell'istanza
automaticamente e a runtime, utilizzando costrutti
Java standard
 Costruttori
 Metodi
 Setter di JavaBean properties
E' il framework a chiamare il codice,
non viceversa

Esempio
Eclipse...

Vantaggi
Non è più necessario scrivere wiring code

è più facile riconfigurare l'applicazione
−
I componenti sono più semplici da scrivere,

manutenere e riutilizzare
Il mio codice non dipende dal framework

posso riutilizzare le stesse classi in altri contesti
−
posso testarle più facilmente, anche perché sono meno
−
accoppiate tra loro

BeanFactory
Il modulo principale di Spring, su cui si basa
l'intero framework, è un IoC container che
implementa DI: la BeanFactory
Le dipendenze vengono specificate tramite:
XML

 Annotazioni
 Codice Java

Esempio di configurazione
<beans>
<bean id=\"myDataSource\"
class=\"org.apache.commons.dbcp.BasicDataSource\"
destroy-method=\"close\">
<property name=\"driverClassName\"
value=\"com.mysql.jdbc.Driver\" />
</bean>
<bean id=\"myDAO\" class=\"example.MyDAO\">
<property name=\"dataSource\" ref=\"myDataSource\" />
</bean>
<bean id=\"myBusinessObject\"
class=\"example.MyBusinessObject\">
<property name=\"dataAccessObject\" ref=\"myDAO\" />
<property name=\"exampleParam\"><value>10</value></property>
<property name=\"list\">
<list>
<value>10</value><value>15</value>
</list>
</property>
</bean>
</beans>

Bean Factory
Lo sviluppatore non e' tenuto a interagire
direttamente con i meccanismi di IoC/DI
Puo' interfacciarsi alla BeanFactory, che
permette di ottenere referenze a componenti
già configurati e relazionati ai loro eventuali
collaboratori (configurati a loro volta)

ApplicationContext
Una versione più sofisticata della BeanFactory

(la estende...) con servizi aggiuntivi
accesso trasparente a risorse (URL, file, classpath)
−
Può inizializzare il context

da filesystem
−
da file presente nel classpath (utile se dentro jar)
−
a mano
−
Esistono ApplicationContext specializzati per

diverse tipologie di applicazioni
es. WebApplicationContext
−

Spring solo per Java EE?
Spring non dipende da nessuna API Java EE,
pertanto e' utilizzabile sia all'interno che
all'esterno di un Application Server

Esempio
Eclipse...

Gli altri moduli di Spring
DAO
ORM
AOP (vedi presentazione di Fabio)
J2EE
Web (MVC)

Spring DAO: Problemi di JDBC
Codice ripetitivo e verboso

necessario per gestire correttamente
ResultSet, Statement e Connection
e garantire la chiusura delle connessioni
in caso di eccezioni
(fonte di errori e inefficenze)
SQLException che significa tutto e niente

ingloba situazioni di errore molto diverse

Spring DAO
Spring risolve i problemi citati
(con overhead trascurabile)
Fornisce oggetti JdbcTemplate che

incapsulano il codice ripetitivo come il corretto
rilascio delle risorse
JdbcTemplate template = new JdbcTemplate(dataSource);
List names = template.query(\"SELECT name FROM user\");
Rimappa le SQLException in una gerarchia

di (unchecked) eccezioni significative

ORM – Hibernate senza Spring
public List findCityByCountry (String country) throws Exception
{
SessionFactory sessionFactory = ...
Session s = null;
try {
s = sessionFactory.openSession();
Query q = s.createQuery(
“select City c from City where c.country = :country”);
q.setString(“country”, country);
return q.list();
} catch (Exception e)
{ ...
} finally {
s.close();
}
}

ORM – Hibernate con Spring
public List findCityByCountry (String country) {
return getHibernateTemplate().find(
“from City where country = :country”, “country”, country);
}

Testing
Spring facilita il testing attraverso tre meccanismi
disaccoppiando le classi, rende più semplice la scrittura
−
degli unit test
eventuale uso di Mock Object

fornendo dependency injection trasparente ai test di
−
integrazione
classe AbstractDependencyInjectionSpringContextTests

fornendo meccanismo di transaction management di test
−
che simula le transazioni su un DB annullandole alla fine
di ogni test
classe AbstractTransactionalDataSourceSpringContextTests


AbstractDependencyInjectionSpringContextTests
Ridefinisco il metodo

protected String[] getConfigLocations() {
return new String[]
{\"classpath:testApplicationContext.xml\"};
}
Utilizzo la variabile membro applicationContext per

accedere alla BeanFactory
applicationContext.getBean(\"aDao\");
Oppure dichiaro variabili membro protected che si

chiamano come i bean che mi servono
popolate automaticamente da Spring in fase di
−
inizializzazione del test se nel costruttore invoco
setPopulateProtectedVariables(true);

AbstractTransactionalDataSourceSpringContextTests
Ogni metodo di test viene eseguito in una

transazione
inizializzata durante la setUp()
−
Alla fine del metodo, la transazione viene

automaticamente annullata
per riportare il DB nello stato originale
−
questo a meno che non chiamo il metodo
−
setComplete()

Spring - punti di forza
Codice piu' modulare e sintetico

I molti moduli di Spring possono essere usati

separatamente, decidendo incrementalmente
quali e quando
L'applicazione risulta riconfigurabile senza

bisogno di ricompilare
(supporto anche per bean scritti in scripting languages)

Riferimenti
Spring
http://www.springframework.org
Il principale articolo su Dependency Injection
http://www.martinfowler.com/articles/injection.html
Introduction to Spring
http://www.theserverside.com/tt/articles/article.tss?l=SpringFramework
Link alla presentazione di Fabio Bonfante su AOP
http://www.slideshare.net/bfx81/introducin-aop
Spring plugin per Eclipse
http://springide.org/blog/

Q&A
GRAZIE per l'attenzione!