Groovy & Gradle: JVM Automation and Build Engineering · Pelajaran

Membangun Plugin Biner

Kembangkan plugin biner mandiri menggunakan Groovy atau Java, lalu kemas untuk didistribusikan.

Membangun Plugin Biner adalah pelajaran Groovy & Gradle: JVM Automation and Build Engineering gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Groovy & Gradle: JVM Automation and Build Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Plugin Biner” gratis?

Ya — teks lengkap “Membangun Plugin Biner” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Groovy & Gradle: JVM Automation and Build Engineering, upgrade ke CoddyKit PRO. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Plugin Biner”?

Kembangkan plugin biner mandiri menggunakan Groovy atau Java, lalu kemas untuk didistribusikan. Kamu berlatih Groovy & Gradle: JVM Automation and Build Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Groovy & Gradle: JVM Automation and Build Engineering?

Tidak diperlukan pengalaman sebelumnya. Groovy & Gradle: JVM Automation and Build Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Membangun Plugin Biner” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Groovy & Gradle: JVM Automation and Build Engineering ini?

Ya. Setiap pelajaran Groovy & Gradle: JVM Automation and Build Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Memahami Plugin Gradle
Membangun Plugin Biner
Menerapkan & Mempublikasikan Plugin
Ekstensi Plugin & DSL yang Dapat Dikonfigurasi

← Kembali ke Groovy & Gradle: JVM Automation and Build Engineering