
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Gradle è un tool multipiattaforma e gratuito, tra i più avanzati attualmente disponibili nell’ambito della build automation.
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.
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:
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:
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.
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:
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.
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.
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
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:
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: .
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.
Se vuoi aggiornamenti su Build automation con Gradle inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
Express è un framework per creare applicazioni Web con Node.js. In questo video vediamo come installare il pacchetto e creare […]
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
Impariamo ad utilizzare Takamaka, una blockchain Java Full Stack, per scrivere codice Java installabile ed eseguibile su una blockchain
In questo articolo impareremo a gestire gli URL (Uniform Resource Locator) attraverso le API messe a disposizione dal linguaggio di programmazione Java.
Java 13: In questo articolo andiamo a presentare le nuove caratteristiche introdotte dalla release elencandole in base al codice JEP che le identifica.
Impariamo a sviluppare applicazioni Java per i sistemi Embedded, piattaforme che a differenza delle tradizionali soluzioni general purpose vengono progettate per svolgere compiti specifici. Nel corso delle guida verranno fornite le nozioni necessarie per installare Oracle Java SE Embedded, scegliere il profilo e la JVM da utilizzare, configurare una JRE personalizzata, creare una prima App ed effettuarne il deploy