What are the types of Gradle plugins? How to create and use custom plugins?

Gradle plugins are the primary mechanism for extending Gradle functionality. Through plugins, you can add new tasks, configurations, and conventions. Here's a detailed explanation of Gradle plugins:

Plugin Types

1. Binary Plugins

Binary plugins are classes that implement the Plugin interface, typically packaged as JAR files.

groovy
// Apply binary plugins
plugins {
    id 'java'
    id 'org.springframework.boot' version '3.0.0'
    id 'com.android.application' version '8.0.0'
}

2. Script Plugins

Script plugins are Groovy or Kotlin script files containing build logic.

groovy
// Apply script plugins
apply from: 'gradle/checkstyle.gradle'
apply from: file('gradle/codenarc.gradle')
apply from: new File(rootDir, 'gradle/common.gradle')

Ways to Apply Plugins

Using plugins DSL (Recommended)

groovy
plugins {
    // Gradle core plugins (no version needed)
    id 'java'
    id 'application'
    id 'war'
    
    // Community plugins (version required)
    id 'org.springframework.boot' version '3.0.0'
    id 'com.github.spotbugs' version '5.0.14'
    id 'io.spring.dependency-management' version '1.1.0'
    
    // Using plugin ID
    id 'com.android.application' version '8.0.0' apply false
}

Using apply Method (Old Way)

groovy
// Apply core plugins
apply plugin: 'java'
apply plugin: 'application'

// Apply community plugins
apply plugin: 'org.springframework.boot'
apply plugin: 'com.github.spotbugs'

// Using classpath
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:3.0.0'
    }
}
apply plugin: 'org.springframework.boot'

Common Plugins

Java Plugin

groovy
plugins {
    id 'java'
}

// Tasks provided by Java plugin
// - compileJava: Compile Java source code
// - compileTestJava: Compile test code
// - test: Run tests
// - jar: Package JAR file
// - javadoc: Generate Javadoc

Application Plugin

groovy
plugins {
    id 'application'
}

application {
    mainClass = 'com.example.Main'
    applicationDefaultJvmArgs = ['-Xmx1024m']
}

// Tasks provided
// - run: Run application
// - distZip: Create ZIP distribution
// - distTar: Create TAR distribution
// - installDist: Install application

War Plugin

groovy
plugins {
    id 'war'
}

war {
    archiveFileName = 'myapp.war'
    webAppDirName = 'src/main/webapp'
}

// Tasks provided
// - war: Create WAR file

Spring Boot Plugin

groovy
plugins {
    id 'org.springframework.boot' version '3.0.0'
}

springBoot {
    mainClass = 'com.example.Application'
}

// Tasks provided
// - bootRun: Run Spring Boot application
// - bootJar: Create executable JAR
// - bootWar: Create executable WAR

Custom Plugins

Create Plugin Project Structure

shell
custom-plugin/
├── build.gradle
├── settings.gradle
└── src/
    └── main/
        ├── groovy/
        │   └── com/
        │       └── example/
        │           └── CustomPlugin.groovy
        └── resources/
            └── META-INF/
                └── gradle-plugins/
                    └── com.example.custom-plugin.properties

Implement Plugin Class

groovy
// CustomPlugin.groovy
package com.example

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

class CustomPlugin implements Plugin<Project> {
    
    @Override
    void apply(Project project) {
        // Create extension
        def extension = project.extensions.create('customConfig', CustomExtension)
        
        // Create task
        def helloTask = project.tasks.register('hello') {
            group = 'Custom'
            description = 'Says hello'
            doLast {
                println "Hello, ${extension.name}!"
            }
        }
        
        // Configure project
        project.afterEvaluate {
            println "Project ${project.name} configured with custom plugin"
        }
    }
}

class CustomExtension {
    String name = 'World'
    int timeout = 30
    
    void timeout(int timeout) {
        this.timeout = timeout
    }
}

Define Plugin ID

properties
# com.example.custom-plugin.properties
implementation-class=com.example.CustomPlugin

Publish Plugin

groovy
// build.gradle
plugins {
    id 'java-gradle-plugin'
    id 'maven-publish'
}

gradlePlugin {
    plugins {
        customPlugin {
            id = 'com.example.custom-plugin'
            implementationClass = 'com.example.CustomPlugin'
        }
    }
}

publishing {
    repositories {
        maven {
            url = uri('../repo')
        }
    }
}

Use Custom Plugin

groovy
// Add plugin repository in settings.gradle
pluginManagement {
    repositories {
        maven {
            url = uri('../repo')
        }
        gradlePluginPortal()
    }
}

// Apply plugin in build.gradle
plugins {
    id 'com.example.custom-plugin'
}

customConfig {
    name = 'Gradle'
    timeout 60
}

Plugin Configuration

Plugin Block Configuration

groovy
plugins {
    id 'java'
    id 'checkstyle'
}

checkstyle {
    toolVersion = '10.3'
    configFile = file('config/checkstyle/checkstyle.xml')
    ignoreFailures = false
    showViolations = true
}

Extension Configuration

groovy
// Use extensions provided by plugins
java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
    
    withSourcesJar()
    withJavadocJar()
}

test {
    useJUnitPlatform()
    testLogging {
        events 'passed', 'skipped', 'failed'
    }
}

Plugin Dependency Management

Plugin Version Management

groovy
// Use version catalog
[plugins]
spring-boot = { id = "org.springframework.boot", version = "3.0.0" }
dependency-management = { id = "io.spring.dependency-management", version = "1.1.0" }

// Use in build.gradle
plugins {
    id libs.plugins.spring.boot.get().pluginId
    id libs.plugins.dependency.management.get().pluginId
}

Plugin Dependency Resolution Strategy

groovy
settings.gradle {
    pluginManagement {
        repositories {
            gradlePluginPortal()
            mavenCentral()
            google()
        }
        
        resolutionStrategy {
            eachPlugin {
                if (requested.id.id == 'com.example.plugin') {
                    useModule('com.example:plugin:1.0.0')
                }
            }
        }
    }
}

Best Practices

1. Use plugins DSL: Prefer using plugins DSL over apply method
2. Specify plugin versions: Specify clear version numbers for community plugins
3. Use plugins appropriately: Only apply necessary plugins to avoid feature redundancy
4. Custom plugins: Consider creating custom plugins for repetitive build logic
5. Plugin configuration: Configure plugin extensions immediately after applying plugins
6. Plugin dependencies: Be aware of dependencies between plugins to avoid conflicts
7. Plugin updates: Regularly check and update plugin versions for new features and fixes