Gradle
| Gradle software | |
|---|---|
 | |
| Genere | Automazione dello sviluppo |
| Sviluppatore | Hans Dockter, Adam Murdoch, Szczepan Faber, Peter Niederwieser, Luke Daley, Rene Gröschke, Daz DeBoer, Steve Appling, collaboratori su GitHub |
| Data prima versione | 2008 |
| Ultima versione | 8.7 (22 marzo 2024) |
| Sistema operativo | Multipiattaforma |
| Linguaggio | Groovy Java Kotlin |
| Licenza | Apache 2.0 (licenza libera) |
| Sito web | gradle.org |
Gradle è un sistema open source per l'automazione dello sviluppo fondato sulle idee di Apache Ant e Apache Maven, che introduce un domain-specific language (DSL) basato su Groovy[1], al posto della modalità XML usata da Apache Maven per dichiarare la configurazione del progetto. Gli script Gradle possono essere eseguiti direttamente, in contrasto con le definizioni dei progetti Apache Maven (pom.xml).
Al contrario di Apache Maven, che definisce il ciclo di vita di un processo, e di Apache Ant, dove l'ordine dei compiti (detti target) è determinato dalle dipendenze (depends on), Gradle utilizza un grafo aciclico diretto (DAG) per determinare l'ordine in cui i processi possono essere eseguiti.
Gradle è stato progettato per sviluppi multi-progetto che possono crescere fino a divenire abbastanza grandi e supporta sviluppi incrementali determinando in modo intelligente quali parti del build tree sono aggiornate ("up-to-date"), in modo che tutti i processi che dipendono solo da quelle parti non avranno bisogno di essere ri-eseguiti; così facendo, il software riduce significativamente il tempo di costruzione del progetto, in quanto, durante il nuovo tentativo di costruzione, verranno eseguite solo le attività il cui codice è effettivamente stato alterato a partire dall'ultima costruzione completata. Gradle supporta anche la costruzione del progetto per processi concorrenti, il che consente di svolgere alcuni compiti durante la costruzione (ad esempio, i test automatizzati attraverso gli unit test), eseguiti in parallelo su più core della medesima CPU, su più CPU o su più computer.
I plugin iniziali sono concentrati soprattutto sullo sviluppo e implementazione di Java, Groovy, Scala e C++, ma l'intenzione è quella di estendere il progetto anche ad altri linguaggi.
Storia[modifica | modifica wikitesto]
Il programma è stato ideato e realizzato inizialmente da Hans Dockter, che è il fondatore della compagnia Gradle. Il codice sorgente viene condiviso tramite il software di controllo di versione distribuito Git su GitHub.[2] Nel corso del 2013, Google ha scelto Gradle come sistema di costruzione automatizzato per il progetto Android.[3][4]
Aspetti tecnici[modifica | modifica wikitesto]
Il software conserva alcuni punti di forza di Apache Maven:
- « convenzione sulla configurazione »
- « ciclo di vita »
- « gestione delle dipendenze » nello stile di Apache Ivy o di Apache Maven
- « repository »
Gradle offre i seguenti vantaggi:
- possibilità di definire il meccanismo di costruzione in linguaggio Groovy, nel file build (file che risulterà più leggero dell'equivalente XML),
- possibilità di modificare il comportamento predefinito di alcune attività,
- una notazione compatta per descrivere le dipendenze,
- un motore di produzione progettato per ottenere progetti multilingue.
Lo strumento permette di costruire, senza sforzo, progetti scritti in linguaggi di programmazione diversi da Java.[5] La migrazione di un progetto da Apache Maven a Gradle è molto facile, se il progetto di partenza soddisfa le convenzioni proposte da Apache Maven.[5]
Proprio come avviene con Apache Maven, la struttura di Gradle è costituita da un nucleo astratto e da una serie di plugin che ne espandono le funzionalità. Anche la costruzione dei progetti Java avviene per mezzo di un plugin. Gradle include alcuni plugin ufficiali che consentono la costruzione di progetti Java, Groovy, Scala e C++; inoltre è supportata la costruzione degli Java Enterprise Archive (gli archivi WAR ed EAR). Altri plug-in consentono di monitorare la qualità del software (ad esempio, invocano l'analisi del codice sorgente da parte del motore di FindBugs, di SonarQube, di PMD o di Checkstyle), ricorrendo all'esecuzione di controlli automatici ed alla produzione di report corrispondenti all'attività di costruzione.
Il processo di costruzione di Gradle si suddivide in due fasi principali, che vengono sempre eseguite: la configurazione e l'esecuzione. Durante il ciclo di configurazione, vengono delineati i passi dell'intera costruzione per generare il grafico di dipendenza (DAG) che contiene la sequenza di tutte le fasi da eseguire. La seconda fase consiste nell'attraversamento delle attività precedentemente rilevate. Sia la configurazione che la realizzazione della build avvengono per mezzo di istruzioni accessibili all'utente attraverso un'interfaccia di programmazione aperta e documentata.
Gradle utilizza tre file principali per personalizzare la costruzione:
- build.gradle (necessario)
- settings.gradle (opzionale) - Il file contiene la definizione dei moduli di cui si compone il multi-progetto.
- gradle.properties (opzionale) - Il file contiene un elenco di valori validi per l'inizializzazione delle proprietà di uno specifico progetto Gradle.
Esistono plugin Gradle per molti ambienti di sviluppo integrati (IDE); tra questi sono compresi i più popolari: NetBeans, IntelliJ IDEA e Eclipse.
I repository Apache Maven e Apache Ivy sono supportati da Gradle.
Documentazione[modifica | modifica wikitesto]
La documentazione di Gradle (i tutorial, il manuale e la documentazione API), che introduce il principiante alla tecnologia Gradle, è reperibile online dal sito ufficiale del prodotto. La documentazione è tuttavia inclusa nel pacchetto di download, posizionata al percorso ".\docs".
Progetto Java esemplificativo[modifica | modifica wikitesto]
Si consideri il caso in cui la struttura della cartella Maven viene usata per contenere il codice sorgente Java e le risorse. Queste cartelle sono: "src/main/java", "src/main/resources", "src/test/java" e "src/test/resources".
build.gradle
apply plugin: 'java'
Eseguendo "gradle build", il risultato sarà
> gradle build
:compileJava
:processResources
:classes
:jar
:assemble
:compileTestJava
:processTestResources
:testClasses
:test
:check
:build
BUILD SUCCESSFUL
Il plugin Java emula come attività la maggior parte dei cicli di vita previsti da Maven all'interno del grafo aciclico diretto delle dipendenze per gli ingressi e per le uscite di ciascuna attività. In questo caso elementare, l'attività build dipende da ciò che viene restituito dalle attività check e assemble. Allo stesso modo, check dipende da test e assemble dipende da jar.
Per i progetti che non seguono le convenzioni proposte da Maven, Gradle consente di configurare la struttura della cartella. L'esempio che segue supporterebbe un progetto contenente file sorgenti in "src/java", piuttosto che in "src/main/java" (come da convenzione esclusiva di Maven).
build.gradle
apply plugin: 'java'
sourceSets.main.java.srcDirs = ['src/java']
Migrazione Ant esemplificativa[modifica | modifica wikitesto]
Gradle si integra strettamente con Ant e tratta anche i file build di Ant come script che possono essere importati direttamente durante la costruzione. L'esempio che segue mostra un semplice costrutto Ant, incorporato come fosse un'attività di Gradle
build.xml
<project>
<target name="ant.target">
<echo message="Running ant.target!"/>
</target>
</project>
build.gradle
ant.importBuild 'build.xml'
Eseguendo gradle ant.target, il risultato sarà
> gradle ant.target
:ant.target
[ant:echo] Running ant.target!
BUILD SUCCESSFUL
Attività (Task)[modifica | modifica wikitesto]
Un concetto chiave di Gradle è quello delle attività (task).
Attività predefinite[modifica | modifica wikitesto]
Gradle ha diverse attività incorporate per via predefinita; per visionarle si ricorre all'esecuzione del comando sotto indicato:
gradle -q tasks
Il risultato del comando è:
hello-world $gradle -q tasks
-----------------------------------------------------
All tasks runnable from root project
-----------------------------------------------------
Help tasks
----------
dependencies - Displays the dependencies of root project 'hello-world'.
help - Displays a help message
projects - Displays the sub-projects of root project 'hello-world'.
properties - Displays the properties of root project 'hello-world'.
tasks - Displays the tasks runnable from root project 'hello-world'
(some of the displayed tasks may belong to subprojects).
Other tasks
-----------
helloWorld
To see all tasks and more detail, run with --all.
dove in "Other tasks" sono elencate le attività definite dall'utente.
Cronologia delle distribuzioni[modifica | modifica wikitesto]
| Versione | Ultimo aggiornamento | Data rilascio della Major Version |
|---|---|---|
| 0.7 | 0.9.2 | 2009-07-20 |
| 1.0 | 1.12 | 2012-06-12 |
| 2.0 | 2.14.1 | 2014-07-01 |
| 3.0 | 3.5.1 | 2016-08-15 |
| 4.0 | 4.10.3 | 2017-06-14 |
| 5.0 | 5.6.4 | 2018-11-26 |
| 6.0 | 6.9.4 | 2019-11-08 |
| 7.0 | 7.6.3 | 2021-04-09 |
| 8.0 | 8.4 | 2023-02-13 |
Le versioni precedenti possono essere recuperate dalla pagina di download di Gradle.
Gradle 2.3 aggiunge alcune funzionalità alla gestione delle dipendenze ed al supporto degli IDE ed apporta miglioramenti ad alcuni plugin incorporati.[6] A partire da questa versione è possibile utilizzare l'Artifact Query API per accedere ai metadati artefatti ivy.xml e pom.xml, usati da Gradle per risolvere le dipendenze.[6] Ciò consente di generare un repository offline e di ispezionare i file per metadati personalizzati.[6]
Note[modifica | modifica wikitesto]
- ^ (EN) Why Build Your Java Projects with Gradle Rather than Ant or Maven?, su drdobbs.com, Benjamin Muschko, 8 luglio 2014. URL consultato l'8 luglio 2014 (archiviato il 22 aprile 2015).
- ^ Repository ufficiale di Gradle ospitato da GitHub
- ^ (EN) Android Tools Project Site - Gradle Plugin User Guide, su sites.google.com, Google Inc., 17 maggio 2013. URL consultato il 17 maggio 2013 (archiviato il 22 aprile 2015).
- ^ (EN) Android Developers Documentation Site - Configure your build, su developer.android.com, Google Inc., 17 maggio 2013. URL consultato il 27 novembre 2020.
- ^ a b (FR) Build automatisé: à la découverte de Gradle, su connect.ed-diamond.com, Gaylord Mazelier, settembre 2011. URL consultato il settembre 2011 (archiviato il 22 aprile 2015).
- ^ a b c (EN) Note di rilascio di Gradle 2.3, su gradle.org, Sito Web ufficiale di Gradle, 16 febbraio 2015. URL consultato il 16 febbraio 2015 (archiviato dall'url originale il 23 aprile 2015).
Bibliografia[modifica | modifica wikitesto]
- (EN) Tim Berglund e Matthew McCullough, Building and Testing with Gradle, Foreword by Hans Dockter, First, O'Reilly Media, luglio 2011, p. 116, ISBN 978-1-4493-0463-8.
- (EN) Hubert Ikkink, Gradle Effective Implementation Guide, First, Packt Publishing, novembre 2012, p. 382, ISBN 978-1-84951-810-9.
- (EN) Tim Berglund e Matthew McCullough, Gradle DSLs, First, xO'Reilly Media, maggio 2013, pp. 50 est., ISBN 978-1-4493-0467-6.
- (EN) Benjamin Muschko, Gradle In Action, First, Manning Publications, Fall 2013, p. 390, ISBN 978-1-61729-130-2.
- (DE) Joachim Baumann, Gradle: Ein kompakter Einstieg in das Build-Management-System, First, D.Punkt.Verlag GmbH, 2013, ISBN 978-3-86490-049-5.
- (DE) Etienne Studer, "Ein Einstieg in Gradle für Java-Entwickler" e "Enterprise Gradle", First, 3-Teilige Serie über Gradle im Java Magazin 1 bis 3/2011, 2011.
Voci correlate[modifica | modifica wikitesto]
Altri progetti[modifica | modifica wikitesto]
Wikimedia Commons contiene immagini o altri file su Gradle
Collegamenti esterni[modifica | modifica wikitesto]
- (EN) Sito ufficiale, su gradle.org.
- Gradle, su packages.debian.org.
- (EN) Gradle, su GitHub.
- Repository sorgenti di Gradle, su github.com.
- (EN) Gradle, su Free Software Directory.
- (EN) Gradle Inc. per l'assistenza commerciale
