Introduzione a Spring - JugGenova 18/09/07 di Corrado e Carlo

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

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

3. 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 :-)

4. Overview

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

6. Inversion of Control (IoC)
The “Hollywood Principle”
Don't call me, I'll call you
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
Lo dicevano i
produttori di
Hollywood agli
aspiranti attori
:-)

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

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

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

10. Esempio
Eclipse...

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

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

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

14. 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)

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

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

17. Esempio
Eclipse...

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

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

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

21. 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();
}
}

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

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

24. 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);

25. 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()

26. 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)

27. 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/

28. Q&A
GRAZIE per l'attenzione!