Spring Roo è un Web-RAD per il mondo Java EE, è basato interamente su Spring e permette di azzerare i tempi di start-up di un progetto. Inoltre Roo è facilmente estendibile: è basato su add-ons che possono essere implementati da chiunque voglia facilitare l’uso della propria libreria/framework in un progetto Roo.

In questo articolo parleremo di Spring Roo, uno strumento estremamente utile per tutti gli sviluppatori Java EE che basano le loro applicazioni sulla famiglia di prodotti SpringSource.

RAD e Spring Roo

Spring Roo è uno strumento RAD basato sul web che permette uno sviluppo rapido di applicazioni Java EE appoggiate allo SpringFramework (web-based RAD: Rapid Application Development tool per il Web [1]). RAD è un concetto per cui i prodotti possono essere sviluppati velocemente (e quindi con un’alta produttività) attraverso:

• raccolta di requisiti tramite workshop;
• prototipazione, con test reiterati più volte sul disegno;
• riuso dei componenti software;
• schedule rigido che permette di posticipare miglioramenti del design;
• comunicazione tra team e poco formalismo.

In generale gli strumenti RAD permettono un:

• prototyping veloce, che può essere anche reiterato più volte;
• test automatico (e continuo) su tutte le componenti software;
• riuso dei componenti software.

Spring Roo è basato anche sul principio “Convention over Configuration”[2]; questo vuol dire che lo sviluppatore deve specificare solamente gli aspetti “non convenzionali” dell’applicazione, lasciando gli aspetti più “convenzionali” a Roo che sa gestirli al meglio.

Per esempio, supponiamo di avere una tabella users sul database; allora il corrispondente entity bean si chiamerà per convenzione Users, e questa assunzione viene fatta da Roo senza alcuna specifica. Viceversa se volessimo deviare da questa convenzione, dovremmo istruire Roo per modificare il suo comportamento per quella determinata classe.

Potenzialità

Quindi Roo è uno strumento RAD che permette di:

• generare automaticamente un progetto Java EE basato su Spring;
• effettuare il reverse-engineering dal DB per ottenere, gli entity beans, le funzioni CRUD, le funzioni di ricerca;
• generare automaticamente i test di verifica;
• generare automaticamente un CRUD web basato su JSP (o anche JSF, GWT).

In pratica tutto questo ci consente di:

• poter creare e ricreare un progetto web Java EE partendo da un database in meno di 10 minuti;
• il progetto risultante (possibilmente modulare) è basato su Maven, un tool collaborativo di gestione dei progetti; il layout dei sorgenti è quindi basato sulle convenzioni Maven (da notare che anche Maven è basato sul principio “convention over configuration”);
• poter creare un prototipo in pochissimo tempo e testarlo in tutte le sue parti;
• riutilizzare molte componenti software open source (Spring, Hibernate, GWT, etc…) in maniera “convenzionale”, cioè in modo rigido e ben compreso da tutti.

Da notare che Roo non è dotato di un run time environment: di conseguenza non entra in gioco quando il programma è in esecuzione.

Queste sono alcune delle caratteristiche principali di Roo. Nel mondo web, Spring Roo è solo l’ultimo arrivato tra i RAD [3] che permettono di automatizzare la creazione e stesura di un web-CRUD. Altri strumenti di questo tipo sono: Grails, Ruby On Rails, AppFuse, Seam Project Generation, solo per citarne alcuni. Quindi, perche’ usare proprio Spring Roo? La differenza che sta tra Roo e gli altri tool risiede principalmente nel fatto che sia basato sul framework Spring; di conseguenza Roo è ideale per chi utilizza la suite Spring per i propri progetti Java EE. Un ulteriore punto di forza di Roo è che non interferisce in alcun modo durante l’esecuzione del programma risultante: infatti tutto il codice è generato da Roo a tempo di compilazione, e non a tempo di esecuzione. In ultimo, la comunità è in costante crescita.

Struttura di un progetto basato su Spring Roo

Un progetto basato su Spring Roo ha una struttura rigida e ben definita; prima di tutto si tratta di un progetto basato su Maven, possibilmente modulare, inoltre è multi-layer e orientato a servizi.

Un tipico progetto multi-layer orientato a servizi è formato dai seguenti layer:

1. Persistence Layer: è il layer che accede al/ai database; inoltre i database a cui si accede possono essere di natura diversa: SQL o anche no-SQL;
2. Service Layer: è il layer in cui si implementano i servizi business del progetto Java EE;
3. Consumer Layer: è il layer dove i servizi esposti nel layer precedente vengono utilizzati da delle pagine web (JSP, JSF, GWT…).

La figura 1 descrive un tipico progetto Java EE multi-layer:

Figura 1 – La struttura multi strato di un tipico progetto Java EE in Spring Roo

Persistence Layer

Tramite Spring Roo (dalla versione 1.2) è possibile scegliere tra tre tipi diversi di supporto ai database:

1. Entity Beans con Active Record;
2. Entity Beans con repository JPA (senza Active Record);
3. MongoDB.

Active Record

L’opzione Active Record è un nuovo pattern di implementazione dei servizi CRUD di base: sostanzialemente un “record attivo” ha la possibilità di effettuare tutte le operazioni CRUD su se stesso senza ausilio di un repository (JPA repository). Il repository JPA funziona come una classe delegate che si occupa di creare/cancellare/ricercare uno o più record sulla tabella.

JPA Repository

Questa opzione è “più tradizionale” [4]; permette di generare degli entity bean in maniera “classica” senza le funzionalità di CRUD implementate al proprio interno. Al contrario, Spring Roo genererà un servizio JpaRepository per effettuare il CRUD sull’Entity.

MongoDB

La famiglia di prodotti Spring annovera al suo interno la libreria Spring Data [5], che è un “ombrello” che contiene diversi specific progetti di accesso a data storage di diverso tipo. Tramite Spring Data è possibile utilizzare tecniche diverse quali JDBC o JPA per accedere a database SQL, oppure è possibile accedere a MongoDB [6], Hadoop o anche NEO4J.

Service Layer

Lo strato dei servizi è stato introdotto in Spring Roo per dare l’opportunità agli sviluppatori di avere un proprio layer dove implementare le proprie logiche di business (per esempio è in questo layer che è indicato implementare un servizio che esponga metodi via SOAP).

Consumer Layer

L’ultimo layer è quello utilizzato per esportare le funzionalità del progetto via web. L’insieme di tecnologie web a nostra disposizione è principalmente il seguente:

• JSP: Spring Roo è stato sviluppato principalmente per supportare questa tecnologia, quindi le JSP (con utilizzo di Spring MVC e Apache Tiles) sono supportate in maniera ottimale;
• JSF: sono state introdotte di recente, per ora è supportata solo la libreria PrimeFaces, ma comunque in generale il supporto JSF appare ancora immaturo;
• GWT: anche per GWT vale lo stesso discorso fatto per le JSP: il supporto dato è sicuramente soddisfacente.
• Flex: anche la tecnologia Adobe Flex è supportata tramite il progetto Spring-Flex.

Inoltre è da annoverare anche il supporto a Vaadin (fornito dagli sviluppatori di Vaadin stessi grazie alle insistenze della propria comunità di sviluppatori), che permette di integrare la loro tecnologia web (basata su GWT) con Spring Roo e quindi con il mondo Spring [7].

Primi passi con Spring Roo

Spring Roo è una shell interattiva da utilizzare per dare dei comandi di creazione e configurazione del progetto [8]. La shell ha un notevole sistema di help che permette di:

• visualizzare tutti i comandi disponibili;
• suggerire il comando più appropriato da dare;
• visualizzare l’help per ogni comando;
• suggerire l’installazione di add-ons per effettuare alcune operazioni (ad esempio, installazione di driver per database forniti da terze parti).

La shell di Roo può anche comportarsi in maniera non interattiva: è possibile dare uno script di comandi e Roo li esegue senza intervento del programmatore. Questa opportunità è molto utile per poter rigenerare dei progetti velocemente: la shell Roo scrive su un file di log (roo.log) tutti i comandi che ha eseguito nella sessione; quindi se volessimo definire un nostro progetto in funzione di uno script Roo (in modo tale da poterlo rigenerare su macchine diverse e/o anche correggere alcuni errori che abbiamo fatto dando a Roo dei comandi sbagliati) è possibile farlo velocemente (in meno di un minuto un progetto viene completamente rigenerato).

La Shell di Roo

Prima di iniziare a creare il nostro progetto, settiamo la variabile di ambiente ROO_OPTS in modo tale da avere la sintassi colorata:

$ export ROO_OPTS="-Droo.bright=true"    // Linux or Apple
$ set ROO_OPTS="-Droo.bright=true"       // Windows users

Creiamo ora un piccolo progetto Roo. Prima di tutto occorre creare una directory vuota, il nome della directory è il nome del progetto. Creiamo quindi il progetto sample e lanciamo il comando roo.sh (o roo.bat per Windows) da dentro questa directory:

$ mkdir sample
$ cd sample/
$ roo.sh
    ____  ____  ____ 
   / __ / __ / __ 
  / /_/ / / / / / / /
 / _, _/ /_/ / /_/ / 
/_/ |_|\____/\____/    1.2.1.RELEASE [rev 6eae723]
 
Welcome to Spring Roo. For assistance press TAB
or type "hint" then hit ENTER.
@ibmkhd: Introducing Spring Roo,
Part 4: Rapid application development in cloud
with Spring Roo and Cloud Foundry: Rapid
http://t.co/eRT1bE6H
roo>

Alla partenza della sua shell, Roo visualizza il messaggio di benvenuto e anche (se disponibili) le ultime notizie su Spring Roo o in generale sul mondo Spring (@SpringRoo su Twitter [9]).

Il primo comando da dare è hint:

roo> hint
Welcome to Roo! We hope you enjoy your stay!
 
Before you can use many features of Roo,
you need to start a new project.
 
To do this, type ‘project' (without the quotes)
and then hit TAB.
 
Enter a --topLevelPackage like ‘com.mycompany.projectname' (no quotes).
When yoùve finished completing your --topLevelPackage, press ENTER.
Your new project will then be created
in the current working directory.
 
Note that Roo frequently allows the use of TAB,
so press TAB regularly. 
Once your project is created, type ‘hint'
and ENTER for the next suggestion. 
You're also welcome to visit
http://forum.springframework.org for Roo help.

Come si può vedere a questo stadio del progetto (ancora non creato!) hint ci suggerisce il primo comando da dare, che è project con il parametro –topLevelPackage che specifica il pacchetto di progetto:

roo> project --topLevelPackage  org.moka.sample

Suggerimento dei comandi

Da notare che nella shell di Roo funziona molto bene il suggerimento di comandi e parametri da dare: basta premere TAB per visualizzare i suggerimenti corretti.

roo> project --topLevelPackage  org.moka.sample
Created ROOT/pom.xml
Created SRC_MAIN_RESOURCES
Created SRC_MAIN_RESOURCES/log4j.properties
Created SPRING_CONFIG_ROOT
Created SPRING_CONFIG_ROOT/applicationContext.xml

La risposta di Roo è quella di creare un progetto Maven (pom.xml), di definire il file per log4j e il file di configurazione per Spring (applicationContext.xml) posizionato dentro la directory di configurazione:

sample/src/main/resources/META-INF/spring.

Questo aspetto è molto importante e da non sottovalutare: usando Roo utilizziamo un modo condiviso di gestire i file di risorse , quali log4j.properties e applicationContext.xml (Convention over Configuration): in questa maniera il nostro progetto sarà facilmente comprensibile anche da altri sviluppatori, senza alcun intervento da parte nostra.

L’utilizzo di Maven, inoltre, garantisce la portabilità del progetto Java: un progetto Maven è utilizzabile in qualsiasi IDE (Netbeans, Eclipse, IntelliJ IDEA) e non memorizza alcun path assoluto delle librerie di terze parti: esse vengno tutte scaricate correttamente dal loro sito di origine con le versioni e le dipendenze correttamente specificate.

A questo punto, se riproviamo a eseguire il comando hint otterremo che:

roo> hint
Roo requires the installation of a persistence configuration,
for example, JPA or MongoDB.
 
For JPA, type ‘jpa setup' and then hit TAB three times.
We suggest you type ‘H' then TAB to complete "HIBERNATE".
After the --provider, press TAB twice for database choices.
For testing purposes, type (or TAB) HYPERSONIC_IN_MEMORY.
If you press TAB again, yoùll see there are no more options.
As such, yoùre ready to press ENTER to execute the command.
 
Once JPA is installed, type ‘hint' and ENTER for the next suggestion.
 
Similarly, for MongoDB persistence, type ‘mongo setup' and ENTER.

Roo ci suggerisce di costruire dapprima il layer della persistenza, e ci suggerisce due possibili scelte: uso di JPA oppure uso di MongoDB (ma non sono scelte esclusive: in un solo layer di persistenza possiamo utilizzare tutte le risorse che vogliamo).

Proviamo, per esempio, a utilizzare Hibernate su Hypersonic in memoria:

roo> persistence setup --provider HIBERNATE
    --database HYPERSONIC_IN_MEMORY
Created SPRING_CONFIG_ROOT/database.properties
Updated SPRING_CONFIG_ROOT/applicationContext.xml
Created SRC_MAIN_RESOURCES/META-INF/persistence.xml
Updated ROOT/pom.xml [added dependencies ... ]

Adesso Roo ha aggiornato il file di build (nel file pom.xml sono state aggiunte le dipendenze alle librerie) e ha aggiunto i file di proprietà per accedere al DB.

Creiamo gli entity bean

A questo punto possiamo creare i nostri entity beans dando dei comandi alla shell. Creiamo un nostro entity bean chiamato MokaUser con le proprietà: nome, cognome, email, eta. Ecco i comandi da dare:

~.User roo> entity jpa --class org.moka.sample.MokaUser --testAutomatically
~.MokaUser roo> field string --fieldName name --notNull --sizeMin  2
~.MokaUser roo> field string --fieldName surname  --notNull --sizeMin  2
~.MokaUser roo> field string --fieldName email
    --notNull --regexp ^([0-9a-zA-Z]([-.w]*[0-9a-zA-Z])
    *@([0-9a-zA-Z][-w]*[0-9a-zA-Z].)+[a-zA-Z]{2,9})$
~.MokaUser roo> field number --fieldName age --type int

Supporto di Eclipse per Roo

A questo punto proviamo a compilare il tutto e a creare un progetto per Eclipse:

~.MokaUser roo> perform package
~.MokaUser roo> perform eclipse

Adesso apriamo il tool STS (Eclipse distribuito da SpringSource) e importiamo il progetto sample come progetto Maven già esistente, la shell Roo si aprirà automaticamente dentro Eclipse.

Figura 2 – La shell Roo.

Finiamo di importare il progetto sample.

Figura 3 – Importazione del progetto sample.

Ed ecco in figura 4 il progetto appena importato dentro Eclipse.

Figura 4 – Il progetto è stato importato dentro Eclipse.

Come si può vedere dall’albero di navigazione, abbiamo creato un progetto Maven con file di tipo java, properties e xml. Inoltre osserviamo che il nostro entity MokaUser è taggato con i tipi:

• @RooJavaBean: vuol dire che questa classe è un entity bean;
• @RooToString: vuol dire che Roo automaticamente creerà il metodo ToString() per questa classe, visualizzando tutti i campi di questo oggetto;
• @RooJpaActiveRecord: vuol dire che Roo ha automaticamente scelto per noi il pattern Active Record per questo bean; se non vogliamo utilizzarlo, usiamo il flag -noactiverecord.

Spring Roo e AspectJ

Notiamo subito che mancano completamente i metodi della classe. Dove sono finiti e come è possibile che un entity bean non abbia metodi getter e setter? A questo punto Roo sembra un framework che crea classi e metodi e li rende inaccessibili all’utente.

Ho già detto all’inizio dell’articolo che Roo non è dotato di un runtime environment, quindi a runtime non entra in gioco: di conseguenza tutto il codice deve per forza essere generato a tempo di compilazione.

In realtà tutto il codice “mancante” viene generato a tempo di compilazione da AspectJ [10] utilizzando le inter-type declarations, chiamate anche mix-ins; si tratta di file sorgenti che vengono compilati da AspectJ e che generano il codice mancante.

Il codice “nascosto” da Roo è solamente scritto sotto forma di regole comprese dal compilatore AspectJ mediante le quali genera i metodi richiesti. Questo codice (creato automaticamente) è la parte più noiosa e ripetitiva, quindi è bene che venga nascosto e generato da un RAD quando si compila. In ogni caso è possibile inibire Roo dal creare questi metodi per noi: basta ridefinirli correttamente nel file .java; Roo non sovrascrive i metodi che trova nei .java con quelli compilati da AspectJ. Se effettuate il listing dei file nella cartella del progetto vedrete la seguente cosa:

$ cd sample/src/main/java/org/moka/sample
# ls
MokaUser.java
MokaUser_Roo_Configurable.aj
MokaUser_Roo_JavaBean.aj
MokaUser_Roo_Jpa_ActiveRecord.aj
MokaUser_Roo_Jpa_Entity.aj
MokaUser_Roo_ToString.aj

Come vedete sono stati creati 5 file .aj per un solo entity bean. Ogni file .aj arricchisce MokaUser.java di una qualche funzionalità (è questo il senso dei mix-ins: “mischiare”, o meglio “aggiungere” del codice generato tramite delle regole che seguono la sintassi degli aspetti). Per esempio, abbiamo taggato la classe con @RooToString, il che vuol dire che abbiamo arricchito MokaUser della funzionalità scritta nel file MokaUser_Roo_ToString.aj. Descriviamo ora brevemente il contenuto di questi file.

MokaUser_Roo_ToString

Se andiamo a vedere questo file, capiremo subito quello che sta succedendo:

// WARNING: DO NOT EDIT THIS FILE. THIS FILE IS MANAGED BY SPRING ROO.
// You may push code into the target .java compilation unit if you wish to edit any member(s).
 
package org.moka.sample;
 
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.moka.sample.MokaUser;
 
privileged aspect MokaUser_Roo_ToString {
 
       public String MokaUser.toString() {
 return ReflectionToStringBuilder.toString(this, ToStringStyle.SHORT_PREFIX_STYLE);
       }
}

Come vediamo, questi file non possono essere editati: vengono rigenerati ogni volta, e viene specificato che se i metodi generati da AspectJ mediante questo mixin sono già stati implementati nel .java, allora non verranno aggiunti.

Notiamo subito che Roo ha definito un aspetto che definisce solamente il metodo toString(). Questo metodo è semplicemente ciò che avremmo scritto da noi per stampare a schermo il contenuto di questo entity bean: Roo utilizza l’utility di Apache Commons ReflectionToStringBuilder per stampare tutti i campi del bean. Questo codice, evidentemente noioso e ripetitivo da scrivere, è già pronto all’uso senza alcun intervento da parte del programmatore.

Diamo una occhiata veloce anche ad altri file .aj.

MokaUser_Roo_Jpa_ActiveRecord

// WARNING: DO NOT EDIT THIS FILE. THIS FILE IS MANAGED BY SPRING ROO.
// You may push code into the target .java compilation unit
// if you wish to edit any member(s).
 
package org.moka.sample;
 
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.moka.sample.MokaUser;
import org.springframework.transaction.annotation.Transactional;
 
privileged aspect MokaUser_Roo_Jpa_ActiveRecord {
       @PersistenceContext
       transient EntityManager MokaUser.entityManager;
       public static final EntityManager MokaUser.entityManager() {
             EntityManager em = new MokaUser().entityManager;
             if (em == null) throw new IllegalStateException(
                                  "Entity manager has not been injected 
                                  (is the Spring Aspects JAR configured as
                                  an AJC/AJDT aspects library?)");
             return em;
       }
       public static long MokaUser.countMokaUsers() {
             return entityManager().createQuery("SELECT COUNT(o) FROM MokaUser o",
                                                            Long.class).getSingleResult();
       }
       public static List MokaUser.findAllMokaUsers() {
             return entityManager().createQuery("SELECT o FROM MokaUser o",
                                                            MokaUser.class).getResultList();
       }
       public static MokaUser MokaUser.findMokaUser(Long id) {...}
       public static List MokaUser.findMokaUserEntries(
                                               int firstResult, int maxResults) {...}
       @Transactional
       public void MokaUser.persist() {...}
      
       @Transactional
       public void MokaUser.remove() {...}
      
       @Transactional
       public void MokaUser.flush() {...}
      
       @Transactional
       public void MokaUser.clear() {...}
      
       @Transactional
       public MokaUser MokaUser.merge() {...}   
}

Come si può vedere è qui che Roo ci implementa per noi tutta la logica di aggancio dell’entity bean all’EntityManager. Inoltre implementa per noi anche alcuni finder, come il conto di quanti record abbiamo nel DB, la select per la lista di tutti i record. Infine gli ultimi metodi implementano il CRUD per questa tabella.

Per gli altri aspetti abbiamo:

• MokaUser_Roo_JavaBean: in questo aspetto ci sono tutti i getters e setters che servono.
• MokaUser_Roo_Jpa_Entity: qui abbiamo tutta la gestione della chiave e del versionamento del record.
• MokaUser_Roo_Configurable: qui aggiungiamo l’annotazione di Spring @Configurable per questo entity. In realtà @Configurable può portare dei problemi di performance quando si effettuano delle query che danno molti risultati; se si incontrano problemi di questo tipo, è bene scegliere l’opzione -noActiveRecord.

Roo e la parte servizi

A questo punto occorre creare i servizi basati sugli entity bean. Il comando è:

~.MokaUser roo> service --interface ~.MokaUserService --entity ~.MokaUser
Created SRC_MAIN_JAVA/org/moka/sample/MokaUserService.java
Created SRC_MAIN_JAVA/org/moka/sample/MokaUserServiceImpl.java

In questa maniera abbiamo creato il nostro servizio sull’entity MokaUser. Vediamo adesso il file MokaUserService_Roo_Service.aj per capire che metodi vengono forniti al nostro servizio:

privileged aspect MokaUserService_Roo_Service {
       public abstract long MokaUserService.countAllMokaUsers();
       public abstract void MokaUserService.deleteMokaUser(MokaUser mokaUser);
       public abstract MokaUser MokaUserService.findMokaUser(Long id);
       public abstract List MokaUserService.findAllMokaUsers();
       public abstract List MokaUserService.findMokaUserEntries
                                  (int firstResult, int maxResults);
       public abstract void MokaUserService.saveMokaUser(MokaUser mokaUser);
       public abstract MokaUser MokaUserService.updateMokaUser(MokaUser mokaUser);
}

Come vedete l’interfaccia del servizio fornisce i metodi già implementati dall’ActiveRecord MokaUser, quindi la parte servizi agisce come un delegate verso la parte di persistenza. Tutti gli altri metodi “di business” che vorremo aggiungere al nostro entity MokaUser andranno ad arricchire questo insieme di funzionalità di base.

Come ho già detto all’inizio di questo articolo, è nella parte dei Services che dobbiamo inserire il nostro codice, è qui che dobbiamo implementare i requirements richiesti dal progetto: tutto ciò che è stato fatto da Roo è solo la parte iniziale che si presume sia sempre implementata in qualsiasi progetto Java EE.

Diamo ora una occhiata veloce all’implementazione del servizio:

privileged aspect MokaUserServiceImpl_Roo_Service {
       declare @type: MokaUserServiceImpl: @Service;
       declare @type: MokaUserServiceImpl: @Transactional;
       public long MokaUserServiceImpl.countAllMokaUsers() {
              return MokaUser.countMokaUsers();
       }
       public void MokaUserServiceImpl.deleteMokaUser(MokaUser mokaUser) {
             mokaUser.remove();
       }
       public MokaUser MokaUserServiceImpl.findMokaUser(Long id) {
             return MokaUser.findMokaUser(id);
       }
    ...
}

E vediamo che il Servizio agisce proprio come un delegate sulla parte di persistenza. Da notare che tutti i metodi vengono eseguiti in transazione (la classe viene annotata con @Transactional, e inoltre è un @Service di Spring).

Roo e la parte web

L’ultimo layer da implementare è quello “consumer”, o “web”. Questa parte implica l’integrazione con una o più tecnologie, tra cui JSP, JSF o GWT. In questo esempio utilizzeremo la tecnologia JSP basandoci su Spring MVC. Ecco i comandi usati per generare la parte vista:

~.MokaUser roo> web mvc setup
~.MokaUser roo> web mvc all --package org.moka.sample.mvc

Usciamo ora dalla shell di Roo con il comando quit, ed eseguiamo:

mvn package
mvn tomcat:run

Ed ecco, nelle figure 5-7, il sito web risultante:

Figura 5 – Ecco il sito web risultante dal nostro lavoro.

Figura 6 – Creazione di un nuovo utente.

Figura 7 – Lista di tutti gli utenti creati.

Come si può vedere il sito è perfettamente funzionante, ed è stato creato in pochi minuti.

Conclusioni

Spring Roo è uno strumento molto importante per tutti coloro che utilizzano il framework Spring per implementare i propri progetti Java EE. Il motivo principale per utilizzare Roo è il concetto di Convention over Configuration: tramite Roo potete scrivere un server Java EE basato su Spring seguendo lo “standard di Spring” in maniera rigida. Il vantaggio di tutto ciò è di avere un progetto maggiormente manutenibile e comprensibile da qualsiasi sviluppatore Spring.

Il secondo motivo per usare Spring Roo è la velocità con cui è possibile mettere in piedi da zero un progetto Java EE. Grazie alle innovazioni apportate nella versione 1.2.0 è finalmente possibile fare il reverse engineering da DB e quindi utilizzarlo nel cosidetto “mondo reale”. Spring Roo permette di costruire velocemente lo scheletro di un progetto web risolvendo i tipici problemi da affrontare. Se utilizzate il plugin per le JSP, per esempio, Roo vi configura una servlet login in https, realizzando automaticamente tutto il codice che serve per la parte di autenticazione e autorizzazione.

Infine Roo non rallenta ne’ spreca memoria usata dal programma a run time, semplicemente perche’ gli aspetti vengono risolti a tempo di compilazione da AspectJ, e non a run time.

Riferimenti

[1] Search Software Quality

http://searchsoftwarequality.techtarget.com/definition/rapid-application-development

[2] Wikipedia sul “convention over configuration” principle

http://en.wikipedia.org/wiki/Convention_over_configuration

[3] Wikipedia propone una lista di strumenti RAD

http://en.wikipedia.org/wiki/List_of_rapid_application_development_tools

[4] Wikipedia sul “delegation pattern”, utilizzato per implementare il JpaRepository

http://en.wikipedia.org/wiki/Delegation_pattern

[5] La libreria Spring Data è un progetto che contiene tutti i sotto progetti che permettono l’accesso a data storage di diverso tipo e tramite specifiche tecniche, tra i quali JDBC, JPA, MongoDB, Hadoop, Neo4j, etc.

http://www.springsource.org/spring-data

[6] MongoDB home page

http://www.mongodb.org/

[7] Home page di diverse tecnologie web:

Prime Faces

http://www.primefaces.org/

Vaadin

https://vaadin.com/home

Spring Web Flow: che è una estensione di Spring MVC. Supporta le JSP, JSF e le Portlet.

http://www.springsource.org/spring-web-flow

Progetto Spring-Flex per il supporto ad Adobe Flex

http://www.springsource.org/spring-flex

[8] Sono da leggere una serie di articoli sul sito dell’IBM su Spring Roo, che trattano di come scrivere degli add-ons o di come integrare Roo con Clound Foundry.

Building from source

http://www.ibm.com/developerworks/opensource/library/os-springroo1/index.html

Developing an application with Spring Roo

http://www.ibm.com/developerworks/opensource/library/os-springroo2/index.html

Developing Spring Roo add-ons

http://www.ibm.com/developerworks/opensource/library/os-springroo3/index.html

Rapid application development in cloud with Spring Roo and Cloud Foundry

http://www.ibm.com/developerworks/opensource/library/os-springroo4/index.html

[9] Twitter su Spring Roo

https://twitter.com/#!/SpringRoo

[10] AspectJ sul Web.

AspectJ era un vecchio progetto di Xerox, poi donato a Eclipse

http://www.eclipse.org/aspectj/doc/next/progguide/index.html

È stato il primo progetto Java di implementazione del paradigma degli aspetti (AOP: Aspect Oriented Programming).

http://it.wikipedia.org/wiki/AspectJ

Attualmente il leader del progetto AspectJ è Adrian Colyer, CTO di SpringSource.

http://en.wikipedia.org/wiki/PARC_%28company%29