Groovy en Gradle: JVM-automatisering en buildbeheer · Les

Taakeigenschappen en configuratie

Leer eigenschappen aan aangepaste taken toevoegen, deze configureren en incrementele builds waarborgen.

Les 3 van 411 stappen

Taakeigenschappen en configuratie is een gratis Groovy en Gradle: JVM-automatisering en buildbeheer-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Groovy en Gradle: JVM-automatisering en buildbeheer. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Groovy en Gradle: JVM-automatisering en buildbeheer bevat in totaal 4 lessen.

Wat zijn taakeigenschappen?

Aangepaste Gradle-taken kunnen zeer flexibel worden gemaakt door eigenschappen toe te voegen. Deze eigenschappen werken als variabelen waarmee je het gedrag van een taak vanuit je build.gradle-script kunt configureren.

Dankzij eigenschappen zijn je aangepaste taken herbruikbaar en aanpasbaar aan verschillende projectbehoeften, zonder dat je hun kernlogica hoeft te wijzigen.

Eenvoudige eigenschappen definiëren

Om een eigenschap aan een aangepaste taak toe te voegen, declareer je eenvoudig een openbaar veld binnen je taakklasse. Voor basistypen zoals String, int of boolean is dit rechttoe rechtaan.

Voor geavanceerdere scenario's biedt Gradle ook speciale typen Property, maar we beginnen met eenvoudige declaraties.

Aangepaste taak met een eigenschap

Hier zie je een eenvoudige aangepaste taak die rechtstreeks in build.gradle is gedefinieerd. De taak heeft een eigenschap message die wordt afgedrukt wanneer de taak wordt uitgevoerd. Let op de standaardwaarde die voor de eigenschap is ingesteld.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class MyMessageTask extends DefaultTask {
    String message = "Default task message"

    @TaskAction
    void printMessage() {
        println "Task says: ${message}"
    }
}

task helloWorld(type: MyMessageTask)

Taakeigenschappen configureren

Nadat een taakeigenschap is gedefinieerd, kun je de waarde ervan eenvoudig instellen vanuit je build.gradle-bestand. Dit doe je binnen het configuratieblok van de taak, waarmee je de taakinstantie kunt aanpassen.

Voer het voorbeeld uit om te zien hoe het standaardbericht wordt overschreven.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class MyMessageTask extends DefaultTask {
    String message = "Default task message"

    @TaskAction
    void printMessage() {
        println "Task says: ${message}"
    }
}

task helloWorld(type: MyMessageTask) {
    message = "Hello from CoddyKit!"
}

Invoer voor incrementele builds

Een van Gradles krachtigste functies is incrementeel bouwen. Dit betekent dat Gradle taken kan overslaan als hun invoer en uitvoer sinds de vorige build niet zijn gewijzigd, wat veel tijd bespaart.

Om dit mogelijk te maken, moet je Gradle vertellen welke eigenschappen als invoer van de taak worden beschouwd. Dit zijn eigenschappen waarvan de waarden invloed hebben op het resultaat van de taak.

Invoereigenschappen declareren

Je markeert een eigenschap als invoer met de annotatie @Input. Gradle houdt de waarde ervan dan bij. Als de waarde tussen builds verandert, wordt de taak uitgevoerd. Zo niet, dan kan Gradle de taak markeren als UP-TO-DATE en overslaan.

Gebruik voor invoer van bestanden of mappen @InputFile, @InputDirectory of @InputFiles.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.TaskAction

class MyInputTask extends DefaultTask {
    @Input
    String greeting = "Hola!"

    @TaskAction
    void greet() {
        println "Greeting: ${greeting}"
    }
}

task sayHello(type: MyInputTask) {
    greeting = "Bonjour!"
}

Uitvoer voor incrementele builds

Ook uitvoer is van groot belang. Dit zijn de bestanden of mappen die je taak tijdens de uitvoering maakt of wijzigt. Gradle houdt ook deze bij om te bepalen of een taak actueel is.

Als de invoer van een taak niet is gewijzigd EN de gedeclareerde uitvoer aanwezig en geldig is, weet Gradle dat de taak niet opnieuw hoeft te worden uitgevoerd.

Uitvoereigenschappen declareren

Je gebruikt annotaties zoals @OutputFile voor één resultaatbestand of @OutputDirectory voor een map met resultaten. Hiermee geef je Gradle aan waar de gegenereerde artefacten van de taak worden opgeslagen.

De taak zorgt ervoor dat de bovenliggende map bestaat voordat het bestand wordt geschreven.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction

class MyOutputFileTask extends DefaultTask {
    @Input
    String content = "Default report content."

    @OutputFile
    File outputFile = project.file("build/reports/output.txt")

    @TaskAction
    void generateFile() {
        outputFile.parentFile.mkdirs()
        outputFile.write(content)
        println "Generated: ${outputFile.name}"
    }
}

task generateReport(type: MyOutputFileTask) {
    content = "Report data for: " + new Date().format("yyyy-MM-dd HH:mm:ss")
}

De kracht van incrementele builds

Door zowel invoer als uitvoer correct te declareren, benut je Gradles krachtige functie voor incrementeel bouwen. Hierdoor worden je taken alleen uitgevoerd wanneer dat nodig is, waardoor builds aanzienlijk sneller worden.

Deze optimalisatie is essentieel voor efficiënte ontwikkelprocessen en robuuste CI/CD-pijplijnen, omdat ze snelle feedback en een lager resourcegebruik garandeert.

Snelle controle van eigenschappen

Stel dat je een aangepaste Gradle-taak hebt die een specifiek configuratiebestand als invoer gebruikt. Welke annotatie zou je gebruiken voor de eigenschap die het pad naar dit ene configuratiebestand definieert?

Samenvatting: taakeigenschappen en incrementele builds

In deze les heb je geleerd hoe je eigenschappen aan aangepaste taken toevoegt, zodat je ze kunt configureren en hergebruiken. Je hebt ook ontdekt hoe je eigenschappen markeert als invoer (bijvoorbeeld @Input, @InputFile) en uitvoer (bijvoorbeeld @OutputFile, @OutputDirectory).

Deze annotaties zijn essentieel om Gradles krachtige functie voor incrementeel bouwen mogelijk te maken. Die functie versnelt je builds aanzienlijk door taken over te slaan die al actueel zijn. Blijf oefenen om efficiënte taakconfiguratie onder de knie te krijgen!

Gratis beginnen

Leer Groovy met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
12
Lessen
48

Veelgestelde vragen

Is de les “Taakeigenschappen en configuratie” gratis?

Ja — de volledige tekst van “Taakeigenschappen en configuratie” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Groovy en Gradle: JVM-automatisering en buildbeheer wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Groovy en Gradle: JVM-automatisering en buildbeheer bevat in totaal 4 lessen.

Wat leer ik in “Taakeigenschappen en configuratie”?

Leer eigenschappen aan aangepaste taken toevoegen, deze configureren en incrementele builds waarborgen. Je oefent met Groovy en Gradle: JVM-automatisering en buildbeheer door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Groovy en Gradle: JVM-automatisering en buildbeheer te beginnen?

Ervaring vooraf is niet nodig. Groovy en Gradle: JVM-automatisering en buildbeheer op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Taakeigenschappen en configuratie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Groovy en Gradle: JVM-automatisering en buildbeheer?

Ja. Elke les over Groovy en Gradle: JVM-automatisering en buildbeheer bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Aangepaste taken definiëren
  2. Taaktypen en acties
  3. Taakeigenschappen en configuratie
  4. Incrementele taken en up-to-date-controles
← Terug naar Groovy en Gradle: JVM-automatisering en buildbeheer