Introduzione a Grails, il primo progetto

Link copiato negli appunti

Grails è un framework opensource (rilasciato con licenza Apache 2.0) per lo sviluppo di applicazioni web basato sul linguaggio Groovy. Essendo basato su Groovy, e quindi su Java, Grails consente agli sviluppatori Java di riutilizzare il codice Java già sviluppato.

Lo sviluppo di Grails è iniziato nel lontano luglio 2005, si tratta dunque di un progetto maturo, e attualmente la versione stabile è la 1.3.5.

Panoramica

In questo articolo mostreremo le più importanti caratteristiche del framework, senza soffermarci sul linguaggio utilizzato, Groovy, per i cui dettagli rimandiamo all'Introduzione a Groovy già menzionata.

Caratteristiche

Sviluppo rapido: Grails offre dei meccanismi di scaffolding per automatizzare le operazioni CRUD sui dati. Nell'ultimo paragrafo vedremo come abilitare lo scaffolding.
Nessuna configurazione mediante XML: al contrario dei tradizionali ambienti di sviluppo web basati su Java, Grails non utilizza file XML di configurazione, in questo modo noi sviluppatori possiamo concentrarci sullo sviluppo Web vero e proprio piuttosto che sulla modifica di file XML. Grails utilizza invece un insieme di convenzioni che identificano le varie parti della web application: ad esempio, una classe che ha il suffisso "Controller" (scriveremo nell'ultimo paragrafo la classe ContattoController) è un web controller (nel prossimo paragrafo scopriremo come Grails utilizza il paradigma MVC).
Ambiente di sviluppo pronto all'uso: Grails contiene, oltre all'ambiente di sviluppo, anche il Web server per eseguire le applicazioni e un DBMS relazionale per la memorizzazione dei dati. Il web server utilizzato è Jetty, più parco di risorse rispetto a Tomcat. Jetty viene lanciato automaticamente da Grails all'avvio della web application. Il database utilizzato è HyperSQL: DBMS relazionale, interamente scritto in JAVA, che mantiene in memoria le entità dell'applicazione Web che stiamo sviluppando
Framework web dinamico: dato che Grails è basato su Java possiamo utilizzare dei metodi dinamici per le classi domains che usano il framework Hibernate per il mapping tra gli oggetti e il backend relazionale
Framework robusto: Grails utilizza a sua volta il framework Spring, mediante il quale gestisce il disaccoppiamento degli oggetti che compongono l'applicazione, e Hibernate per il mapping tra gli oggetti e la base di dati relazionale, due framework opensource robusti e altamente affidabili

MVC in Grails

Grails è basato sul paradigma Model View Controller che separa la logica, la visualizzazione e la gestione degli oggetti coinvolti.

Domains (model): i domains costituiscono la componente Model di MVC, in particolare un domain è una classe Groovy che rappresenta una entità. Tale classe Groovy contiene le dichiarazioni degli attributi dell'entità che rappresenta, i vincoli sugli attributi, e le relazioni con gli altri domains dell'applicazione.

Esempio: Albero.groovy

class Albero {
  static constraints = {
                         nome(blank:false)
					   }
  String nome
  TipoAlbero tipoAlbero
}

TipoAlbero.groovy

class TipoAlbero {
  static hasMany = [albero:Albero]
  static constraints= {
                        descrizione(blank:false)
					  }
  String descrizione
}

Nell'esempio abbiamo definito due domains: Albero e TipoAlbero. Il primo ha due attributi: nome (che non deve essere vuoto) e tipoAlbero, quest'ultimo è un riferimento al dominio TipoAlbero, cioé tra TipoAlbero e Albero c'è una relazione 1-a-molti, come indicato nella definizione di TipoAlbero.

I domains definiti vengono mappati da Grails, tramite il sottosistema GORM (Grails Object Relational Mapping), in tabelle e relazioni del database di backend utilizzato. GORM utilizza, come abbiamo già accennato, il framework Hibernate per eseguire il mapping. Il database di backend utilizzato da GORM è indicato nel file DataSource.groovy del progetto, di default Grails è configurato per utilizzare il DBMS HyperSQL, incluso in Grails come abbiamo visto nel paragrafo precedente.

I Controllers contengono la logica dell'applicazione web, in particolare contiene i metodi a cui si accede mediante URL. Le URL in Grails infatti hanno la seguente struttura:

http://indirizzo-del-server:8080/nome-applicazione/controller/metodo

Esempio: AlberoController.groovy

class AlberoController {
  def index = {
                render "index di AlberoController"
			  }
  def lista = {
                render "lista degli alberi"
			  }
}

Nell'esempio precedente abbiamo definito un controller con due metodi, index e lista e sono accessibili dal browser mediante le seguenti URL:

http://indirizzo-del-server:8080/nome-applicazione/albero/

http://indirizzo-del-server:8080/nome-applicazione/albero/lista

Al fine di utilizzare i meccanismi di scaffolding è sufficiente inserire, al posto delle definizioni dei metodi, l'istruzione def scaffolding = Albero

che indica a Grails che deve creare tutti i metodi per le operazioni CRUD sul domain Albero (e le relative views).

Views

Le Views si occupano della parte di visualizzazione delle pagine Weeb. Le view sono definite mediante pagine GSP (Groovy Server Pages), che utilizzano come linguaggio di markup le librerie di tag di Grails e codice HTML.

Vediamo alcuni tag GSP di esempio:

Campo	Descrizione
`<g:each>`	Definisce un ciclo
`<g:if>`	Defnisce un blocco di codice eseguito solo se è soddisfatta la condizione indicata
`<g:link>`	Definisce un link nella pagina

Come potete notare, i tag Grails hanno il prefisso "g:". È inoltre possibile espandere la libreria standard di tag, definendo dei tag personalizzati, ma questo esula dallo scopo di questo articolo.

Dopo aver fatto una panoramica generale vediamo come installare l'ambiente di sviluppo di Grails e successivamente svilupperemo un'applicazione di esempio al fine di mettere in pratica i concetti finora affrontati così da fissarli al meglio.

Installazione

Grails necessita di una Java Virtual Machine installata sul sistema (e della variabile di sistema JAVA_HOME). Supponendo di avere già installato e configurato la JVM, procediamo all'installazione di Grails. Scarichiamo la versione binary zip di Grails dal sito del progetto e decomprimiamo il file in una directory a nostra scelta. Una volta ottenuta la cartella grails aggiungiamo la variabile GRAILS_HOME alle variabili di sistema che deve contenere il path completo alla cartella grails, es: "c:grails" in sistemi Microsoft e "~/grails" in sistemi Linux.

In sistemi Linux aggiungiamo export GRAILS_HOME=~/grails in ~/.bash_profile, mentre in sistemi Microsoft aggiungiamo la variabile mediante Variabili di sistema in Pannello di Controllo->Sistema. Aggiungiamo inoltre alla variabile di sistema PATH il percorso ${GRAILS_HOME}/bin per sistemi Linux o %GRAILS_HOME%bin in sistemi Microsoft.

Primo progetto pratico: agenda di appuntamenti

Andiamo a sviluppare la nostra prima applicazione Grails, una agenda di appuntamenti. Il primo passo da compiere è creare il progetto agenda: apriamo la shell Linux o la console DOS e entriamo nella directory che conterrà tutti i nostri progetti Grails, ad esempio in Linux: cd ~/progetti. Creiamo ora la nostra applicazione mediante il comando: grails create-app agenda. Se al termine della procedura vedete il messaggio: Created Grails Application at ~/progetti/agenda, l'applicazione è stata correttamente creata.

In particolare è stata creata una cartella agenda con le seguenti sottocartelle:

grails-app

conf, contiene la configurazione dell'applicazione

hibernate, contiene i file di configurazione opzionali per Hibernate
spring, contiene i file di configurazione opzionali per Spring

controllers, contiene le classi Groovy che definiscono i controllers dell'applicazione
domains, contiene le classi Groovy che definiscono i domains dell'applicazione
i18n, contiene i file riguardanti la localizzazione dell'applicazione
serivices
taglib, contiene le librerie di tag utilizzate
util, contiene alcune classi di utilità
views, contiene i file GSP

layouts, contiene i layout

lib
scripts
src

groovy, contiene i file sorgenti Groovy opzionali
java, contiene i file sorgenti Java opzionali

test, contiene classi di test
web-app

META-INF
WEB-INF
css
images
js

Procediamo ora a creare i due domains utilizzati: Appuntamento e Contatto:

grails create-domain-class Appuntamento
grails create-domain-class Contatto

Verifichiamo che le classi siano state create in agenda/grails-app/domain/agenda. Apriamo Contatto.groovy e modifichiamo il codice in modo che diventi:

class Contatto {
  static contraints = {
    nome(blank:false)
    telefono(blank:false)
    email(email:true)
  }
  String nome
  String telefono
  String email
}

Modifichiamo anche Appuntamento.groovy:

class Appuntamento {
  static contraints = {
    data(blank:false)
    descrizione(blank:false)
  }
  String descrizione
  String luogo
  Date data
  Contatto contatto
}

Andiamo a creare ora il controller di Appuntamento mediante il comando: grails create-controller Appuntamento e verifichiamo che Grails abbia creato la classe controller in agenda/grails-app/controllers/agenda.

Apriamo AppuntamentoController.groovy e modifichiamolo in modo che contenga:

class AppuntamentoController {
  // def index = { }
  def scaffold = Appuntamento
}

Nello stesso modo creiamo il controller Contatto e modifichiamo in modo che contenga:

class ContattoController {
  //def index = { }
  def scaffold = Contatto
}

Ora possiamo avviare l'applicazione web mediante il comando: grails run-app. Se l'applicazione viene avviata correttamente Grails visualizza un messaggio simile a questo "Server running. Browse to http://localhost:8080/agenda".

Apriamo quindi il browser e puntiamolo all'url indicata. Se non ci sono errori vedremo la seguente schermata: