Stasera mi volevo dilettare un pò a studiare Groovy, un progetto di un linguaggio di scripting moderno ed in grado di integrarsi a perfezione nel mondo di Java. Groovy, infatti, è sia un linguaggio interpretato che compilabile in Java byte code, rendendo pertanto molto snella la scrittura di nuove classi all’interno dei nostri progetti.

Groovy è un linguaggio dinamicamente tipizzato quindi un espressione del tipo:

def x = 5
def y = "Ciao Mondo"

sarà correttamente interpretata attribuendo alle variabili x ed y i giusti tipi, deducendoli dal valore assegnato. Altre caratteristiche rendono molto appetibile Groovy anche rispetto allo stesso Java. Ad esempio la presenza dei closures:

alquadrato = { it * it }

rappresenta la definizione di una funzione che moltiplica per se stesso un valore passato come parametro (di default “it” è un nome riservato al parametro). Quindi la chiamata:

[ 1, 2, 3, 4 ].collect(alquadrato)

restituirà l’array [1, 4, 9, 16]. Ciò che si può fare con i closures è limitato solo dalla nostra capacità di rendere incomprensibile un codice ò_ò.

Iniziamo con un semplice esempio:

package it.unile;
	
public class GClasse {
	def k =99
	def s = "Ciao Mondo! Chissà perché ma ho in mente il numero"
	public void Print()
	{
		println(s+" "+k)
	}
	
}

Una classetina semplice che salveremo in un file GClasse.groovy all’interno della cartella src/it/unile. Il codice si distingue per la mancanza (opzionale) di “;” alla fine delle righe. Inoltre il comando di stampa su Standard Output è semplicemente “println”. In realtà Groovy è un linguaggio compatibile con la sintassi di Java; pertanto se non ricordate il costrutto per un ciclo for o un nome di tipo sappiate che la sintassi Java è ben accetta. Adesso supponiamo di voler integrare il codice Groovy in una applicazione Java.

Possiamo pensare di scrivere una classe java (src/it/unile/MainClass.java) nel seguente modo:

package it.unile;
	
import java.io.File;
import java.io.IOException;
	
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
	
import org.codehaus.groovy.*;
import org.codehaus.groovy.control.CompilationFailedException;
	
public class MainClass {
	public static void main(String[] args) {
		GroovyClassLoader loader = new GroovyClassLoader();
		Class groovyClass;
		try
		{
			groovyClass = loader.parseClass(new File("src/it/unile/GClasse.groovy"));
			GroovyObject groovyObject;
			groovyObject = (GroovyObject) groovyClass.newInstance();
			Object[] argos = {};
			groovyObject.invokeMethod("Print", argos);
	
		} catch (CompilationFailedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
}

Il codice è stato scritto con l’aiuto del plugin Groovy per Eclipse, disponibile presso il sito di Groovy. Il resto lo ha fatto Eclipse ed i suoi “Quick Fix” una volta importato il jar di Groovy nel Build Path.
Per poter compilare questa classe dovrete inserire nel classpath la libreria groovy-all-1.0.jar disponibile nella distribuzione di Groovy. Questa classe inizializza un Class Loader che ci consente, dinamicamente, di poter istanziare una classe di tipo GClasse a partire dallo script GClasse.groovy. Ad ogni cambiamento che faremo sullo script, senza ricompilare, un nuovo run della classe MainClass (in realtà ogni volta che leggeremo ed istanzieremo il file GClasse.groovy) produrrà come risultato l’esecuzione del codice aggiornato! Il sistema è ottimo per poter estendere con facilità le funzionalità delle nostre applicazioni con dei plugin scriptabili. Si potrebbe pensare anche di generare dinamicamente codice Groovy in base alle scelte dell’utente.

Avete visto quante cose si possono fare con Groovy? Ci rivediamo la prossima volta per nuovi ed emozionanti attacchi d’arte….ehm…vabbè.

Bye