Gestione delle dipendenze a Gradle

1. Panoramica

In questo tutorial, esamineremo la dichiarazione delle dipendenze in uno script di compilazione Gradle. Per i nostri esempi, utilizzeremo Gradle 6.7.

2. Struttura tipica

Cominciamo con un semplice script Gradle per progetti Java:

plugins { id 'java' } repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter:2.3.4.RELEASE' testImplementation 'org.springframework.boot:spring-boot-starter-test:2.3.4.RELEASE' }

Come si può vedere sopra, abbiamo tre blocchi di codice: plugin , repository e dipendenze .

Innanzitutto, il blocco dei plugin ci dice che questo è un progetto Java. In secondo luogo, il blocco delle dipendenze dichiara la versione 2.3.4. RILASCIO della dipendenza spring-boot-starter necessaria per compilare il codice sorgente di produzione del progetto. Inoltre, afferma anche che la suite di test del progetto necessita di un test di avvio primaverile per la compilazione.

La build Gradle estrae tutte le dipendenze dal repository Maven Central, come definito dal blocco dei repository .

Concentriamoci su come possiamo definire le dipendenze.

3. Configurazioni delle dipendenze

Esistono diverse configurazioni in cui possiamo dichiarare le dipendenze. A tal proposito possiamo scegliere di essere più o meno precisi, come vedremo più avanti.

3.1. Come dichiarare le dipendenze

Per iniziare, la configurazione ha 4 parti:

  • gruppo : identificatore di un'organizzazione, azienda o progetto
  • nome - identificatore di dipendenza
  • versione : quella che vogliamo importare
  • classificatore : utile per distinguere le dipendenze con lo stesso gruppo , nome e versione

Possiamo dichiarare le dipendenze in due formati. Il formato contratto ci consente di dichiarare una dipendenza come una stringa :

implementation 'org.springframework.boot:spring-boot-starter:2.3.4.RELEASE'

Invece, il formato esteso ci permette di scriverlo come una mappa :

implementation group:'org.springframework.boot', name: 'spring-boot-starter', version: '2.3.4.RELEASE'

3.2. Tipi di configurazione

Inoltre, Gradle fornisce molti tipi di configurazione delle dipendenze:

  • api - utilizzato per rendere esplicite le dipendenze ed esporle nel classpath. Ad esempio, quando si implementa una biblioteca per essere trasparente per i consumatori della biblioteca
  • implementazione - necessari per compilare il codice sorgente di produzione e sono puramente interni. Non sono esposti all'esterno della confezione
  • compileOnly - usato quando devono essere dichiarati solo in fase di compilazione, come annotazioni di sola origine o processori di annotazione. Non vengono visualizzati nel percorso classe runtime o nel percorso classe test
  • compileOnlyApi - usato quando richiesto in fase di compilazione e quando devono essere visibili nel classpath per i consumatori
  • runtimeOnly : utilizzato per dichiarare le dipendenze richieste solo in fase di esecuzione e non disponibili in fase di compilazione
  • testImplementation : richiesto per compilare i test
  • testCompileOnly - richiesto solo in fase di compilazione del test
  • testRuntimeOnly - richiesto solo in fase di test runtime

Dobbiamo notare che le ultime versioni di Gradle deprecano alcune configurazioni come compile , testCompile , runtime e testRuntime. Al momento della scrittura, sono ancora disponibili.

4. Tipi di dipendenze esterne

Analizziamo i tipi di dipendenze esterne che incontriamo in uno script di build Gradle.

4.1. Dipendenze del modulo

Fondamentalmente, il modo più comune per dichiarare una dipendenza è fare riferimento a un repository. Un repository Gradle è una raccolta di moduli organizzati per gruppo , nome e versione .

È un dato di fatto, Gradle estrae le dipendenze dal repository specificato all'interno del blocco del repository :

repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter:2.3.4.RELEASE' }

4.2. Dipendenze dei file

Dato che i progetti non utilizzano sempre la gestione automatizzata delle dipendenze, alcuni progetti organizzano le dipendenze come parte del codice sorgente o del file system locale. Pertanto, dobbiamo specificare la posizione esatta in cui si trovano le dipendenze.

A questo scopo, possiamo utilizzare i file per includere una raccolta di dipendenze:

dependencies { runtimeOnly files('libs/lib1.jar', 'libs/lib2.jar') }

Allo stesso modo, possiamo usare filetree per includere una gerarchia di file jar in una directory:

dependencies { runtimeOnly fileTree('libs') { include '*.jar' } }

4.3. Dipendenze del progetto

Poiché un progetto può dipendere da un altro per il riutilizzo del codice, Gradle ci offre l'opportunità di farlo.

Diciamo di voler dichiarare che il nostro progetto dipende dal progetto condiviso :

 dependencies { implementation project ( ':shared' ) } 

4.4. Dipendenze di Gradle

In alcuni casi, come lo sviluppo di un'attività o di un plugin, possiamo definire delle dipendenze che appartengono alla versione Gradle che stiamo utilizzando:

dependencies { implementation gradleApi() }

5. buildScript

As we saw before, we can declare the external dependencies of our source code and tests inside the dependencies block. Similarly, the buildScript block allows us to declare the Gradle build's dependencies, such as third-party plugins and task classes. Particularly, without a buildScript block, we can use only Gradle out-of-the-box features.

Below we declare that we want to use the Spring Boot plugin by downloading it from Maven Central:

buildscript { repositories { mavenCentral() } dependencies { classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.3.4.RELEASE' } } apply plugin: 'org.springframework.boot'

Hence we need to specify the source from which we'll download external dependencies because there isn't a default one.

What's described above is related to older versions of Gradle. Instead, in newer versions, it's possible to use a more concise form:

plugins { id 'org.springframework.boot' version '2.3.4.RELEASE' }

6. Conclusion

In questo articolo, abbiamo esaminato le dipendenze di Gradle, come dichiararle e i diversi tipi di configurazione.

Dati questi punti, il codice sorgente di questo articolo è disponibile su GitHub.