Java  »  Articoli  »  Programmazione Java 

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:

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.

Altri articoli

Altre guide

Altre newsletter