Gradle

Gradle software
Genere	Automazione dello sviluppo
Sviluppatore	Gradle Inc., Adam Murdoch, Daz DeBoer e Bo Zhang
Data prima versione	2008
Ultima versione	8.11.1 (20 novembre 2024)
Sistema operativo	Multipiattaforma
Linguaggio	Apache Groovy Java Kotlin
Licenza	licenza Apache 2.0 (licenza libera)
Sito web	gradle.org
Modifica dati su Wikidata · Manuale

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.

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]

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

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.

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

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

Un concetto chiave di Gradle è quello delle attività (task).

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.

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]

• (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.

• Automazione dello sviluppo
• Apache Maven
• Android Studio

• Wikimedia Commons contiene immagini o altri file su Gradle

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

Portale Software libero: accedi alle voci di Wikipedia che trattano di software libero