Dependencies tussen projecten

In een Gradle-build met meerdere projecten moeten verschillende deelprojecten vaak samenwerken. Een deelproject kan bijvoorbeeld een bibliotheek produceren die een ander deelproject gebruikt.

Daar komen afhankelijkheden tussen projecten van pas! Ze bepalen hoe deelprojecten van elkaar afhankelijk zijn, zodat de juiste buildvolgorde en het delen van artefacten worden gewaarborgd.

• Afhankelijkheden tussen projecten: Hoe een deelproject code of uitvoer van een ander deelproject gebruikt.
• Essentieel voor modulaire toepassingen.

In Gradle is het eenvoudig om te declareren dat het ene deelproject afhankelijk is van een ander. Je gebruikt de functie project() in je blok dependencies.

Als je deelproject app bijvoorbeeld code uit je deelproject lib nodig heeft, voeg je dit toe aan app/build.gradle:

// app/build.gradle
dependencies {
    implementation project(':lib')
}

Het gedeelte :lib verwijst naar het pad van het deelproject lib ten opzichte van de hoofdmap.

Stel je een eenvoudige configuratie met meerdere projecten voor. We hebben een hoofdproject, een deelproject app en een deelproject lib.

Je settings.gradle ziet er zo uit:

// settings.gradle
rootProject.name = 'my-multi-project'
include 'app', 'lib'

Hiermee informeer je Gradle over onze twee deelprojecten, app en lib.

Bij het declareren van afhankelijkheden tussen projecten gebruik je meestal configuraties zoals implementation of api.

• implementation: De meest gebruikelijke keuze. De afhankelijkheid wordt intern door het deelproject gebruikt en niet beschikbaar gesteld aan gebruikers van dat deelproject.
• api: Stelt de afhankelijkheid beschikbaar aan gebruikers. Als app via api afhankelijk is van lib en otherApp afhankelijk is van app, ziet otherApp ook de API van lib.

Voor intern gebruik tussen deelprojecten heeft implementation over het algemeen de voorkeur vanwege betere inkapseling en snellere builds.

Maak eerst een eenvoudige klasse in ons deelproject lib die het deelproject app zal gebruiken. Deze klasse biedt een basishulpmiddel.

In lib/src/main/groovy/com/coddykit/LibUtils.groovy:

Laat ons deelproject app nu de klasse LibUtils uit ons deelproject lib gebruiken. Vergeet niet dat we implementation project(':lib') hebben gedeclareerd in app/build.gradle.

Probeer dit voorbeeld uit te voeren:

Een van de grootste voordelen van het declareren van afhankelijkheden tussen projecten is dat Gradle automatisch de juiste buildvolgorde bepaalt.

• Als app afhankelijk is van lib, zorgt Gradle ervoor dat lib wordt gecompileerd en dat de artefacten beschikbaar zijn voordat app met compileren begint.
• Zo hoef je buildvolgordes niet handmatig te beheren, vooral niet in complexe configuraties met meerdere projecten.

Wanneer je vanuit de hoofdmap gradle build uitvoert, bouwt Gradle eerst lib en daarna app.

Wat gebeurt er als je deelproject lib zelf afhankelijk is van een ander deelproject, bijvoorbeeld common?

// lib/build.gradle
dependencies {
    implementation project(':common')
}

// app/build.gradle
dependencies {
    implementation project(':lib')
}

Als app afhankelijk is van lib en lib afhankelijk is van common, zorgt Gradle er ook voor dat common wordt gebouwd en dat de artefacten transitief beschikbaar zijn op het classpath van app voor compilatie. Ze zijn echter niet noodzakelijk beschikbaar in de API van app als lib implementation gebruikt.

Volg deze best practices om je builds met meerdere projecten beheersbaar en efficiënt te houden:

• Minimale afhankelijkheden: Declareer alleen afhankelijkheden voor deelprojecten die je echt nodig hebt.
• Gebruik implementation: Geef voor interne afhankelijkheden tussen deelprojecten de voorkeur aan implementation boven api om de inkapseling te verbeteren en herbouwen te beperken.
• Duidelijke grenzen: Ontwerp je deelprojecten met duidelijke verantwoordelijkheden om circulaire afhankelijkheden te voorkomen.
• Vermijd diepe paden: Houd paden naar deelprojecten beknopt. :module:submodule is bijvoorbeeld prima, maar vermijd onnodig lange paden.

Goed gedaan! In deze les heb je geleerd hoe je afhankelijkheden tussen deelprojecten in een Gradle-build met meerdere projecten beheert.

• We hebben besproken hoe je afhankelijkheden declareert met project(':subproject').
• We hebben het belang van implementation voor intern gebruik besproken.
• Je hebt gezien hoe Gradle automatisch de buildvolgorde beheert.
• We hebben best practices voor overzichtelijk afhankelijkheidsbeheer behandeld.

Het beheersen van afhankelijkheden tussen projecten is essentieel om grote, modulaire toepassingen efficiënt met Gradle te bouwen!