The Complete Gradle Course: From Beginner to Advanced

Explore the Gradle fundamentals, including the Gradle project, build script, tasks, and plugins. Master how to create a Gradle project from scratch by the end of the chapter.

Define the Gradle project as the highest level concept representing the entire application, with Spring Boot as an example. Learn project structure, settings.gradle, and Gradle tasks to interact with it.

Extend your project with a Gradle build script in Groovy or Kotlin to define how your application builds, using tasks, plugins, and reusable build logic.

Define a Gradle task in a build.gradle file to perform work, such as copying files, using prepackaged or custom tasks, and run it from the command line.

Apply the Gradle base plugin to automatically register and expose helpful tasks, including clean and copy tasks, and learn how plugins extend project functionality with modular tasks.

Create your first Gradle project by building a simple workflow that copies ride description files, replaces a theme park name token, and runs with a build script, task, and plugin.

Create a Gradle zip task named zip descriptions to package the generated ride descriptions into a zip file located at Build Descriptions zip.

Master interacting with Gradle via the command line and an IDE, create projects with the Gradle command line wizard, and navigate the Gradle project layout for version control.

Generate a basic Gradle project skeleton with the Gradle init command. Replace manual settings.gradle and build.gradle, then explore the generated Groovy DSL build.gradle, settings.gradle, and wrapper scripts.

Learn how the Gradle wrapper lets you run tasks without a local Gradle install, ensures project-specific versions, caches downloads, and simplifies updates for teammates.

Add the Gradle wrapper to an existing project and update its Gradle version. Learn how distributions are downloaded and cached in the user’s home directory for reliable builds.

Master the Gradle project layout, including build.gradle and settings.gradle, the default build directory, and what to commit or ignore: dot gradle, build source, gradle.properties, and Gradle wrapper.

Learn to interact with Gradle on the command line, run multiple tasks, set a default task, use abbreviated task names, and explore key command line options and console modes.

Learn the Gradle build lifecycle, including initialization, configuration, and execution, and how these phases affect task execution, multi-project builds, and incremental builds. Understand how to diagnose issues and optimize performance.

Learn how the Gradle daemon, enabled by default, runs in the background to speed builds by reusing daemons, and manage it with status, stop, and the no-daemon option.

Master Gradle integration in IntelliJ IDEA by importing and creating Gradle projects, running and debugging Gradle tasks, and configuring Gradle settings for optimal performance.

Create a Gradle project from scratch using Gradle init, configure a generate descriptions task, initialize git and .gitignore, commit, and run the task from the IDE with the Gradle wrapper.

Explore Gradle build scripts, including build.gradle files in Groovy and Kotlin, compare their advantages, and master plugins, tasks, dependencies, and repositories for effective projects.

Discover how Groovy language features power Gradle build scripts, from dynamic typing and closures to a Groovy-based DSL, enabling concise, script-style Gradle configurations.

Explore Gradle's Kotlin DSL and Groovy DSL differences, learn to create Kotlin Gradle projects with Gradle init, and configure tasks, plugins, and Kotlin scripts in IntelliJ for smoother builds.

Compare Gradle Groovy and Kotlin DSLs to decide which option to use for a new project, noting migration between Groovy and Kotlin, build script scope, consistency, and team skills.

Learn how to configure a Gradle project using Groovy DSL and Kotlin DSL, setting the description, group, and version, and understand how these properties affect publishing and artifact naming.

Learn to define and configure Gradle tasks, including task classes and ad hoc tasks, using Groovy or Kotlin DSLs with the tasks register approach.

Locate and configure Gradle tasks efficiently with task providers and configuration avoidance to minimize unnecessary configuration during builds. Explore four locating approaches, with tasks named as the recommended method.

Learn to link task inputs and outputs in Gradle to automate dependencies, enable incremental builds, and reduce duplication by using the from method to pass generated outputs to downstream tasks.

See how Gradle uses task dependencies to order producer and consumer tasks, such as generate descriptions and zip descriptions, with depends on, must run after, and finalized by, ensuring execution.

Apply plugins in Gradle using the plugin DSL to add rich build tasks, including core and third-party plugins, with proper versioning and IDE integration.

Learn how to declare repositories and dependencies in a Gradle build script, including Maven Central and Google Maven, and manage compile and runtime classpaths with dependency configurations.

Learn to build, test, and run Java applications with Gradle by managing compilation, classpath, resources, dependencies, packaging into a jar, running tests and applications, and publishing artifacts.

Apply the java plugin to enable compile Java, process resources, build a jar, and run tests, while configuring dependencies for an efficient classpath using the standard Gradle project layout.

Build a standalone Java jar with Gradle by implementing a main class that prints ride statuses from bundled resources, and test the logic with JUnit 5.

Understand how Gradle tasks orchestrate building, testing, and packaging Java projects using dependencies among build, assemble, check, and jar, and how to read the task graph.

Explore six Gradle dependency configurations and how they shape production and test classpaths. Use unresolvable and resolvable configurations, annotation processor paths, and extra properties to manage libraries.

Learn to customize Java compilation and resource processing in Gradle by configuring compile Java, compile test Java, process resources, and the jar task, including verbose options and archive file naming.

Learn to run Java applications with Gradle in a local environment, configure application plugin, main class, and arguments, manage runtime classpath and dependencies, and debug with remote JVM.

Configure the Gradle test task for JUnit 4/5 and testing platforms, use include/exclude filters, run tests from the command line or IntelliJ IDEA, and leverage incremental builds.

Learn to run unit and integration tests separately in Gradle using dedicated test suites and directories. Configure check to include integration tests with JVM Test Suite plugin for Gradle 7.3+.

Discover how to manage Java versions in Gradle using Java toolchains to ensure deterministic builds, download missing versions, and override versions for specific tasks like java exec, compile, and test.

Publish your Java artifacts to Maven repositories using the Maven Publish plugin in Gradle, configuring publications and repositories (including AWS), credentials, and an optional local Maven repository for testing.

Learn to build a spring boot web api with gradle, using starters and plugins, and run an executable jar for the Theme Park API rides in json.

Explore building Java libraries with Gradle, distinguish applications from libraries, and manage the application binary interface, compile and runtime classpaths using the API dependency configuration for clean consumer integration.

Deploy Spring Boot apps to standalone Tomcat using a deployable war. Replace the Gradle Java plugin with the War plugin, extend SpringBootServletInitializer, and generate an executable war.

Master dependency resolution in Gradle by controlling transitive dependencies, using exclude rules, module replacement, and a dependency constraint to ensure highest version appears on classpath for compile and runtime.

Learn techniques to keep a Gradle project well maintained, understandable, and extensible by organizing into logical subprojects and encapsulating build logic into reusable tasks or plugins.

Learn how to externalize configuration with Gradle project properties to keep credentials out of version control, enable publishing to Maven, and pass properties via -P, -D, env vars and gradle.properties.

Learn how to transform single-project repos into multi-project builds with Gradle, create subprojects, configure settings.gradle includes, and run targeted tasks for modular, faster builds.

Create a theme park manager with api, service, and ui subprojects in a single gradle spring boot app, exposing ride status and image paths via localhost 8080.

Learn to configure copy and zip tasks in Gradle, using single or multiple files and directories with relative paths, file trees, file collections, and layout references.

Extract build logic into a top-level build source to create reusable convention plugins that apply common repositories, dependencies, and test configurations across subprojects in a multi-project Gradle build.

Create a reusable custom task in Gradle by extending default task and using @TaskAction. Configure with Gradle properties, annotate inputs, and extract the task to build source for cross-project reuse.

Learn to create and configure custom plugins in Gradle, packaging tasks like file diff, applying plugins across projects, and using extensions to make plugins configurable.

Extract and publish a standalone gradle plugin by moving the plugin class, extension, and task into a new groovy-based project, then publish to local or remote maven repositories.

Write functional tests for a Gradle plugin, using Spock and Spark to run real Gradle builds with Gradle Test Kit, verifying file diff behavior across equal and unequal file sizes.

Learn to configure Gradle logging and use the logger for meaningful output. Use levels such as error, warn, info, debug, quiet, and lifecycle, with placeholders and the Gradle logger API.

Explore how the Gradle task graph reveals task dependencies in a Java project, showing the root task and tasks to optimize builds by selecting specific tasks or using dry run.

Learn how to specify dependencies in the Gradle build script and how Gradle resolves them, including transitive dependencies and version conflicts, with the dependencies task.

Explore how Jacoco with the Gradle plugin measures production code coverage, generates html reports, and uses a verification task to fail the build when coverage dips below 80%.

Enforce consistent code style across production and test code with the Gradle core Checkstyle plugin, using a customizable XML configuration to cover imports, indentation, and left curly placement.

Learn how PMD analyzes code during the build to enforce quality criteria, focusing on code quality beyond layout and encouraging logging frameworks over System.out.println.

Package your application's jar in a Docker image using Spring Boot boot image task with Cloud Native Buildpacks. Publish image to a registry and customize the boot build image task.

Centralize dependency versions in multi-project Gradle builds with version catalogs, defining libraries, plugins, and named versions using toml or settings file for a single source of truth.

Master Gradle essentials with this final recap, covering the three build lifecycle stages, Groovy and Kotlin DSLs, and best practices for Java projects, plugins, and multi-project builds.