Uppgiftstyper och åtgärder
Utforska olika uppgiftstyper, definiera uppgiftsåtgärder och hantera uppgifters indata och utdata.
Uppgiftstyper och åtgärder är en gratis lektion i Groovy och Gradle: JVM-automatisering och byggsystemutveckling på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Groovy och Gradle: JVM-automatisering och byggsystemutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling innehåller totalt 4 lektioner.
Introduktion till tasks: typer och åtgärder
I Gradle är tasks de centrala arbetsenheterna. I lektion 1 visade vi hur Ni definierar grundläggande tasks. I den här lektionen går vi djupare in på task-typer och åtgärder.
Vi lär oss hur olika task-typer erbjuder specifik funktionalitet, definierar vad en task faktiskt gör med hjälp av åtgärder och hanterar taskens indata och utdata för effektiva byggen.
Vad är task-åtgärder?
En task-åtgärd är en koddel som en task kör. Se den som delen "vad som ska göras" i tasken.
Ni kan definiera åtgärder direkt i ett task-block eller med specialmetoder som doLast och doFirst.
- Direkt: Kod i
doLast { ... }eller själva task-blocket. doLast: Kör åtgärden allra sist i taskens körning.doFirst: Kör åtgärden allra först i taskens körning.
Enkelt exempel på en task-åtgärd
Vi skapar en enkel Gradle-task med en åtgärd med hjälp av doLast. Åtgärden skriver ut ett meddelande i konsolen.
Spara detta som build.gradle och kör gradle helloAction.
task helloAction {
doLast {
println 'Hello from a Gradle action!'
}
}doFirst kontra doLast förklarat
När en task har flera åtgärder spelar ordningen roll. Åtgärder med doFirst körs före alla andra åtgärder, medan åtgärder med doLast körs efteråt.
Om Ni definierar åtgärder direkt i taskens konfigurationsblock (utan doFirst/doLast) läggs de implicit till som doLast-åtgärder.
doFirst och doLast i praktiken
Observera körordningen i det här exemplet. println utanför doFirst/doLast körs under konfigurationsfasen.
Kör gradle orderedActions för att se resultatet.
task orderedActions {
doLast { println 'Action C: This is the main action (doLast).' }
doFirst { println 'Action B: This runs before everything.' }
doLast { println 'Action D: Another action at the end.' }
println 'Action A: This runs during configuration phase.'
}Inbyggda task-typer
Gradle är inte bara till för anpassade skript! Det tillhandahåller många kraftfulla inbyggda task-typer för vanliga åtgärder som att kompilera Java-kod, köra tester eller kopiera filer.
Dessa typer är klasser som utökar Gradles DefaultTask och levereras med fördefinierade egenskaper och beteenden. Ni konfigurerar dem i stället för att skriva all logik från grunden.
Exempel: task-typen `Copy`
Task-typen Copy används för att kopiera filer och kataloger. Den är betydligt robustare än ett enkelt skript för filhantering.
Skapa först en tom fil med namnet my_document.txt i projektets rotkatalog. Kör sedan gradle copyMyFile.
task copyMyFile(type: Copy) {
from '.' // Source directory (project root)
include 'my_document.txt' // File to copy
into 'build/backup' // Destination directory
}Exempel: task-typen `JavaExec`
Task-typen JavaExec är avsedd för att köra ett Java-program i en separat JVM-process.
För att detta ska fungera behöver Ni vanligtvis ha en Java-fil (till exempel src/main/java/MyApp.java) med en main-metod. Så här definierar Ni tasken i build.gradle:
// In build.gradle
apply plugin: 'java'
repositories {
mavenCentral()
}
task runMyJavaApp(type: JavaExec) {
classpath sourceSets.main.runtimeClasspath
mainClass = 'MyApp' // Your main class name
args 'Hello', 'World' // Optional arguments
}
// A sample src/main/java/MyApp.java file:
// public class MyApp {
// public static void main(String[] args) {
// System.out.println("Args: " + String.join(", ", args));
// }
// }Task-indata: "vad den behöver"
Indata för uppgifter är alla värden, filer eller kataloger som en uppgift använder för att utföra sitt arbete. Gradle spårar dessa indata.
Om indata inte har ändrats sedan det senaste bygget vet Gradle att det kan hoppa över körningen av uppgiften (vilket gör byggena snabbare!). Detta är avgörande för inkrementella byggen.
För anpassade uppgiftsklasser (som behandlas i nästa lektion) markerar du egenskaper med annoteringar som @Input, @InputFile eller @InputDirectory.
Utdata från uppgifter: ”Vad den producerar”
Utdata från uppgifter är alla filer eller kataloger som en uppgift skapar eller ändrar. Gradle spårar även dessa.
Genom att deklarera utdata (till exempel med @OutputDirectory eller @OutputFile för anpassade uppgiftsklasser) kan Gradle cachelagra uppgiftsresultat, dela dem mellan byggen och hantera uppgiftsberoenden korrekt.
Att förstå indata och utdata är avgörande för att kunna utnyttja Gradles funktioner för byggcachelagring och parallell körning.
Snabb kontroll: åtgärdernas ordning
Anta att en Gradle-uppgift definieras så här:
task myTask {
doLast { println 'Action C' }
doFirst { println 'Action B' }
doLast { println 'Action D' }
println 'Action A'
}Vilken är rätt ordning på utskriften när gradle myTask körs?
Sammanfattning: bemästra dina uppgifter!
Bra jobbat! Du har utforskat Gradle-uppgifter på djupet.
- Vi definierade uppgiftsåtgärder med
doFirstochdoLastför att styra körningsordningen. - Du såg hur du kan utnyttja kraftfulla inbyggda uppgiftstyper som
CopyochJavaExec. - Vi berörde också vikten av att deklarera indata och utdata för uppgifter för inkrementella byggen och cachelagring.
Härnäst lär vi oss hur du lägger till egenskaper i anpassade uppgifter och konfigurerar dem för ännu större flexibilitet!
Lär dig Groovy med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Uppgiftstyper och åtgärder” gratis?
Ja – hela texten till ”Uppgiftstyper och åtgärder” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling innehåller totalt 4 lektioner.
Vad lär jag mig i ”Uppgiftstyper och åtgärder”?
Utforska olika uppgiftstyper, definiera uppgiftsåtgärder och hantera uppgifters indata och utdata. Ni övar på Groovy och Gradle: JVM-automatisering och byggsystemutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Groovy och Gradle: JVM-automatisering och byggsystemutveckling?
Du behöver inga förkunskaper. Utbildningen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”Uppgiftstyper och åtgärder”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Groovy och Gradle: JVM-automatisering och byggsystemutveckling-lektionen?
Ja. Varje Groovy och Gradle: JVM-automatisering och byggsystemutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Definiera anpassade uppgifter
- Uppgiftstyper och åtgärder
- Uppgiftsegenskaper och konfiguration
- Inkrementella uppgifter och kontroller av aktualitet