Task Declaration & Registration

It's a set of lazy task APIs (TaskProvider, tasks.named, configureEach) that let Gradle skip creating and configuring tasks you don't run, cutting configuration-time cost.

Register a task of type Copy and configure from (source) and into (destination). Gradle copies the matched files into the target directory when the task runs.

doLast adds an action to the end of the task's action list; doFirst adds one to the front. Both run in the execution phase. If you call doFirst twice, the later one runs first.

An ad-hoc task is an untyped task of type DefaultTask whose behavior you add inline with doLast { ... }. You register it with tasks.register("name") and put the action in the closure.

Use tasks.named('compileJava') to get a lazy reference. It is preferred over getByName() because named() doesn't force the task to be configured immediately — configuration runs only if the task is actually needed.

tasks.create builds the task eagerly and runs its configuration immediately. tasks.register is lazy: it only registers the task and runs configuration if/when the task is actually needed. Prefer register.

Register a task of type Zip, tell it which files to include with from(...), and set archiveFileName plus destinationDirectory to control the output file name and folder.

--type selects the project template to scaffold—e.g. java-application, kotlin-library, java-library, basic. It determines the plugins, source layout, and sample code generated. Omitting it makes init prompt interactively (or infer from an existing pom.xml).

init generates the wrapper so the new project pins a specific Gradle version everyone uses via ./gradlew, without installing Gradle manually. The wrapper is four files: gradlew, gradlew.bat, gradle/wrapper/gradle-wrapper.jar, and gradle/wrapper/gradle-wrapper.properties.

all and the withType { } closure realize every matching task immediately. configureEach defers configuration so each task is only configured when (and if) it's realized.

Sync copies like Copy but also DELETES anything in the destination that isn't in the source, leaving the target as an exact mirror. Copy only adds/overwrites; it never removes stale files.

The print is outside doLast, so it runs in the configuration phase, which executes every build for all projects. Move the side-effecting code inside doLast { ... } so it only runs when the task executes.

withType<Test>() selects all tasks of type Test, and configureEach applies the block to each — both existing and future ones — lazily. configureEach defers configuration; all()/each() would eagerly realize every matching task.

Eager APIs force realization: tasks.getByName, tasks.create, tasks.all {}, iterating the task container, or calling .get() on a provider. Any of these realizes lazy tasks, undoing the benefit of register.

Register a task of type Exec and set commandLine to the executable plus its arguments. workingDir sets the directory to run in; args lets you set arguments separately from the executable.

Register a Delete task and list paths via delete(...). The base plugin's clean task is just a Delete that removes the build directory (layout.buildDirectory).

Pass the type as a second argument: tasks.register("zipIt", Zip::class) { } in Kotlin, or tasks.register('zipIt', Zip) { } in Groovy. 'by registering' is Kotlin delegate sugar that registers and binds a val to the provider.

--dsl selects the build-script language for the generated scripts: kotlin produces *.gradle.kts files, groovy produces *.gradle files. Kotlin DSL gives type-safe, IDE-friendly scripts and is now the recommended default.

--test-framework picks the testing library wired into the generated build and sample test—e.g. junit (JUnit 4), junit-jupiter (JUnit 5), testng, spock (Groovy), or kotlintest. It adds the right dependencies and configures tasks.test (e.g. useJUnitPlatform()).

tasks.getByName realizes the task right away. tasks.named returns a TaskProvider and defers configuration until the task is actually realized, preserving configuration avoidance.

rename changes file names (regex/closure), expand substitutes ${token} placeholders in text, filter transforms content line-by-line, and eachFile gives a per-file hook to tweak path/permissions or exclude files.

Inside the register block set group (the category in gradle tasks), description (the help text), and call dependsOn(...) to declare tasks that must run before this one. All three are properties on every task.

tasks.matching { } returns a live collection of tasks satisfying an arbitrary predicate — e.g. by name prefix. Use it when a type filter isn't enough. The trade-off: its predicate is less configuration-avoidance-friendly than withType's pure type filter.

The typed form returns a TaskProvider<JavaCompile>, giving statically-typed access to JavaCompile properties inside the block — no cast needed. If the actual task isn't that type, Gradle fails when the task is realized.

register returns a TaskProvider. Pass the provider itself to dependsOn or inputs — Gradle resolves it lazily. Use provider.configure { } to add config, and flatMap to read its outputs without calling get().

Tar is the same kind of archive task as Zip but produces a .tar. Set its compression property to Compression.GZIP and give it a .tar.gz extension to get a compressed tarball.

Calling get() on a TaskProvider, getByName/create, tasks.all/withType-closure, iterating the task container, or requesting the task on the CLI all realize it. Wire dependencies with providers and use named/configureEach to stay lazy.

Use one Sync/Copy task with nested from(...) { into("subdir") } child CopySpecs to fan files into subfolders. Wire inputs via Providers/configurations so they stay lazy, and target a dedicated build dir so Sync's delete is safe.

Use a typed/custom task when logic is reused, needs declared inputs/outputs for up-to-date checks and caching, or needs unit testing. Ad-hoc doLast tasks are fine for tiny one-off glue but get none of that.