Een aangepaste taak in Gradle

1. Overzicht

In dit artikel bespreken we hoe maak een aangepaste taak in Gradle. We laten een nieuwe taakdefinitie zien met behulp van een build-script of een aangepast taaktype.

Zie dit artikel voor de introductie van de Gradle. Het bevat de basisprincipes van Gradle en - wat het belangrijkste is voor dit artikel - de inleiding tot Gradle-taken.

2. Aangepaste taakdefinitie binnen build.gradle

Om een ​​eenvoudige Gradle-taak te maken, moeten we de definitie ervan toevoegen aan onze build.gradle het dossier:

taak welkom {doLast {println 'Welkom in de Baeldung!' }} 

Het belangrijkste doel van de bovenstaande taak is om de tekst "Welkom in de Baeldung!" Af te drukken. We kunnen dit controleren taak is beschikbaar door rennen geleidelijke taken - allemaal opdracht:

geleidelijke taken - allemaal 

De taak staat op de lijst onder de groep Andere taken:

Andere taken ----------- welkom

Het kan net als elke andere Gradle-taak worden uitgevoerd:

gradle welkom 

De output is zoals verwacht - het "Welkom in de Baeldung!" bericht.

Opmerking: als optie -alle is niet ingesteld, dan zijn taken die tot de categorie "Overig" behoren niet zichtbaar. Aangepaste Gradle-taak kan tot een andere groep behoren dan "Other" en kan een beschrijving bevatten.

3. Stel Groep en beschrijving in

Soms is het handig om taken op functie te groeperen, zodat ze onder één categorie zichtbaar zijn. We kunnen snel setgroup voor onze aangepaste taken, gewoon door een groepseigenschap te definiëren:

taak welkom {groep 'Voorbeeldcategorie' doLast {println 'Welkom op de Baeldung!' }}

Als we nu het Gradle-commando uitvoeren om alle beschikbare taken weer te geven (-alle optie is niet meer nodig), we zien onze taak onder een nieuwe groep:

Voorbeeldcategorietaken --------------------- welkom 

Het is echter ook goed voor anderen om te zien waarvoor een taak verantwoordelijk is. Wij kunnen maak een beschrijving die korte informatie bevat:

taak welkom {groep 'Voorbeeldcategorie' beschrijving 'Taken met een welkomstbericht' doLast {println 'Welkom in de Baeldung!' }} 

Als we een lijst met beschikbare taken afdrukken, ziet de uitvoer er als volgt uit:

Voorbeeld categorietaken --------------------- welkom - Taken met een welkomstbericht 

Dit soort taakdefinitie wordt genoemd ad-hoc definitie.

Verderop is het nuttig om een ​​aanpasbare taak te maken waarvan de definitie kan worden hergebruikt. We bespreken hoe u een taak van een type kunt maken en hoe u enige aanpassing beschikbaar kunt maken voor de gebruikers van deze taak.

4. Definieer het Gradle-taaktype binnenin build.gradle

De bovenstaande "welkomst" -taak kan niet worden aangepast en is daarom in de meeste gevallen niet erg nuttig. We kunnen het uitvoeren, maar als we het in een ander project (of subproject) nodig hebben, moeten we de definitie ervan kopiëren en plakken.

We kunnen snel maak aanpassing van de taak mogelijk door een taaktype te maken. Alleen een taaktype wordt gedefinieerd in het build-script:

class PrintToolVersionTask breidt DefaultTask uit {String tool @TaskAction void printToolVersion () {switch (tool) {case 'java': println System.getProperty ("java.version") break case 'groovy': println GroovySystem.version break default: throw new IllegalArgumentException ("Onbekende tool")}}}

EEN aangepast taaktype is een eenvoudige Groovy-klasse die zich uitbreidt DefaultTask - de klasse die de standaard taakimplementatie definieert. Er zijn andere taaktypen waaruit we kunnen uitbreiden, maar in de meeste gevallen is de DefaultTask klasse is de juiste keuze.

PrintToolVersionTasktask bevat tooleigenschap die kan worden aangepast door instanties van deze taak:

String gereedschap 

We kunnen zoveel eigenschappen toevoegen als we willen - houd er rekening mee dat het slechts een eenvoudig Groovy class-veld is.

Bovendien bevat het methode geannoteerd met @TaskAction. Het definieert wat deze taak doet. In dit eenvoudige voorbeeld wordt de versie van de geïnstalleerde Java of Groovy afgedrukt - afhankelijk van de opgegeven parameterwaarde.

Om een ​​aangepaste taak uit te voeren op basis van het aangemaakte taaktype, moeten we maak een nieuwe taakinstantie van dit type:

taak printJavaVersion (type: PrintToolVersionTask) {tool 'java'} 

De belangrijkste onderdelen zijn:

  • onze taak is een PrintToolVersionTask type, dus wanneer uitgevoerd, zal het de actie activeren die is gedefinieerd in de methode die is geannoteerd met @TaskAction
  • hebben we een aangepaste waarde voor gereedschapseigenschappen toegevoegd (Java) die zal worden gebruikt door PrintToolVersionTask

Wanneer we de bovenstaande taak uitvoeren, is de uitvoer zoals verwacht (afhankelijk van de geïnstalleerde Java-versie):

> Taak: printJavaVersion 9.0.1 

Laten we nu een taak maken die de geïnstalleerde versie van Groovy afdrukt:

taak printGroovyVersion (type: PrintToolVersionTask) {tool 'groovy'} 

Het gebruikt hetzelfde taaktype als we eerder hebben gedefinieerd, maar het heeft een andere tooleigenschapwaarde. Wanneer we deze taak uitvoeren, wordt de Groovy-versie afgedrukt:

> Taak: printGroovyVersion 2.4.12 

Als we niet te veel aangepaste taken hebben, kunnen we deze rechtstreeks in het build.gradle het dossier (zoals we hierboven deden). Als er echter meer dan een paar zijn, dan is onze bouwen.gradle-bestand wordt moeilijk te lezen en te begrijpen.

Gelukkig biedt Gradle daar enkele oplossingen voor.

5. Definieer het taaktype in het buildSrc Map

Wij kunnen definieer taaktypen in het buildSrc map die zich op het rootprojectniveau bevindt. Gradle compileert alles wat erin zit en voegt typen toe aan het klassenpad zodat ons build-script het kan gebruiken.

Ons taaktype dat we eerder hebben gedefinieerd (PrintToolVersionTask) kunnen worden verplaatst naar de buildSrc / src / main / groovy / com / baeldung / PrintToolVersionTask.groovy. We hoeven er maar een paar toe te voegen importeert uit Gradle API in een verhuisde klas.

We kunnen een onbeperkt aantal taaktypen definiëren in het buildSrc map. Het is gemakkelijker te onderhouden, te lezen en de declaratie van het taaktype bevindt zich niet op dezelfde plaats als de taakinstantie.

We kunnen deze typen op dezelfde manier gebruiken als we typen gebruiken die rechtstreeks in het build-script zijn gedefinieerd. We hoeven alleen te onthouden om de juiste invoer toe te voegen.

6. Definieer het taaktype in de plug-in

We kunnen aangepaste taaktypen definiëren in een aangepaste Gradle-plug-in. Raadpleeg dit artikel, waarin wordt beschreven hoe u een aangepaste Gradle-plug-in definieert, gedefinieerd in de:

  • build.gradle het dossier
  • buildSrc map als andere Groovy-klassen

Deze aangepaste taken zijn beschikbaar voor onze build wanneer we een afhankelijkheid van deze plug-in definiëren. Houd er rekening mee dat ad-hoc-taken ook beschikbaar zijn, niet alleen aangepaste taaktypen.

7. Conclusie

In deze zelfstudie hebben we besproken hoe u een aangepaste taak in Gradle kunt maken. Er zijn veel plug-ins beschikbaar die u kunt gebruiken in uw build.gradle bestand dat veel aangepaste taaktypen zal bieden die u nodig heeft.

Zoals altijd zijn codefragmenten beschikbaar op Github.