Gradle 插件有哪些类型？如何创建和使用自定义插件？ - 面试题

Gradle 插件是扩展 Gradle 功能的主要机制，通过插件可以添加新的任务、配置和约定。以下是 Gradle 插件的详细说明：

插件类型

1. 二进制插件（Binary Plugins）

二进制插件是实现 Plugin 接口的类，通常打包为 JAR 文件。

groovy
// 应用二进制插件
plugins {
    id 'java'
    id 'org.springframework.boot' version '3.0.0'
    id 'com.android.application' version '8.0.0'
}

2. 脚本插件（Script Plugins）

脚本插件是包含构建逻辑的 Groovy 或 Kotlin 脚本文件。

groovy
// 应用脚本插件
apply from: 'gradle/checkstyle.gradle'
apply from: file('gradle/codenarc.gradle')
apply from: new File(rootDir, 'gradle/common.gradle')

应用插件的方式

使用 plugins DSL（推荐）

groovy
plugins {
    // Gradle 核心插件（无需版本号）
    id 'java'
    id 'application'
    id 'war'
    
    // 社区插件（需要版本号）
    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'
    
    // 使用插件 ID
    id 'com.android.application' version '8.0.0' apply false
}

使用 apply 方法（旧方式）

groovy
// 应用核心插件
apply plugin: 'java'
apply plugin: 'application'

// 应用社区插件
apply plugin: 'org.springframework.boot'
apply plugin: 'com.github.spotbugs'

// 使用类路径
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:3.0.0'
    }
}
apply plugin: 'org.springframework.boot'

常用插件

Java 插件

groovy
plugins {
    id 'java'
}

// Java 插件提供的任务
// - compileJava: 编译 Java 源代码
// - compileTestJava: 编译测试代码
// - test: 运行测试
// - jar: 打包 JAR 文件
// - javadoc: 生成 Javadoc

Application 插件

groovy
plugins {
    id 'application'
}

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

// 提供的任务
// - run: 运行应用程序
// - distZip: 创建 ZIP 分发包
// - distTar: 创建 TAR 分发包
// - installDist: 安装应用程序

War 插件

groovy
plugins {
    id 'war'
}

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

// 提供的任务
// - war: 创建 WAR 文件

Spring Boot 插件

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

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

// 提供的任务
// - bootRun: 运行 Spring Boot 应用
// - bootJar: 创建可执行 JAR
// - bootWar: 创建可执行 WAR

自定义插件

创建插件项目结构

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

实现插件类

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) {
        // 创建扩展
        def extension = project.extensions.create('customConfig', CustomExtension)
        
        // 创建任务
        def helloTask = project.tasks.register('hello') {
            group = 'Custom'
            description = 'Says hello'
            doLast {
                println "Hello, ${extension.name}!"
            }
        }
        
        // 配置项目
        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
    }
}

定义插件 ID

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

发布插件

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')
        }
    }
}

使用自定义插件

groovy
// 在 settings.gradle 中添加插件仓库
pluginManagement {
    repositories {
        maven {
            url = uri('../repo')
        }
        gradlePluginPortal()
    }
}

// 在 build.gradle 中应用插件
plugins {
    id 'com.example.custom-plugin'
}

customConfig {
    name = 'Gradle'
    timeout 60
}

插件配置

插件块配置

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

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

扩展配置

groovy
// 使用插件提供的扩展
java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
    
    withSourcesJar()
    withJavadocJar()
}

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

插件依赖管理

插件版本管理

groovy
// 使用版本目录
[plugins]
spring-boot = { id = "org.springframework.boot", version = "3.0.0" }
dependency-management = { id = "io.spring.dependency-management", version = "1.1.0" }

// 在 build.gradle 中使用
plugins {
    id libs.plugins.spring.boot.get().pluginId
    id libs.plugins.dependency.management.get().pluginId
}

插件依赖解析策略

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

最佳实践

使用 plugins DSL：优先使用 plugins DSL 而不是 apply 方法
明确插件版本：为社区插件指定明确的版本号
合理使用插件：只应用必要的插件，避免功能冗余
自定义插件：对于重复的构建逻辑，考虑创建自定义插件
插件配置：在应用插件后立即配置插件扩展
插件依赖：注意插件之间的依赖关系，避免冲突
插件更新：定期检查和更新插件版本以获取新功能和修复