Build automation con Gradle

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:

gradle -v

Su Ubuntu, l’output mostrato è il seguente:

------------------------------------------------------------
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

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:

gradle proviamoGradle

ottenendo il seguente output:

2 è pari...
4 è pari...
6 è pari...
8 è pari...
10 è pari...
12 è pari...
14 è pari...
16 è pari...
18 è pari...
Operazioni terminate alle 12:33:35

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:

apply plugin: 'java'

A questo punto, digitando da riga di comando:

gradle build

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:

java -jar bin.jar

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.