
Master Gradle from the ground up by learning the domain specific language, Groovy, the Gradle lifecycle, and domain objects with plugins, plus Eclipse and Buildkit workflows for Java projects.
Lets find out about some of the benefits to using Gradle!
Groovy upto now has been the main language of choice for Gradle - this is changing with the introduction of the Kotlin programming language. But Groovy remain a big player in Gradle... so lets take a look!
For Gradle and the Eclipse IDE we need the Java JDK installed on our machines. Lets see how to do that!
I'm going to start by introducing the minimum requirements for a Gradle project.
Groovy is used in a special way in Gradle, so lets take look at that!
Explore Groovy's optional typing with the def keyword, observe runtime type safety and the risk of runtime exceptions for type mismatches, and note compile-time checks introduced by Kotlin in Gradle.
Lets dive into Groovy 'Strings' and how they work!
Groovy 'Properties' and how they work withing Gradle
Closures are such a big part of the Groovy language and therefor also play a key role in Gradle.
An even deeper look at Groovy closures.
Explore the Gradle lifecycle, detailing the initialization, configuration, and execution phases; learn how Gradle selects projects, maps build scripts, and executes tasks to run a build.
Explore how the Gradle build lifecycle unfolds, and how build scripts, the build.gradle file, and the Gradle object model interact through the project, settings, and init scripts.
Explore how the Gradle object and its delegate empower build scripts to access version information, Gradle home, and logging, using the logger and concise dot notation.
Explore how the project object serves as the default context for build scripts in build.gradle, and use its properties and methods like buildFile and relativePath with the Gradle API.
Lets start looking at and using Gradle Properties.
Lets take a look at how Tasks and Actions fit in with the Gradle Lifecycle
Tasks are totally configurable - so lets take a look at how to do that...
Learn how to define task dependencies with dependsOn to form a task graph. Gradle uses this graph in the configuration phase to determine the execution order during the build lifecycle.
Explore using a closure with dependsOn to filter project tasks via find all, returning a single task or a collection for dependencies like do start process and do step two.
Master the Gradle dependsOn dot notation to attach task dependencies, using static and dynamic approaches with conditional logic and comma-separated lists of tasks.
Before the build is performed, Gradle builds a graph of all the Tasks - lets take a look at how this works.
The task dependency graph provides us some really convenient 'call-back' methods.
Plugins are a major part of Gradle, so lets start looking at them.
Most non-trivial Java applications these days depend on 3rd part software. Lets take a look at how we can set that up...
Learn how Gradle builds a Java application using the build ship plugin, running clean and build tasks, inspecting the jar in build/libs, and reviewing test reports and Java doc outputs.
Create a Gradle copy task to deploy a war to Tomcat's webapps, using archive path, properties, and optional dependency on the war task to ensure proper deployment.
Welcome to The Gradle Mastery Course !
Where you will learn the intricacies and nuances of one of the most advanced software Build Tools on the planet ...
In this course you'll learn about Gradle from the ground up.
Starting with the corner stones of Gradle; the Domain Specific Language or DSL, the Domain Object Model and Lifecycle.
Gradle relies heavily on what is called a Domain Specific Language or DSL.
For along time Groovy has been Gradles go to DSL language. So it makes sense to start there and I provide you with a good understanding in how to use Groovy with Gradle, so you can get the maximum benefit from both. Later in the course I also take a look at using Kotlin as the DSL and what IDE support there is available for this amazing programming language.
I then set the scene of how Gradle works from the inside out, by looking at the Gradle Lifecycle (... something that is often over looked!!).
You'll get to understand that mastering the Gradle Lifecycle and associated Domain Objects is the key to getting that 'A-ha!' moment with Gradle. (This alone will put you streets ahead of other developers.)
You'll learn that mastering the wide variety of Domain Objects that come with Gradle and its 'Plugins' are another key that unlocks the power of Gradle.
From single Java projects to complex Multi-Project Java Web applications – these can easily be handled by Gradle and with the examples used in this course you'll have plenty of guidance and experience to use on you're very own projects and lead the way forward. Creating world class, leading edge build scripts, with arguably the most powerful and modern build tool on the planet!
In this course I cover the basics of the Groovy language used by Gradle, later in the course I also touch upon using Kotlin as well.
I cover in-depth the Gradle Lifecycle and how to hook into it, so we get the full benefit of Gradles power.
I cover a variety of Gradles Domain Objects and how to successfully manipulate them, as well as 'Plugins' – in particular the Java Plugin.
The Gradle 'Wrapper is also covered in some detail.
I look at the Buildship plugin for Eclipse and how that works. (The course is mainly based on using this platform.)
The examples used in this course are various and all Java Projects. From single applications to Multi-Project Web Applications, all built and deployed using Gradle.
The ideal student for this course is any Java developer who is looking to expand on their current skills.
There're no requirements to enroll on this course, only that you have some prior knowledge of Java,
I only ask that you come open minded and ready to learn.