Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Effective Gradle Implementation to your Wishlist.

Add to Wishlist

Effective Gradle Implementation

Build, automate, and deploy your application using Gradle
3.2 (14 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
198 students enrolled
Last updated 11/2014
$10 $85 88% off
5 days left at this price!
30-Day Money-Back Guarantee
  • 3 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?

This course will show you how to use Gradle effectively and will help you overcome these issues with the build tool called Gradle. The authors, Ryan and Lee, will take the user from a point of having just a basic development background to being able to implement Gradle in a variety of languages, utilizing Gradle in some beneficial ways including continuous integration and artifact management.

You will learn to build and deploy your code effectively. Gradle is quickly becoming the de facto build tool for Java, Groovy, C++, and other platforms, and is rapidly replacing Maven and Ant systems. Learn how to integrate your IDE, leverage Ant or Maven build assets, deploy artifacts, and integrate with continuous integration servers. You can follow along with step-by-step instructions for the most common IDEs, programming languages, and artifact servers to implement.

You will leave the course feeling like you have a good handle on Gradle and confident to begin planning and building your implementation.

About the Author

Lee Fox is a technologist with a strong background in software development. He has served in architecture roles for companies like 3M, AT&T Wi-Fi Services, Borland, and Pervasive. His software development history has always focused on maintaining quality. He is an Agile pragmatist as he strives to help organizations become more effective in their technical and software development implementations while maintaining a high degree of quality. Lee received his Bachelor of Science in Computer Science from Southwest Texas State University. He is also a Certified ScrumMaster and Trained Innovation Games Facilitator. Lee is co-founder of Xan Endeavors.

Ryan is the Chief Systems and Software Architect and Director of Products at ReachForce, and was formerly Lead Architect. He maintains the grails-quartz plugin, GVPS Grails plugin, and Struts 1 plugins, and is co-chair of the Austin Groovy and Grails User Group in Austin, TX. Ryan is currently building a Grails infrastructure for ReachForce as well as teaching Grails to the developer team. Ryan is also the co-founder of Xan Endeavors, LLC, a collaboration of software development, consulting, coaching, and innovation games. In the past, Ryan has architected a Grails solution that allows rapid deployment of Developer Program portals for all kinds of companies, specializing in the mobile industry. He has also built Java- and Linux-based webcasting for events such as SXSW, built telecom software, and SaaS systems for the financial sector.

Who is the target audience?
  • If you are a developer, devops engineer, build engineer, or IT administrator and wish to effectively implement Gradle in your projects, this course is for you. The course takes you through the installation process and how to set up your projects followed by dependency management, IDE integration, and plugin implementations. You also learn to deploy and publish your application.
Students Who Viewed This Course Also Viewed
What Will I Learn?
Create a build.gradle file and manage build dependencies
Integrate Gradle with popular IDEs such as IntelliJ, Eclipse, and Netbeans
Build Java, Scala, and Groovy applications with Gradle
Implement C/C++ and JavaScript applications with Gradle
Utilize Gradle within a Continuous Integration Loop
Integrate Gradle with Artifact Management
Incorporate external dependencies such as Maven and Ivy repositories
View Curriculum
  • Basic Java development knowledge is a prerequisite.
  • This example-driven video tutorial shows you how to effectively implement Gradle in your projects through a variety of plugins and integration techniques.
Curriculum For This Course
Expand All 74 Lectures Collapse All 74 Lectures 03:06:29
Getting Started
9 Lectures 26:01

Even though we need to start somewhere, there are still some things that are required as prerequisites. In this section, we will look at the prerequisites you need to have in place before you install Gradle.


Installing software on various platforms can be annoying. Fortunately, there is a tool called GVM that will make installing Gradle and keeping track of versions much easier. In this section, we will take a look at installing and using GVM.

Preview 02:56

Sometimes, there is a need to manually install Gradle. In this section, we will show you how to install Gradle on Windows, OS X, and Linux.

Manual Installation in Windows/Mac/Linux

Not every installation goes as smoothly as we would like. So, in this section, we will look at some common problems and solutions to help you past issues while installing Gradle.

Installation Troubleshooting

Gradle has a lot of structure in its default binary installation. Getting to know that structure will help you better create the builds that best fit your environment. In this section, we will look at the binary installation structure for Gradle itself.

Gradle Installation Binaries

The default Gradle project has a good deal of structure. To ensure the structure helps you rather than hinders you, we will look at the default project structure in this section.

Default Project Layout

With today's technology, portability is a need that is almost always there, but sometimes overlooked. Gradle has a facility called Gradle wrapper to help with portability issues. In this section, we will look at the Gradle wrapper.

Gradle Wrapper

In this section we've learnt how to install Gradle and keep up with current versions of Gradle.

Gradle Tasks
7 Lectures 18:47

In this section we'll learn how to create Tasks in Gradle.


The heart and soul of a Gradle configuration is the build.gradle file. In this section, we will have a look at it.


With Gradle so tightly involved with its Groovy-based DSL, it makes sense to spend some time getting to know Groovy. In this section, we will get a quick taste of Groovy.

A Taste of Groovy

How to create a task on the fly that isn't predeclared in your build file.

Dynamic Tasks

Control flow of the execution of tasks in the case of errors. Also, control flow by making some tasks always run before or after others to avoid build code duplication.

Gradle Tasks API

If you are coming from an Ant environment, it'll be nice to know how to leverage your Ant builds to make the transition easier and more cost effective. In this section, we will look at using Ant tasks to do so.

Using Ant Tasks

We will see how to control the flow of certain tasks during the execution phase to create different types of artifacts. If certain dynamic tasks are available at runtime, we need to take certain actions.

Preview 04:04
Java, Groovy, and WAR Plugins
9 Lectures 27:49

In this section we're going to cover how to build and setup a basic and multimodule Java Project.


What kind of tasks do we need to know about to build a Java project? We will go over the tasks of the Java plugin and how to run it.

Preview 03:09

Learn how to hook into Maven and publish an artifact to your local repository.

Hooking into Maven

Learn how test code is normally organized, what frameworks are supported, and how to write tests.


Walk through an example multimodule project and see how to access tasks from subprojects. Learn proper structure and how to use them to bring in a Maven or Ivy sub project.

Multimodule Java Projects

Create a ZIP file with your application and related files for distribution.

Creating a Distribution

Build a Groovy project and learn how to use the tasks. Learn how the srcDir property works in relation to Groovy files.

Groovy Plugin Tasks

For an average Java developer, the endgame of a build environment is to turn out a WAR file. In this section, we will look at how we can create a WAR file using Gradle.

Building a WAR

In this section we covered a bunch of things such as Java and Groovy plugin tasks, hooking into Maven, Testing, and WAR files.

IDE Integration
5 Lectures 10:08

In this section we'll cover IDE integration


IntelliJ IDEA is a very popular and very powerful IDE. In this section, we will look at integrating Gradle with IntelliJ IDEA and build a sample project in the IDE.

Preview 03:15

Eclipse is a very popular and free IDE that is chock-full of features. In this section, we will look at integrating Eclipse with Gradle and build a project.


NetBeans is a rather powerful IDE with a wide reach. In this section, we will look at the support for Gradle and build a sample project.


In this section we looked at three popular IDEs, IntelliJ Idea, Eclipse, and NetBeans.

Dependency Management
7 Lectures 14:09

In this section we'll be talking about Dependency Management.


Learn what the different dependency types are in Gradle and see examples of each in action.

Dependency Types

See how to use a runtime, compile, test, and project dependency for your project.

Declaring Dependencies

Configure dependencies for Maven and Ivy repositories. See examples of long and short notation to resolve artifacts.

External Dependencies

Publish Maven and Ivy artifacts like a pro on a local Maven repository or remote Ivy repository.

Preview 01:40

How do you keep test libraries out of your distributable artifacts? Use configurations like scopes and see examples in action.

Dependency Configurations

·In this section we've covered the six types of dependencies, internal and external dependencies, Maven and Ivy repositories, and declaring dependencies.

C++ Support
11 Lectures 23:24

In this section we'll jump into building native binaries with our Gradle Scripts.


What does the CPP plugin support? In this section, we will look at the platform support and the language support offered by the plugin.

Supported Platforms

How do you install the CPP plugin? Here, we will show what plugins to use and give you an overview of their tasks.


How do you build a library? What tasks help you build a library? This section will show how to build a shared or static library.


This section will show how to build a native executable and show how to use the toolchain variable.


We dive deeper into the CPP plugin tasks to build and install executables.


Here, we show how to configure different compiler and linkers. Use the toolchain variable and binary types to build on multiple platforms.

Preview 02:11

Advances with external dependencies since 1.11 and what is still lacking.

External Dependencies

Use the multimodule project in concert with a native CPP project.

Project Dependencies

We will go over your options for publishing the native artifacts support and a plugin to help you do so.


Portability and internationalization can be challenging. In this section, we will address that through the use of variants like platforms and flavors.

Native Support for Variants
Building JavaScript (gradle-js-plugin)
9 Lectures 15:44

In this section we'll talk about the Gradle JavaScript plugin


A build system that can entertain JavaScript files is a very awesome thing. In this section, we will look at enabling the GradleJS plugin and specifying our JavaScript files for a build.

Specifying Your Sources

Lots of web applications seem to have numerous JavaScript files that keep code scattered and unorganized. In this section, we will see how the Gradle JavaScript plugin helps to manage the chaos by combining the sources.

Combining Your Sources

Discovering problems early can really help improve a project's development. In this section, we will look at how static code analysis using JSHint can accomplish that for JavaScript


Even JavaScript developers need to produce documentation. JSDoc offers a solution to help generate some of that documentation from source listings. In this section, we will look at integrating JSDoc with Gradle.

Preview 02:18

It's nice to have a way to manage configuration files and settings when doing JavaScript development. In this section, we will look at how to integrate Props2Js into our Gradle builds.


To help improve the quality of our JavaScript code, we need a script loader to help us out. This section will show how to integrate Gradle with RequireJS to achieve those aims.


If you are developing JavaScript, you are most likely going to be using a lot of CSS. In this section, we will lightly cover the Gradle CSS plugin to help you deal with CSS files in your build.

Gradle CSS Plugin

In this section we broadly covered the Gradle JavaScript plugin and lightly touched on the functionality in the CSS plugin.

Building Scala
7 Lectures 12:29

In this section we'll learn about the Scala Plugin Support.


When starting to learn about a new plugin, it's nice to go over the basics of that plugin. In this section, we will look at enabling the Scala plugin and go over some of the tasks it provides.

Usage and Tasks

To best use the Scala plugin, we need to understand how it's laid out. In this section, we will explore the layout of a Scala project and how to specify sources.

Project Layout

The Scala plugin offers us several options for compiler support. To help alleviate confusion, this section will take a look at compiler setup and compilation with the Scala plugin.

Preview 04:00

Dependencies are a crucial item to understand and handle for any development. Scala is no different. In this section, we will look at dependencies with the Scala plugin.


Nothing will drive a developer crazier than a slow build. In this section, we will try to save some developer sanity by seeing how we can speed up a Scala build with Fast Compiler Support.

Fast Compiler Support

In this section we've covered usage and Tasks, Project Layout, Compiler Setup, Dependencies, and Fast Compiler Support.

Continuous Integration Servers
5 Lectures 21:25

Let's understand what is Continuous Integration.

What Is Continuous Integration?

Jenkins is a very powerful continuous integration server in wide use across the industry. In this section, we will look at integrating Jenkins and Gradle. Then we will configure a Jenkins Gradle build.

The Jenkins/Hudson Plugin

TeamCity is a very solid continuous integration server made by JetBrains. It's vastly popular for companies willing to invest money into this part of their infrastructure. In this section, we will look at the support TeamCity has for Gradle and run a Gradle build.

Preview 07:01

Bamboo is Atlassian's continuous integration server. In this section, we will look at Gradle integration with Bamboo and configure a Gradle build.


In this section we learnt about what Continuous Integration is, and covered three of the most popular CI servers.

Repository Managers
5 Lectures 16:33

In this section we'll learn what a Repository Manager is, and which of the Repository Managers are recommended.

What Is Repository Management?

Artifactory is a very popular repository manager. In this section, we will look at Artifactory integration with Gradle.


Bintray is becoming more and more popular with developers. In this section, we will look at integrating your Gradle builds with bintray.

Preview 06:47

Nexus is a great standard for repository managers. In this section, we will look at Gradle integration with Nexus.


In this section we've covered publishing your project to a repository manager service, whether its Artifactory, Bintray or Nexus.

About the Instructor
3.9 Average rating
3,593 Reviews
29,534 Students
311 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.

Report Abuse