Gradle

Da Wikipedia, l'enciclopedia libera.
Gradle
Logo
Sviluppatore Hans Dockter, Adam Murdoch, Szczepan Faber, Peter Niederwieser, Luke Daley, Rene Gröschke, Daz DeBoer, Steve Appling, collaboratori su GitHub
Data prima versione 2007
Ultima versione 2.10[1] (21 dicembre 2015; 23 mesi fa)
Sistema operativo Multipiattaforma
Linguaggio Java
Groovy
Genere Automazione dello sviluppo
Licenza Apache 2.0
(licenza libera)
Sito web e

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[2], 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.[3] Nel corso del 2013, Google ha scelto Gradle come sistema di costruzione automatizzato per il progetto Android.[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 Data
0.7 2009-07-20
0.8 2009-09-28
0.9 2010-12-19
1.0 2012-06-12
1.1 2012-07-31
1.2 2012-09-12
1.3 2012-11-20
1.4 2013-01-28
1.5 2013-03-27
1.6 2013-05-07
1.7 2013-08-06
1.8 2013-09-24
1.9 2013-11-19
1.10 2013-12-17
1.11 2014-02-11
1.12 2014-04-29
2.0 2014-07-01 [6]
2.1 2014-09-08 [7]
2.2 2014-11-10 [8]
2.3 2015-02-16 [9]
2.4 2015-05-05 [10]
2.5 2015-07-08 [11]
2.6 2015-08-10 [12]
2.7 2015-09-14 [13]
2.8 2015-10-19 [14]
2.10 2015-12-21 [15]

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.[16] 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.[16] Ciò consente di generare un repository offline e di ispezionare i file per metadati personalizzati.[16]

Note[modifica | modifica wikitesto]


Bibliografia[modifica | modifica wikitesto]

Altri progetti[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]

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