Groovy & Gradle: JVM Automation and Build Engineering · Leçon

Construire des modules d’extension binaires

Développez des modules d’extension binaires autonomes avec Groovy ou Java, puis empaquetez-les pour leur distribution.

Construire des modules d’extension binaires est une leçon Groovy & Gradle: JVM Automation and Build Engineering gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Groovy & Gradle: JVM Automation and Build Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why Binary Plugins?

Welcome! In this lesson, we'll dive into building binary plugins for Gradle. Unlike simpler script plugins, binary plugins are compiled code (Java or Groovy) that offer superior reusability and structure.

Reusability: Easily share across many projects.
Encapsulation: Keep your build logic clean and organized.
Testability: Easier to unit test complex logic.

Setting Up Your Plugin Project

A binary plugin is typically developed in its own Gradle project. For local development, a common approach is to place your plugin source code within the buildSrc directory of your main project.

The standard structure looks like this:

rootProject/
buildSrc/
src/main/groovy/com/coddykit/plugins/
MyPlugin.groovy
build.gradle
build.gradle (for the consumer project)

The Plugin<Project> Interface

Every binary Gradle plugin must implement the org.gradle.api.Plugin interface, specifically Plugin<Project>. This interface defines a single method: apply(Project project).

The Project object passed to apply is the project the plugin is being applied to. This is your entry point to configure that project.

package com.coddykit.plugins

import org.gradle.api.Plugin
import org.gradle.api.Project

class MyFirstPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        // Plugin logic goes here
        // You can add tasks, extensions, etc.
    }
}

Plugin's Core: apply Method

The apply method is where your plugin's magic happens. Inside this method, you can perform various actions to configure the target project, such as:

Creating custom tasks.
Adding new configurations.
Registering extensions for user configuration.
Applying other plugins.

This method runs when Gradle applies your plugin to a project.

Adding a Simple Task

Let's create a basic plugin that adds a custom task named helloGradle to any project it's applied to. This task will simply print a greeting message.

We'll put this class in buildSrc/src/main/groovy/com/coddykit/plugins/GreetingPlugin.groovy.

package com.coddykit.plugins

import org.gradle.api.Plugin
import org.gradle.api.Project

class GreetingPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        project.tasks.create('helloGradle') {
            doLast {
                println "Hello from CoddyKit's Greeting Plugin!"
            }
        }
    }
}

Declaring Your Plugin ID

To make your plugin discoverable, you need to declare a unique ID for it in the plugin project's build.gradle file. This maps your plugin class to an ID that consumer projects will use.

This example build.gradle would be placed in buildSrc/build.gradle.

plugins {
    id 'java-gradle-plugin' // Enables Gradle plugin development features
    id 'groovy' // If your plugin is written in Groovy
}

repositories {
    mavenCentral()
}

dependencies {
    implementation gradleApi() // Provides Gradle API classes
    implementation localGroovy() // Provides Groovy classes
}

gradlePlugin {
    plugins {
        greetingPlugin {
            id = 'com.coddykit.greeting'
            implementationClass = 'com.coddykit.plugins.GreetingPlugin'
        }
    }
}

// To build this plugin: gradle build (from buildSrc dir)

Using Your Custom Plugin

Now that our GreetingPlugin is defined and has an ID, we can apply it to a consumer project. If the plugin is in buildSrc, it's automatically available to the root project.

Add this to your root project's build.gradle file:

plugins {
    id 'com.coddykit.greeting' // Apply our custom plugin by ID
}

// To run the task:
// 1. Ensure GreetingPlugin is in buildSrc
// 2. Open terminal in your project's root
// 3. Run: gradle helloGradle

Plugin Extensions for Configuration

For powerful and flexible plugins, you'll want to allow users to configure them. Gradle extensions are objects that plugins add to a project, providing a DSL (Domain Specific Language) for configuration.

You define an extension class with properties, then register it in your plugin's apply method. Users can then configure these properties in their build.gradle.

Plugin with Configuration

Here's an example of a plugin that uses an extension. First, the extension class (CoddyKitExtension.groovy) defines configurable properties. Then, the plugin (ConfigurablePlugin.groovy) creates an instance of this extension and registers it with the project, also creating a task that uses the configured message.

// src/main/groovy/com/coddykit/plugins/CoddyKitExtension.groovy
package com.coddykit.plugins

class CoddyKitExtension {
    String message = "Default CoddyKit message"
}

// src/main/groovy/com/coddykit/plugins/ConfigurablePlugin.groovy
package com.coddykit.plugins

import org.gradle.api.Plugin
import org.gradle.api.Project

class ConfigurablePlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        // Create and register the extension
        def extension = project.extensions.create('coddyKit', CoddyKitExtension)

        project.tasks.create('displayConfigMessage') {
            doLast {
                println "CoddyKit Plugin says: ${extension.message}"
            }
        }
    }
}

Binary Plugin Check

Which of the following are key benefits of using a binary Gradle plugin compared to a simple script plugin?

Recap: Building Binary Plugins

Great job! You've learned the fundamentals of building binary Gradle plugins:

Binary plugins offer reusability, encapsulation, and testability for your build logic.
They implement the Plugin<Project> interface, with core logic in the apply method.
You declare a unique plugin ID in your plugin project's build.gradle.
Extensions provide a way for users to configure your plugin.

Next, we'll explore how to apply and publish these powerful plugins!

Questions Fréquemment Posées

La leçon « Construire des modules d’extension binaires » est-elle gratuite ?

Oui — le texte complet de « Construire des modules d’extension binaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Groovy & Gradle: JVM Automation and Build Engineering, passe à CoddyKit PRO. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire des modules d’extension binaires » ?

Développez des modules d’extension binaires autonomes avec Groovy ou Java, puis empaquetez-les pour leur distribution. Tu pratiques Groovy & Gradle: JVM Automation and Build Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Groovy & Gradle: JVM Automation and Build Engineering ?

Aucune expérience préalable n'est requise. Groovy & Gradle: JVM Automation and Build Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Construire des modules d’extension binaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Groovy & Gradle: JVM Automation and Build Engineering ?

Oui. Chaque leçon Groovy & Gradle: JVM Automation and Build Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Comprendre les modules d’extension Gradle
Construire des modules d’extension binaires
Appliquer et publier des modules d’extension
Extensions de plugins et DSL configurables

← Retour à Groovy & Gradle: JVM Automation and Build Engineering