Untitled (original) (raw)

Gradle User Manual

• Getting Started

Gradle Tutorials

• Beginner Tutorial
  • 1. Initializing the Project
  • 2. Running Tasks
  • 3. Understanding Dependencies
  • 4. Applying Plugins
  • 5. Exploring Incremental Builds
  • 6. Enabling the Build Cache
• Intermediate Tutorial
  • 1. Initializing the Project
  • 2. Understanding the Build Lifecycle
  • 3. Multi-Project Builds
  • 4. Writing the Settings File
  • 5. Writing a Build Script
  • 6. Writing Tasks
  • 7. Writing Plugins
• Advanced Tutorial
  • 1. Initializing the Project
  • 2. Adding an Extension
  • 3. Creating a Custom Task
  • 4. Writing a Unit Test
  • 5. Adding a DataFlow Action
  • 6. Writing a Functional Test
  • 7. Using a Consumer Project
  • 8. Publish the Plugin

Gradle Releases

• All Releases
• Release Notes
• Installing Gradle
• Upgrading Gradle
  • Within versions 9.x.y
  • To version 9.0.0
  • Within versions 8.x
  • From version 7.x to 8.0
  • From version 6.x to 7.0
  • From version 5.x to 6.0
  • From version 4.x to 5.0
• Migrating to Gradle
  • from Maven
  • from Ant
• Compatibility Notes
• Gradle's Feature Lifecycle

Gradle Fundamentals

• Learning Gradle Basics
  • 1. Core Concepts
  • 2. Wrapper Basics
  • 3. CLI Basics
  • 4. Settings File Basics
  • 5. Build File Basics
  • 6. Dependencies Basics
  • 7. Tasks Basics
  • 8. Caching Basics
  • 9. Plugins Basics
  • 10. Build Scan Basics
• Writing Build Scripts
  • 1. Anatomy of a Gradle Build
  • 2. Structuring Multi-Project Builds
  • 3. Gradle Build Lifecycle
  • 4. Writing Build Scripts
  • 5. Gradle Managed Types
  • 6. Declaring Dependencies
  • 7. Creating and Registering Tasks
  • 8. Working with Plugins
• Creating Plugins
  • 1. Plugin Introduction
  • 2. Pre-Compiled Script Plugins
  • 3. Binary Plugins
  • 4. Developing Binary Plugins
  • 5. Testing Binary Plugins
  • 6. Publishing Binary Plugins

Gradle Reference

• Runtime and Configuration
  • Command-Line Interface
  • Logging and Output
  • Gradle Wrapper
  • Gradle Daemon
  • Gradle Directories
  • Build Configuration
  • Build Lifecycle
  • Build Scan
  • Continuous Builds
  • File System Watching
• DSLs and APIs
  • Java API
  • Groovy DSL Primer
  • Groovy DSL
  • Kotlin DSL Primer
  • Kotlin DSL
  • Public APIs
  • Default Script Imports
  • Groovy to Kotlin DSL Migration
• Gradle Managed Types
  • Lazy vs Eager Evaluation
  • Properties and Providers
  • Collections
  • Services and Service Injection
  • Dataflow Actions
  • Working with Files
• Tasks
  • Understanding Tasks
  • Controlling Task Execution
  • Organizing Tasks
  • Implementing Custom Tasks
  • Lazy Configuration
  • Parallel Task Execution
  • Advanced Task Development
  • Shared Build Services
• Plugins
  • Introduction to Plugins
  • Precompiled Script Plugins
  • Convention Plugins
  • Binary Plugins
  • Testing Plugins
  • Preparing to Publish
  • Publishing Plugins
  • Reporting Plugin Problems
  • Initialization Scripts & Init Plugins
  • Testing with TestKit
  • Core Plugins
• Dependencies
  • Getting Started
  • Learning the Basics
    * 1. Declaring Dependencies
    * 2. Dependency Configurations
    * 3. Declaring Repositories
    * 4. Centralizing Dependencies
    * 5. Dependency Constraints and Conflict Resolution
  • Advanced Concepts
    * 1. Dependency Resolution
    * 2. Graph Resolution
    * 3. Variant Selection
    * 4. Artifact Resolution
  • Declaring Dependencies
    * Declaring Dependencies
    * Viewing Dependencies
    * Declaring Versions and Ranges
    * Declaring Dependency Constraints
    * Creating Dependency Configurations
    * Gradle Distribution-Specific Dependencies
  • Declaring Repositories
    * Declaring Repositories
    * Centralizing Repository Declarations
    * Repository Types
    * Metadata Formats
    * Supported Protocols
    * Filtering Repository Content
  • Centralizing Dependencies
    * Creating Platforms
    * Creating Version Catalogs
    * Using Catalogs with Platforms
  • Managing Dependencies
    * Locking Versions
    * Using Resolution Rules
    * Modifying Dependency Metadata
    * Caching Dependencies
  • Controlling Dependency Resolution
    * Consistent Dependency Resolution
    * Resolving Specific Artifacts
    * Capabilities
    * Variants and Attributes
    * Artifact Views
    * Artifact Transforms
  • Publishing Libraries
    * Setting up Publishing
    * Understanding Gradle Module Metadata
    * Signing Artifacts
    * Customizing Publishing
    * Maven Publish Plugin
    * Ivy Publish Plugin
• Platforms
  • JVM Builds
    * Building Java & JVM projects
    * Testing Java & JVM projects
    * Java Toolchains
    * Managing Dependencies
    * JVM Plugins
    * Java Library Plugin
    * Java Application Plugin
    * Java Platform Plugin
    * Groovy Plugin
    * Scala Plugin
  • C++ Builds
    * Building C++ projects
    * Testing C++ projects
  • Swift Builds
    * Building Swift projects
    * Testing Swift projects
• Best Practices
  • Introduction
  • Index
  • General Best Practices
  • Best Practices for Structuring Builds
  • Best Practices for Dependencies
  • Best Practices for Tasks
  • Best Practices for Performance
  • Best Practices for Security
• Other Topics
  • Using Ant from Gradle

Structuring Gradle Builds

• Organizing Projects
• Multi-Project Builds
• Sharing Build Logic
• Composite Builds
• Configuration on Demand
• Isolated Projects

Optimizing Gradle Builds

• Improving Performance
• Build Cache
  • Enabling and Configuring
  • Why use the Build Cache?
  • Understanding the Impact
  • Learning Basic Concepts
  • Caching Java Project
  • Caching Android Project
  • Debugging Caching Issues
  • Troubleshooting
• Configuration Cache
  • How it Works
  • Enabling and Configuring
  • Requirements for your Build Logic
  • Debugging and Troubleshooting
  • Status

Securing Gradle Builds

• Supply Chain Security
• Verifying Dependencies

IDE & Tool Integration

• Third-party Tools
• APIs
  • Tooling API
  • Test Reporting API

How-To-Guides

• Structuring Builds
  • Convert a Single-Project Build to Multi-Project
• Dependency Management
  • How to Downgrade Transitive Dependencies
  • How to Upgrade Transitive Dependencies
  • How to Exclude Transitive Dependencies
  • How to Prevent Accidental or Eager Dependency Upgrades
  • How to Align Dependency Versions
  • How to Share Outputs Between Projects
  • How to Resolve Specific Artifacts from a Module Dependency
  • How to Use a Local Fork of a Module Dependency
  • How to Fix Version Catalog Problems
  • How to Create Feature Variants of a Library

More Resources

• Samples
• Glossary
• Single Page Version