Effective Gradle Implementation
3.4 (21 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.
240 students enrolled
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.4 (21 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.
240 students enrolled
Created by Packt Publishing
Last updated 11/2014
English
Current price: $10 Original price: $85 Discount: 88% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 3 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
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
Requirements
  • 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.
Description

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
Curriculum For This Course
74 Lectures
03:06:29
+
Getting Started
9 Lectures 26:01
Introduction
02:27

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.

Prerequisites
00:24

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
06:07

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
05:26

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
05:05

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
01:28

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
01:45

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

Conclusion
00:23
+
Gradle Tasks
7 Lectures 18:47

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

Introduction
00:53

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

build.gradle
04:29

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
03:04

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

Dynamic Tasks
01:48

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
02:43

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
01:46

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.

Introduction
00:24

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
05:31

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

Testing
05:02

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
02:26

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

Creating a Distribution
04:31

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
01:24

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
04:55

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

Conclusion
00:27
+
IDE Integration
5 Lectures 10:08

In this section we'll cover IDE integration

Introduction
00:15

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.

Eclipse
03:13

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.

NetBeans
03:07

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

Conclusion
00:18
+
Dependency Management
7 Lectures 14:09

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

Introduction
01:56

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

Dependency Types
01:05

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

Declaring Dependencies
02:35

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

External Dependencies
04:19

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
02:07

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

Conclusion
00:27
+
C++ Support
11 Lectures 23:24

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

Introduction
00:42

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
00:45

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

Plugins
02:35

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.

Libraries
02:02

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

Executables
01:44

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

Tasks
03:20

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
02:21

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

Project Dependencies
02:01

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

Publishing
03:08

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
02:35
+
Building JavaScript (gradle-js-plugin)
9 Lectures 15:44

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

Introduction
01:30

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
02:01

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
01:44

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

JSHint
01:54

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.

Props2JS
02:04

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.

RequireJS
02:28

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
01:00

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

Conclusion
00:45
+
Building Scala
7 Lectures 12:29

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

Introduction
00:18

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
04:09

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
01:21

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.

Dependencies
01:16

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
01:06

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

Conclusion
00:19
+
Continuous Integration Servers
5 Lectures 21:25

Let's understand what is Continuous Integration.

What Is Continuous Integration?
04:01

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
06:34

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.

Bamboo
03:00

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

Conclusion
00:49
+
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?
00:46

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

Artifactory
05:30

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.

Nexus
03:11

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

Conclusion
00:19
About the Instructor
Packt Publishing
4.0 Average rating
6,556 Reviews
48,568 Students
569 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.