Groovy & Gradle: JVM Automation and Build Engineering · Lección

Construcción de plugins binarios

Desarrolle plugins binarios independientes con Groovy o Java y empaquételos para distribuirlos.

Construcción de plugins binarios es una lección gratuita de Groovy & Gradle: JVM Automation and Build Engineering en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Groovy & Gradle: JVM Automation and Build Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Groovy & Gradle: JVM Automation and Build Engineering incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

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!

Preguntas frecuentes

¿La lección «Construcción de plugins binarios» es gratis?

Sí — el texto completo de «Construcción de plugins binarios» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Groovy & Gradle: JVM Automation and Build Engineering, actualiza a CoddyKit PRO. El curso de Groovy & Gradle: JVM Automation and Build Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Construcción de plugins binarios»?

Desarrolle plugins binarios independientes con Groovy o Java y empaquételos para distribuirlos. Practicas Groovy & Gradle: JVM Automation and Build Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Groovy & Gradle: JVM Automation and Build Engineering?

No se requiere experiencia previa. Groovy & Gradle: JVM Automation and Build Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Construcción de plugins binarios»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Groovy & Gradle: JVM Automation and Build Engineering?

Sí. Cada lección de Groovy & Gradle: JVM Automation and Build Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Comprensión de los plugins de Gradle
Construcción de plugins binarios
Aplicación y publicación de plugins
Extensiones de plugins y DSL configurables

← Volver a Groovy & Gradle: JVM Automation and Build Engineering