Mastering Dependencies and Multi-Project Builds

COURSE SUMMARY

You might be familiar with the basic concepts of Gradle - tasks, dependency management, and multi-project builds - but what if your build needs to implement complex custom requirements or simply doesn’t look like a typical cookie-cutter project? Gradle provides a flexible approach for implementing logic that you don’t see on a regular basis with the help of its deep model and API.

This training is a one day, hands-on, instructor lead training course designed for Gradle users with basic knowledge of Gradle core concepts, who want to learn about advanced dependency management, flexible and highly-customizable multi-project builds, and techniques for troubleshooting and optimizing builds.

DURATION

One day (If delivered virtually: two sessions of 3.5 Hours + 30 minutes Q&A)

OBJECTIVES

Upon completion of this course you will get/learn…

• Deep understanding of Gradle’s API to implement complex build requirements


• Using Gradle’s powerful dependency management system to resolve dependencies by rules and further processing of their provided metadata


• Managing and implementing complex multi-project builds in an enterprise setting


• Identifying and solving performance issues in Gradle builds


• Debugging problems and root cause analysis in Gradle builds

AUDIENCE

This course is designed for developers, architects and build masters that want to get a deeper understanding of Gradle’s core APIs and how to use them to implement complex custom requirements in their builds.

PREREQUISITES

Basic knowledge of Gradle core concepts are required. Attendance of course Introduction to Gradle is recommended. A lot of the example code is going to be developed in Groovy. Basic knowledge of Groovy is expected.

OUTLINE

The proposed four-hour Gradle for Android course is divided into four hour-long segments, each providing time for some Q&A plus a short break before continuing into the next segment.

• Introduction

• Custom requirements in complex builds


• Gradle’s deep model and API as enabler


• Concepts covered in this course


• Introduction of case study build (used to exercise concepts)

• Advanced dependency management

• Recap: Gradle’s basic dependency management features


• Gradle’s dependency cache
  
  
  
  • Location and structure
  
  
  • Performance features
  
  
  • Caching of dynamic and changing artifact versions
  
  
  • Configuring caching rules
  
  
  • Lab: Changing the TTL for dynamic and changing artifact version
  
  
  
  


• Using dependency resolve rules
  
  
  
  • Enforcing artifact versions
    
    
    
    • Implementing the concept
    
    
    • Lab: Enforce a specific version of Spring framework in a build
    
    
    
    
  
  
  • Making dependency version recommendations
    
    
    
    • Storing a mapping of dependency attribute to recommended version
    
    
    • Implementing the concept
    
    
    • Lab: Using version recommendations stored in a data structure for dependency declarations
    
    
    
    
  
  
  • Replacing legacy artifacts
    
    
    
    • The need to replacing artifacts
    
    
    • Implementing the concept
    
    
    • Lab: Replacing Google Collection with Guava
    
    
    
    
  
  
  
  


• Using component metadata rules
  
  
  
  • Use cases
  
  
  • Modifying dependency metadata
  
  
  • Lab: Marking dependency with a custom “status” attribute as changing
  
  
  • Defining fine-grained metadata rules
  
  
  • Lab: Applying rules for matching module
  
  
  
  


• Using the artifact query API
  
  
  
  • Use cases
  
  
  • Querying for raw metadata artifacts
    
    
    
    • Resolving source and javadoc artifacts
    
    
    • Resolving metadata artifacts (ivy.xml, pom.xml)
    
    
    
    
  
  
  • Lab: Generating an offline repository
  
  
  
  

• Advanced multi-project builds

• Structuring multi-project builds
  
  
  
  • Single build file
  
  
  • Multiple build files
  
  
  • Hybrid approach
  
  
  • Weighing the options
  
  
  • Lab: Configuring a multi-project build with different approaches
  
  
  
  


• Settings configuration
  
  
  
  • Recap: Evaluation of settings during Gradle’s build lifecycle
  
  
  • How is the settings file resolved?
  
  
  • Options for configuring the project name
  
  
  • Creating projects dynamically as part of the settings logic
  
  
  • Lab: Configuring projects dynamically from an external JSON definition
  
  
  • Mapping dynamically created projects to IDE mappings
  
  
  • Lab: Configuring the Gradle Eclipse/IDEA plugins
  
  
  • Externalizing settings logic into a plugin
  
  
  • Lab: Writing a plugin that works on Settings instance
  
  
  
  


• Assembling detached projects into a multi-project build
  
  
  
  • Typical workflow
  
  
  • The need to assembling builds in developer environments
  
  
  • Implications
  
  
  • Custom solutions to this problem
    
    
    
    • Extending Gradle’s DSL to allow for dynamically resolving artifact or project dependencies
    
    
    • Lab: Implement approach in Gradle build
    
    
    • A look at Prezi Pride
    
    
    
    
  
  
  • Dependency substitution rules
    
    
    
    • Replace external with project dependency
    
    
    • Replace project with external dependency
    
    
    • Lab: Replacing dependencies in a multi-project build
    
    
    
    
  
  
  • Out-of-the-box DE support (Eclipse STS)
  
  
  • How does it work under the covers?
  
  
  • Lab: Building independent projects as multi-project builds with STS
  
  
  
  

• Optimizing and debugging builds

• Discovering bottlenecks in a build


• General performance implications


• Profiling a Gradle build


• Performance optimizations
  
  
  
  • Using the Gradle daemon
    
    
    
    • When should I use the daemon?
    
    
    • Daemon health monitoring
    
    
    • Lab: Configuring the daemon for all developer builds
    
    
    
    
  
  
  • Enabling parallel execution
    
    
    
    • How does it work under the covers?
    
    
    • Lab: Using parallel execution for multi-project and task build execution
    
    
    
    
  
  
  • Enabling configure on demand
    
    
    
    • How does it work under the covers?
    
    
    • Lab: Using configure on demand for a multi-project build
    
    
    
    
  
  
  • Managing large multi-project builds
    
    
    
    • Structuring large builds
    
    
    • Performance implications
    
    
    • Optimizing for performance
    
    
    
    
  
  
  
  


• Debugging Gradle builds
  
  
  
  • Scenario: Understand why build fails
    
    
    
    • Using command line options to get relevant information
    
    
    • Interpreting stack traces
    
    
    • Mapping the stack trace to Gradle core source code
    
    
    • Strategies for understanding the issue
    
    
    • Lab: Resolving a configuration issue
    
    
    
    
  
  
  • Scenario: Understanding why dependency cannot be resolved
    
    
    
    • Configuring build to render appropriate logs
    
    
    • Interpreting emitted HTTP calls
    
    
    • Lab: Fixing a failed dependency resolve
    
    
    
    
  
  
  • Scenario: Understanding internals/behavior of Gradle core and plugins
    
    
    
    • Configuring remote debugging
    
    
    • Attaching the Gradle core source code
    
    
    • Stepping through Gradle core and Gradle plugin code
    
    
    • Lab: Using remote debugging to identify issue