JUG Ancona Italy Spring Framework Andrea Del Bene Jug Marche
Spring: perché e nato e perché lo voglio imparare? Quando si decide di investire in un nuova tecnologia è indispensabile capire il valore aggiunto che essa apporta al nostro lavoro quotidiano e i suoi elementi di innovazione rispetto le altre soluzioni esistenti. Spring rappresenta una serie di strumenti per l'ambito Enterprise, ma perché è diventato così popolare? Come ha fatto del semplice codice scritto a sussidio di un testo informatico a mutare ed influenzare l'universo dello sviluppo Java Enterprise? Forse prima è meglio definire bene cos'è la programmazione Enterprise :-)...
Introduzione: programmazione Enterprise Con applicazioni Enterprise definiamo tutti i programmi con forti vincoli operativi (mission critical): multiutenza, consistenza dei dati, tolleranza ai guasti, garanzia di servizio, distribuzione del servizio, ecc... Sun da anni si interessa alla programmazione Enterprise e con Java (in particolare gli EJB) ha costituito un ombrello di tecnologie e specifiche per l'implementazione delle applicazioni enterprise. Es: RMI è una specifica per la distribuzione degli oggetti, JDBC è la specifica per l'accesso a database relazionali, JSP e Servlet sono specifiche per usare i servizi Java via web.
Gli Application Server Sun si limita a definire le specifiche dei servizi Enterprise senza fornirne le implementazioni. Le implementazioni le forniscono i vari vendor, proponendo applicazioni container che contengono i pezzi (le classi!) delle nostre applicazioni Java garantendo che rispettino i requisiti Enterprise (scalabilità, accesso sicuro ai dati, distribuzione, ecc...) Bene allora! Tutti contenti! O no...!!???
Dove falliscono gli Application Server? Noi dovremmo potere mettere le classi della nostra applicazione negli A.S. e magicamente dovrebbero acquisire le proprietà Enterprise... Peccato che per fare ciò noi dobbiamo conformare le nostre classi alle regole di accettazione degli A.S., diverse per giunta da vendor a vendor!!!! Le nostre classi devono implementare interfacce, seguire le dinamiche obbligatorie di ogni A.S., insomma usare un A.S. implica.....influenzare l'architettura della nostra applicazione per soddisfare i bisogni dell'a.s.: il progettista diventa succube della tecnologia (e dei suoi capricci!)
Es:elucubrazioni da A.S. Con JBoss voglio esporre una classe con un metodo che converte da lire ad euro...allora l'a.s. ha bisogno di: La classe concreta ConvertitoreBean Un'interfaccia locale per la classe ConvertitoreHome Un'interfaccia remota per la classe Convertitore Un file di manifesto XML Un XML per il deployment...(questo solo per la parte server!) Cacchio, chissà perché era considerato troppo complesso?
Aria primaverile... Spring è il frutto del lavoro di un signore, Rod Johnson, che pur di non usare questi strumenti complessi se ne costruiti di più semplici...poi li ha resi open source! Spring non solo vuole evitare la complessità appena vista ma vuole dare la possibilità di scegliere quali caratteristiche Enterprise adottare, senza prendersele tutte per forza. Di conseguenza Spring promuove la progettazione di software fortemente modulare, con classi il più indipendenti possibili le une dalle altre: classi come mattoncini Lego componibili ed intercambiabili.
Aria primaverile... Ma Spring non offre solo maggiore semplicità. Offre anche tante classi pronte all'uso per le esigenze di tutti i giorni: connessione al db, politiche di sicurezza, ecc... Tutte queste utilità oggi sono racchiuse sotto il nome di Spring Portfolio
Ma cosa NON è Spring!? Anche se Spring è un'alternativa agli A.S. NON è un A.S. e non è un'applicazione che si lancia e si stoppa come JBoss o Tomcat, non è un'applicazione che vive di vita propria. Spring è semplicemente un insieme di jar, una libreria (vastissima!) che ci offre determinate funzionalità e vive sempre dentro la nostra applicazione (come Hibernate o Struts o la libreria che più vi piace).
Cos'è Spring per noi programmatori Spring, tra le altre cose, è sicuramente un container, ossia una terza "entità" a cui chiediamo di creare e restituirci delle istanze di determinate classi. Come gli A.S. anche Spring ha un contesto che conitene (da cui container) delle istanze di classe che noi richiederemo. Es: mioobj = (MioObj) ctx.getbean("mioobj") In questo caso abbiamo usato ctx per ottenere mioobj.
Riassumiamo: il rapporto tra Spring e i nostri programmi Classe1 Classe2... ClasseN. 3 3 3 <beans>... </beans> 2 Spring 1 4 Applicazione generica La nostra applicazione invece che creare istanze delle classi (Classe1,Classe2,...ClasseN), le chiederà a Spring che farà da intermediario ( ossia container) compiendo i seguenti passi: 1)il nostro programma crea una nuova istanza di classe contesto Spring indicandole il file xml da caricare per costruire i nostri bean. 2)Il contesto carica il file xml contente le istruzioni su quali istanze caricare in esso 3)In base al file xml letto il contesto crea una sorta di indice delle istanze che può restituire (istanze di Classe1, Classe2,...ClasseN e così via). 4)la nostra applicazione chiede al contesto una delle istanze configurate.
Il file di contesto Il segreto in spring è come configurare il contesto, ossia: quali istanze metterci dentro in che relazione sono le istanze tra loro Ci sono diversi modi per configurare il contesto in Spring (annotazioni, metadati, ecc...). Il più diffuso di tutti è usare un file xml. <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="persona" class="org.jugancona.jug4tenda.domain.persona"> </bean> </beans>
Struttura XML del contesto. <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="persona" class="org.jugancona.jug4tenda.domain.persona"> </bean> </beans> Come possiamo vedere il tag radice del file è <beans>. Come si intuisce dal nome all'interno di esso vi saranno le dichiarazioni dei bean che vogliamo inserire nel contesto. La dichiarazione di un bean è contenuta nel tag <bean>. Il punto di partenza della dichiarazione di un bean è l'attributo class del tag bean. Con questo attributo indichiamo di quale classe sarà istanza il bean che stiamo dichiarando. Es: in sostanza scrivere class="org.jug4tenda.domain.persona" equivale a scrivere l'istruzione new Persona();
Struttura XML del contesto - 2. <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="persona" class="org.jugancona.jug4tenda.domain.persona"> </bean> </beans> Un altro attributo usatissimo nel tag <bean> è id. id è una stringa che rappresenterà l'identificativo che useremo per recuperare tramite Spring il bean che stiamo costruendo. Il recupero del bean viene fatto il metodo getbean(idbean) esposto dal contesto di Spring. Es: getbean( persona ) ci farà recuperare l'istanza della classe Persona configurata nel file xml ed identificata dalla stringa persona. Da notare che getbean(...) restituisce un tipo generico Object, e occorrerà quindi fare un cast al tipo voluto per utilizzare l'istanza ottenuta. Es: (Persona)getBean( persona )
Esploriamo Spring con JUnit Ora passiamo al codice della classe da test fornita con il progetto. Si trova sotto il package org.jugancona.jug4tenda.tes e il codice è il seguente:
Esploriamo Spring con JUnit
Il tag <property> La sintassi per valorizzare gli attributi primitivi di un'istanza è la seguente: <beans>... <bean id="idbean" class="classebean">... <property name="propertyname">avalue</property>... </bean>...... <property name="cognome" value="rossi" />... La classe per essere valorizzata deve avere i setter pubblici corrispondenti! Es: setcognome(... )
Le proprietà complesse In questi casi (comunissimi!) la proprietà è valorizzata referenziando un altro bean configurato nel file xml tramite la seguente sintassi (in grassetto): <beans>... <bean id="persona" class="org.jugancona.jug4tenda.domain.persona">... <bean id="indirizzo" class="org.jugancona.jug4tenda.domain.indirizzo">... <property name="ospite" ref="persona"/> </bean> </beans>
L'Inversion of Control Con Spring è il framework che si occupa della costruzione delle istanze che vogliamo e non le istanze stesse! Le new le fa il framework e non il progrmammatore. E' proprio questo l'inversione di controllo! Es: pensate all'installazione delle applicazioni Windows: devono fare tutto da sole, c'è un exe che si installa nel S.O. Ora pensate a Linux: IoC! Qui è il S.O. Che installa le applicazioni e se ne prende cura.
Dependency Injection In realtà di DI ne abbiamo parlato sino ad ora dicendo che nel modello IoC di Spring è il container di Spring che di occupa di soddisfare le dipenze (DI appunto...) delle istanze "legandole" insieme. La DI non è altro che la dipendenza tra due entità impostata nel file di configurazione xml. In altre parole la DI sono i vari ref di un'istanza ad un'altra...
Link utili Spring framework (http://www.springframework.org/): è il sito ufficiale dove scaricare Spring e aggiornarsi sulle ultime novità del monso Spring. Blog Interface21 (http://blog.interface21.com/): è il blog dei creatori di Spring. Si possono trovare idee e spunti di utilizzo del framework. SpringIDE (http://springide.org/): strumento indispensabile per lavorare con Spring ed Eclipse.
Domande...?
JUG Ancona Italy Grazie! Andrea Del Bene JUG Marche - www.jugancona.it