Quando si inizia a programmare, si identifica nel codice la principale
chiave di successo del proprio lavoro. La sua qualità è
sicuramente un elemento imprescindibile. Un approccio
più professionale, però, suggerisce l'adozione di
ulteriori strumenti che aumentino la produttività di un programmatore:
ambienti di sviluppo, un buon debugger, sistemi di
controllo della versione ma anche tool di build automation.
Proprio in quest'ultima categoria rientra Gradle,
software multipiattaforma e gratuito, tra i più avanzati attualmente
disponibili nell'ambito della build automation.
In questo articolo introdurremo alcuni concetti fondamentali, comuni a tutti
i tool di questo tipo, per poi approfondire l'utilizzo di Gradle.
Cos'è la build automation
Le fasi di sviluppo di un software sono contornate da una serie di
attività accessorie, a volte preliminari, a volte attuate a posteriori,
spesso organizzate durante lo sviluppo.
Tra queste attività possiamo evidenziare le principali:
- compilazione: si tratta del procedimento di
trasformazione dei sorgenti (scritti dal programmatore) in codice
binario (il formato riconosciuto dalla macchina); - packaging dei binari: il
risultato della compilazione deve assumere una forma compatta ed una
chiara connotazione in base al suo scopo: eseguibile, libreria da
esportare, etc.; - esecuzione di test automatizzati: un software vero non
può semplicemente essere "provato". Non basta inserire qualche dato a
caso con le proprie mani e sentirsi soddisfatti dei risultati ottenuti.
Per evitare bug nascosti, è necessario attuare una fase di sperimentazione
che dimostri l'affidabilità del software in ogni sua sfaccettatura,
cercando di verificarne le funzionalità in ogni possibile situazione.
Per seguire una strategia di
test del genere, non è più sufficiente un essere umano di buona volontà
ma è necessaria una macchina, un software appositamente programmato per
eseguire test completi; - deployment della
soluzione: una volta che il software è pronto e testato, deve essere
installato e configurato sui sistemi per i quali è stato implementato; - documentazione del
progetto: i software prodotti sono spesso piuttosto complessi e vivono,
attraverso le versioni pubblicate, una vera e propria evoluzione. Data
la complessità dei prodotti informatici, la redazione di opportuni
documenti che ne spieghino l'utilizzo e le funzionalità
è fondamentale. Ovviamente la documentazione prenderà la forma più consona
al tipo di progetto e al target di utilizzatore.
I prodotti di build automation sono tool pensati proprio per automatizzare
tutte le fasi appena elencate. La loro importanza è notevole, al punto
che hanno popolato la storia dell'informatica.
Se i programmatori per tanti anni si sono affidati a Make, gli esperti
del mondo Java si sono spesso confrontati con Ant e Maven, entrambi
basati su file di configurazione in XML.
Nonostante le differenze che li distinguono, i tool di
build automation a volte presentano tratti comuni, quali ad esempio:
- il build file: le
operazioni che devono essere svolte per trasformare il progetto
sorgente nella soluzione finale vengono
raccolte in un file principale, che a volte fa riferimento o include altri file secondari; - il task: è il concetto
che definisce la singola operazione da svolgere all'interno delle fasi
del procedimento di build. Spesso i task sono divisi in micro-azioni e vengono
contestualizzati assegnando loro precedenze e dipendenze da altri task.
Così facendo viene definito il flusso di svolgimento dell'intero processo di build; - le dipendenze del
software da altri progetti: a livello professionale, non si inizia a
programmare "da zero" ma ci si basa su framework, librerie o altri
progetti, che rappresentano le fondamenta del nostro lavoro. Fare in modo che
nelle varie fasi di build il progetto abbia a disposizione tutto il
necessario è un compito doloroso per il programmatore. Un grande
merito dei tool di questa categoria al giorno d'oggi è quella di
automatizzare il soddisfacimento delle dipendenze del progetto in
maniera automatica, attraverso la rete, mettendo a disposizione le
versioni aggiornate delle dipendenze, o quelle meglio compatibili con le nostre necessità.
In definitiva, un progetto informatico prende vita grazie ad una serie
di fasi, a volte complesse, la cui automazione solleva il programmatore
da notevoli responsabilità ed riduce la possibilità che si verifichino errori di distrazione o
stanchezza.
Gradle: iniziamo ad usarlo
Strumenti di build automation come Ant e Maven, ricchi di funzionalità ed
espandibili, hanno spesso dimostrato una certa rigidità di
configurazione dovuta per lo più all'utilizzo del formato XML.
Gradle si propone come uno dei tool di gestione dei software più
avanzato del momento. Esso trae vantaggio
dall'utilizzo di configurazioni svolte in un linguaggio dichiarativo: Groovy.
Si tratta di un linguaggio di scripting che nasce in seno alla tecnologia
Java. Appartiene all'ambito della programmazione orientata agli oggetti
e il suo codice è compilato on-the-fly, ed assume la forma di
bytecode per la Java Virtual Machine.
Gradle è progetto multipiattaforma e può essere scaricato dal sito di riferimento www.gradle.org. Seguendo il link
Downloads è possibile scaricarne i
sorgenti, i binari o un pacchetto che li includa entrambi con
l'aggiunta della documentazione.
Scegliamo di scaricare la versione con i binari e, una volta
scompattato l'archivio in formato .zip, otterremo il
contenuto parzialmente visibile nella figura seguente.
Tra le varie cartelle, ce ne sono due di maggiore interesse per i nostri scopi:
- bin: contiene gli eseguibili. Serviranno per attivare il
programma da riga di comando; - lib: raccoglie molti archivi jar che permetteranno a
Gradle di svolgere il proprio lavoro. Un rapido sguardo
all'interno di questa directory ci fa notare alcuni nomi che dimostrano su quali solide basi
poggi Gradle e quanto affondi le proprie radici nel mondo Java: ant,
log4j, groovy, diversi commons di Apache e molto altro ancora.
Una volta scompattato l'archivio .zip, Gradle è già pronto all'uso. Per funzionare, esso non
richiede altro che un JDK o una JVM correttamente configurati nel
sistema.
Per provarne le funzionalità, utilizziamo subito il
comando gradle, direttamente da riga di comando:
[code]
gradle -v
[/code]
Su Ubuntu, l'output mostrato è il seguente:
[code]
------------------------------------------------------------
Gradle 2.1
------------------------------------------------------------
Build time: 2014-09-08 10:40:39 UTC
Build number: none
Revision: e6cf70745ac11fa943e19294d19a2c527a669a53
Groovy: 2.3.6
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_21 (Oracle Corporation 23.21-b01)
OS: Linux 3.5.0-23-generic amd64
[/code]
Come si vede, il comando appena digitato mostra la versione di Gradle
(2.1 in questo caso) e di tutti i componenti che
esso ha a disposizione: JVM, groovy, ant e sistema operativo.
La sintassi
Visto che un vantaggio importante di Gradle consiste nella flessibilità
del linguaggio utilizzato, vediamolo subito al lavoro.
Creiamo un file di build, che possiamo denominare build.gradle,
apriamolo con un editor di testo e scriviamo il seguente codice al suo
interno:
import java.text.SimpleDateFormat
SimpleDateFormat simple=new SimpleDateFormat("HH:mm:ss")
task proviamoGradle {
for(int i=1;i<20;i++)
if (i%2==0) println i+" è pari..."
println 'Operazioni terminate alle'+simple.format(new Date())
}Da riga di comando digitiamo:
[code]gradle proviamoGradle[/code]
ottenendo il seguente output:
[code]
2 è pari...
4 è pari...
6 è pari...
8 è pari...
10 è pari...
12 è pari...
14 è pari...
16 è pari...
18 è pari...
Operazioni terminate alle 12:33:35
[/code]
In pratica, abbiamo realizzato un programma, il cui cuore è collocato
nel task denominato proviamoGradle,
in cui vengono stampati i numeri
pari compresi tra 1 e 20, seguiti dall'informazione oraria del
termine delle operazioni. La cosa più interessante di ciò, però, è
il fatto che il codice che abbiamo utilizzato non è altro che Java.
Le classi Date e SimpleDateFormat che abbiamo utilizzato sono
esattamente quelle appartenenti al JDK, for e if sono i costrutti di
controllo che conosciamo bene e println è l'istruzione per
richiedere la stampa a console di una singola riga.
L'esempio dimostra come l'uso di Groovy all'interno di Gradle
conferisca non solo flessibilità alle istruzioni, ma tutta la ricchezza
delle funzionalità del mondo Java.
Build automation: compiliamo un programma in Java
Gradle può svolgere operazioni di qualunque tipo e può interagire con
tecnologie informatiche di ogni genere, sebbene le sue funzionalità
lo rendono particolarmente adatto a Java. Per questo motivo,
lo useremo per eseguire il build di un programma Java,
un semplice 'Hello world'.
Per tutti quei settori in cui il tool offre un gran numero di funzionalità,
vengono forniti degli appositi plugin.
Per Java ne esiste uno che contiene tutti i task che ne specificano le più
comuni necessità: compilazione, impacchettamento
in .jar, test, eccetera. Creiamo quindi un semplice file Hello.java, con il più classico dei contenuti
di prova:
public class Hello
{
public static void main(String[] args)
{
System.out.println("Hello world!");
}
}È molto importante, a questo punto, seguire le convenzioni di
Gradle. Pertanto collochiamo il file appena creato all'interno della cartella
src/main/java.
Il file build.gradle sarà minimale, poichè dovrà solo attivare il plugin 'java',
senza includere alcun task:
[code]apply plugin: 'java'[/code]
A questo punto, digitando da riga di comando:
[code]gradle build[/code]
Gradle creerà, accanto alla cartella src, anche la cartella build, il
cui contenuto sarà quello mostrato in figura:
Chi conosce Java sa che si tratta di una
compilazione completa del nostro software: il file .class
con il bytecode, un .jar ed anche un file Manifest.
In pratica, il plugin ha fatto quello che un qualunque programmatore
Java si sarebbe aspettato: ha elaborato i sorgenti, riconoscendoli dalla
collocazione in cartelle, e li ha compilati.
Un'ultima nota: per rendere utilizzabile direttamente il file .jar, è
necessario impostare l'attributo Main-Class nel Manifest.
Possiamo specificare quest'altra istruzione sempre nel file build.gradle:
apply plugin: 'java'
jar {
manifest {
attributes 'Main-Class':'Hello'
}
}Fatto ciò e lanciato nuovamente il comando gradle build
otterremo lo stesso risultato, ma questa volta il file .jar prodotto sarà
eseguibile da riga di comando con:
[code]java -jar bin.jar[/code]
Integrazione su Android Studio
Gradle è entrato a far parte del mondo
della programmazione Android, ed è interessante investigarne il suo impiego in
Android Studio, un IDE
pubblicato a maggio del 2013 appositamente per
creare app Android.
Piuttosto che sviluppare capacità di building all'interno di Android
Studio, è stato integrato in esso l'uso di Gradle, che è collegato all'IDE con un
apposito plugin.
Il vantaggio di questa scelta consiste nell'avere un sistema
flessibile e potente, ma
soprattutto esterno all'IDE. Ciò permette di fare build da riga di
comando o automatizzati tramite script anche su macchine in cui non sia
presente Android Studio.
I progetti di Android Studio contengono almeno un modulo obbligatorio,
che prende il nome di app.
Ogni modulo ha il suo build.gradle file,
strutturato come il seguente:
apply plugin: 'com.android.application'
android {
compileSdkVersion 20
buildToolsVersion "20.0.0"
defaultConfig {
applicationId "comexample.helloworld"
minSdkVersion 14
targetSdkVersion 20
versionCode 1
versionName "1.0"
}
buildTypes {
release {
runProguard false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}Dopo quanto detto su Gradle in questo articolo, possiamo
riconoscere i seguenti elementi:
- apply plugin carica il
plugin contenente i task relativi alle
attività per Android; - l'elemento android
racchiude vari attributi di configurazione del
progetto, come il version number e livelli di API di riferimento
(minSdkVersion e targetSdkVersion); - dependencies specifica le
dipendenze del progetto. Quella che si
vede qui è una dipendenza
locale, che permette di avere a
disposizione le classi presenti all'interno dei file .jar inclusi nella
directory libs.
Molto spesso vengono usate dipendenze
remote, definite mediante coordinate Maven, come ad esempio:compile 'com.android.support:appcompat-v7:20.+'
che permette di usare
classi contenute nella libreria di supporto appcompat7.
La presenza di Gradle in Android Studio giustifica anche la particolare
disposizione dei sorgenti Java e delle risorse nel progetto, che seguono
le convenzioni cui si era accennato in precedenza, e che devono essere
rispettate affinchè il build possa essere eseguito.
Un altro aspetto da non dimenticare è che, ogni volta che il programmatore
apporta modifiche al file
build.gradle, su Android Studio è necessario cliccare sul pulsante Sync Project
With Gradle Files, riconoscibile mediante la seguente icona: 
.
Conclusioni
Quanto presentato in questo articolo non è che una goccia nel mare delle funzionalità offerte da Gradle.
La documentazione ufficiale del
progetto resta la migliore fonte di informazioni. Non è raro trovare
programmatori interessati ad appronfondire l'argomento, e non solo nell'ambito di Java.
Gradle può essere utile a chiunque sia interessato ad un
sistema di scripting flessibile per pianificare operazioni da svolgere
nel sistema, ma anche a tutti gli sviluppatori Android che cercano di
prendere confidenza con Android Studio.
Interessante è anche approfondire il rapporto tra Gradle ed i suoi predecessori,
Ant e Maven. Gradle nasce nel segno della continuità e
dell'integrazione con entrambi questi ottimi tool, per fare in modo che
chi li ha già usati per anni nella build automation non debba
ricominciare da capo.
