Groovy & Gradle: JVM Automation and Build Engineering · Ders

İkili Eklentiler Oluşturma

Groovy veya Java kullanarak bağımsız ikili eklentiler geliştirin ve bunları dağıtım için paketleyin.

İkili Eklentiler Oluşturma, CoddyKit'te ücretsiz bir Groovy & Gradle: JVM Automation and Build Engineering dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Groovy & Gradle: JVM Automation and Build Engineering öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Groovy & Gradle: JVM Automation and Build Engineering kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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!

Sıkça Sorulan Sorular

“İkili Eklentiler Oluşturma” dersi ücretsiz mi?

Evet — “İkili Eklentiler Oluşturma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Groovy & Gradle: JVM Automation and Build Engineering kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Groovy & Gradle: JVM Automation and Build Engineering kursu toplamda 4 dersten oluşur.

“İkili Eklentiler Oluşturma” dersinde ne öğreneceğim?

Groovy veya Java kullanarak bağımsız ikili eklentiler geliştirin ve bunları dağıtım için paketleyin. Groovy & Gradle: JVM Automation and Build Engineering ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Groovy & Gradle: JVM Automation and Build Engineering öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Groovy & Gradle: JVM Automation and Build Engineering, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“İkili Eklentiler Oluşturma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Groovy & Gradle: JVM Automation and Build Engineering dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Groovy & Gradle: JVM Automation and Build Engineering dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Gradle Eklentilerini Anlama
İkili Eklentiler Oluşturma
Eklentileri Uygulama ve Yayımlama
Eklenti Uzantıları ve Yapılandırılabilir DSL'ler

← Groovy & Gradle: JVM Automation and Build Engineering Sayfasına Dön