使用外掛

Gradle 的許多功能是透過外掛提供的，包括 Gradle 隨附的核心外掛、第三方外掛，以及在建置中定義的腳本外掛。

外掛引入了新的工作（例如，JavaCompile）、網域物件（例如，SourceSet）、慣例（例如，將 Java 原始碼放在 src/main/java），並擴展了核心或其他外掛物件。

在 Gradle 中，外掛對於自動化常見的建置任務、與外部工具或服務整合，以及客製化建置流程以滿足特定專案需求至關重要。它們也是組織建置邏輯的主要機制。

外掛的優點

在建置腳本中編寫許多工作並複製配置區塊可能會變得雜亂。與直接將邏輯添加到建置腳本相比，外掛提供了幾個優勢

提升可重複使用性：減少在專案之間複製相似邏輯的需求。
增強模組化：允許更模組化和有組織的建置腳本。
封裝邏輯：保持命令式邏輯分離，啟用更宣告式的建置腳本。

外掛發佈

您可以利用來自 Gradle 和 Gradle 社群的外掛，或建立您自己的外掛。

外掛可透過三種方式取得

核心外掛 - Gradle 開發和維護一組核心外掛。
社群外掛 - 在遠端儲存庫（例如 Maven 或 Gradle 外掛入口網站）中共享的 Gradle 外掛。
自訂外掛 - Gradle 允許使用者使用 API 建立外掛。

外掛類型

外掛可以實作為 二進制外掛、預編譯腳本外掛 或 腳本外掛

1. 腳本外掛

腳本外掛是 Groovy DSL 或 Kotlin DSL 腳本，使用 apply from: 語法直接套用到 Gradle 建置腳本。它們在建置腳本中內嵌套用，以新增功能或客製化建置流程。不建議使用它們，但了解如何使用它們很重要

build.gradle.kts

// Define a plugin
class HelloWorldPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        project.tasks.register("helloWorld") {
            group = "Example"
            description = "Prints 'Hello, World!' to the console"
            doLast {
                println("Hello, World!")
            }
        }
    }
}

// Apply the plugin
apply<HelloWorldPlugin>()

2. 預編譯腳本外掛

預編譯腳本外掛是 Groovy DSL 或 Kotlin DSL 腳本，編譯並作為 Java 類別檔案封裝在某些程式庫中發佈。它們旨在作為二進制 Gradle 外掛使用，因此使用 plugins {} 區塊套用到專案。可以透過外掛 ID 引用預編譯腳本，該 ID 衍生自其名稱和可選的套件宣告。

plugin/src/main/kotlin/my-plugin.gradle.kts

// This script is automatically exposed to downstream consumers as the `my-plugin` plugin
tasks {
    register("myCopyTask", Copy::class) {
        group = "sample"
        from("build.gradle.kts")
        into("build/copy")
    }
}

consumer/build.gradle.kts

plugins {
    id("my-plugin") version "1.0"
}

3. `BuildSrc` 和慣例外掛

這些是預編譯外掛和二進制外掛的混合體，提供了一種在專案之間重複使用複雜邏輯的方法，並允許更好地組織建置邏輯。

buildSrc/src/main/kotlin/shared-build-conventions.gradle.kts

plugins {
    java
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.8.1")
    implementation("com.google.guava:guava:30.1.1-jre")
}

tasks.named<Test>("test") {
    useJUnitPlatform()
}

tasks.register<Copy>("backupTestXml") {
    from("build/test-results/test")
    into("/tmp/results/")
    exclude("binary/**")
}

app/build.gradle.kts

plugins {
    application
    id("shared-build-conventions")
}

4. 二進制外掛

二進制外掛是編譯後的外掛，通常以 Java 或 Kotlin DSL 編寫，並封裝為 JAR 檔案。它們使用 plugins {} 區塊套用到專案。與腳本外掛或預編譯腳本外掛相比，它們提供更好的效能和可維護性。

plugin/src/main/kotlin/plugin/MyPlugin.kt

class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        project.run {
            tasks {
                register("myCopyTask", Copy::class) {
                    group = "sample"
                    from("build.gradle.kts")
                    into("build/copy")
                }
            }
        }
    }
}

consumer/build.gradle.kts

plugins {
    id("my-plugin") version "1.0"
}

二進制外掛 和 腳本外掛 之間的差異在於它們的共享和執行方式

二進制外掛 被編譯成位元組碼，並且共享位元組碼。
腳本外掛 作為原始碼共享，並在使用時編譯。

二進制外掛可以使用任何產生 JVM 位元組碼的語言編寫，例如 Java、Kotlin 或 Groovy。相反，腳本外掛只能使用 Kotlin DSL 或 Groovy DSL 編寫。

但是，也存在一個中間地帶：預編譯腳本外掛。這些外掛像腳本外掛一樣使用 Kotlin DSL 或 Groovy DSL 編寫，但像二進制外掛一樣編譯成位元組碼並共享。

外掛通常從腳本外掛開始（因為它們很容易編寫）。然後，隨著程式碼變得更有價值，它會遷移到可以輕鬆測試並在多個專案或組織之間共享的二進制外掛。

若要使用封裝在外掛中的建置邏輯，Gradle 需要執行兩個步驟。首先，它需要解析外掛，然後它需要將外掛套用到目標，通常是 專案。

解析外掛表示找到包含給定外掛的 JAR 的正確版本，並將其新增到腳本類別路徑。一旦外掛被解析，其 API 就可以在建置腳本中使用。腳本外掛是自解析的，因為它們是從套用它們時提供的特定檔案路徑或 URL 解析的。作為 Gradle 發行版一部分提供的核心二進制外掛會自動解析。
套用外掛表示在專案上執行外掛的 Plugin.apply(T)。

外掛 DSL 建議用於一步解析和套用外掛。

套用外掛

Gradle 提供 核心外掛（例如，JavaPlugin、GroovyPlugin、MavenPublishPlugin 等）作為其發行版的一部分，這表示它們會自動解析。

核心外掛使用外掛名稱在建置腳本中套用

plugins {
    id «plugin name»
}

例如

build.gradle.kts

plugins {
    id("java")
}

build.gradle

plugins {
    id 'java'
}

非核心外掛必須先解析才能套用。非核心外掛在建置檔案中透過唯一 ID 和版本識別

plugins {
    id «plugin id» version «plugin version»
}

例如

build.gradle.kts

plugins {
    id("com.gradleup.shadow") version "8.3.4"
}

build.gradle

plugins {
    id 'com.gradleup.shadow' version '8.3.4'
}

並且外掛的位置必須在設定檔中指定

settings.gradle.kts

pluginManagement {  (1)
    repositories {
        gradlePluginPortal()
    }
}

settings.gradle

pluginManagement {  (1)
    repositories {
        gradlePluginPortal()
    }
}

解析和套用外掛還有其他考量


plugins {
  id("org.barfuin.gradle.taskinfo") version "2.1.0"
}
plugins {
    id("org.barfuin.gradle.taskinfo") version "2.1.0"
}
allprojects {
    apply(plugin = "org.barfuin.gradle.taskinfo")
    repositories {
        mavenCentral()
    }
}
plugins {
    id("com.gradleup.shadow") version "8.3.4" apply false
    id("io.ratpack.ratpack-java") version "1.8.2" apply false
}
plugins {
    id("my-convention.gradle.taskinfo")
}
buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath("org.barfuin.gradle.taskinfo:gradle-taskinfo:2.1.0")
  }
}
apply(plugin = "org.barfuin.gradle.taskinfo")
apply<MyCustomBarfuinTaskInfoPlugin>()

#	要	使用	例如
1	將外掛套用到專案。	建置檔案中的 `plugins` 區塊.	plugins { id("org.barfuin.gradle.taskinfo") version "2.1.0" }
2	將外掛套用到多個專案。	根建置檔案中的 `subprojects` 或 `allprojects` 區塊。不建議	plugins { id("org.barfuin.gradle.taskinfo") version "2.1.0" } allprojects { apply(plugin = "org.barfuin.gradle.taskinfo") repositories { mavenCentral() } }
3	將外掛套用到多個專案。	根建置檔案中的 `plugins` 區塊.	plugins { id("com.gradleup.shadow") version "8.3.4" apply false id("io.ratpack.ratpack-java") version "1.8.2" apply false }
4	將外掛套用到多個專案。	`buildSrc` 目錄中的慣例外掛。建議。	plugins { id("my-convention.gradle.taskinfo") }
5	套用建置腳本本身所需的外掛。	建置檔案本身中的 `buildscript` 區塊。舊版。	buildscript { repositories { mavenCentral() } dependencies { classpath("org.barfuin.gradle.taskinfo:gradle-taskinfo:2.1.0") } } apply(plugin = "org.barfuin.gradle.taskinfo")
6	套用腳本外掛。在類型安全存取器不可用時套用外掛。	建置檔案中的舊版 `apply()` 方法。不建議。舊版。	apply<MyCustomBarfuinTaskInfoPlugin>()

1. 使用 `plugins{}` 區塊套用外掛

外掛 DSL 提供了一種簡潔方便的方式來宣告外掛相依性。

plugins 區塊配置了 PluginDependenciesSpec 的實例

plugins {
    application                                     // by name
    java                                            // by name
    id("java")                                      // by id - recommended
    id("org.jetbrains.kotlin.jvm") version "1.9.0"  // by id - recommended
}

核心 Gradle 外掛是獨特的，因為它們提供簡短名稱，例如核心 JavaPlugin 的 java。

若要套用核心外掛，可以使用簡短名稱

build.gradle.kts

plugins {
    java
}

build.gradle

plugins {
    id 'java'
}

所有其他二進制外掛都必須使用外掛 ID 的完整形式（例如，com.github.foo.bar）。

若要從 Gradle 外掛入口網站套用社群外掛，必須使用完全限定的 外掛 ID（全域唯一識別碼）

build.gradle.kts

plugins {
    id("org.springframework.boot") version "3.3.1"
}

build.gradle

plugins {
    id 'org.springframework.boot' version '3.3.1'
}

有關使用外掛 DSL 的更多資訊，請參閱 PluginDependenciesSpec。

外掛 DSL 的限制

外掛 DSL 為使用者提供了方便的語法，並讓 Gradle 能夠快速確定使用了哪些外掛。這讓 Gradle 能夠

最佳化外掛類別的載入和重複使用。
為編輯器提供有關建置腳本中潛在屬性和值的詳細資訊。

但是，DSL 要求外掛是靜態定義的。

plugins {} 區塊機制與「傳統」apply() 方法機制之間存在一些關鍵差異。也存在一些約束和可能的限制。

plugins{} 區塊只能在專案的建置腳本 build.gradle(.kts) 和 settings.gradle(.kts) 檔案中使用。它必須出現在任何其他區塊之前。它不能在腳本外掛或初始化腳本中使用。

受限語法

plugins {} 區塊不支援任意程式碼。

它被限制為是等冪的（每次產生相同的結果）且無副作用的（Gradle 可以隨時安全地執行）。

形式為

plugins {
    id(«plugin id»)                             (1)
    id(«plugin id») version «plugin version»    (2)
}

1	對於核心 Gradle 外掛或建置腳本已可用的外掛
2	對於需要解析的二進制 Gradle 外掛

其中 «外掛 ID» 和 «外掛版本» 是字串。

其中 «外掛 ID» 和 «外掛版本» 必須是常數、文字字串。

plugins{} 區塊也必須是建置腳本中的頂層語句。它不能巢狀在另一個結構中（例如，if 語句或 for 迴圈）。

2. 將外掛套用到所有 subprojects{} 或 allprojects{}

假設您有一個多專案建置，您可能想要將外掛套用到建置中的某些或所有子專案，但不要套用到 根 專案。

雖然 plugins{} 區塊的預設行為是立即 解析 和 套用 外掛，但您可以使用 apply false 語法來告知 Gradle 不要將外掛套用到目前的專案。然後，在子專案的建置腳本中使用不帶版本的 plugins{} 區塊

settings.gradle.kts

include("hello-a")
include("hello-b")
include("goodbye-c")

build.gradle.kts

plugins {
    // These plugins are not automatically applied.
    // They can be applied in subprojects as needed (in their respective build files).
    id("com.example.hello") version "1.0.0" apply false
    id("com.example.goodbye") version "1.0.0" apply false
}

allprojects {
    // Apply the common 'java' plugin to all projects (including the root)
    plugins.apply("java")
}

subprojects {
    // Apply the 'java-library' plugin to all subprojects (excluding the root)
    plugins.apply("java-library")
}

hello-a/build.gradle.kts

plugins {
    id("com.example.hello")
}

hello-b/build.gradle.kts

plugins {
    id("com.example.hello")
}

goodbye-c/build.gradle.kts

plugins {
    id("com.example.goodbye")
}

settings.gradle

include 'hello-a'
include 'hello-b'
include 'goodbye-c'

build.gradle

plugins {
    // These plugins are not automatically applied.
    // They can be applied in subprojects as needed (in their respective build files).
    id 'com.example.hello' version '1.0.0' apply false
    id 'com.example.goodbye' version '1.0.0' apply false
}

allprojects {
    // Apply the common 'java' plugin to all projects (including the root)
    apply(plugin: 'java')
}

subprojects {
    // Apply the 'java-library' plugin to all subprojects (excluding the root)
    apply(plugin: 'java-library')
}

hello-a/build.gradle

plugins {
    id 'com.example.hello'
}

hello-b/build.gradle

plugins {
    id 'com.example.hello'
}

goodbye-c/build.gradle

plugins {
    id 'com.example.goodbye'
}

您還可以透過使用您自己的慣例外掛組成建置邏輯來封裝外部外掛的版本。

3. 套用在根專案中宣告的外掛

您可以從多專案建置中的根專案或父專案套用外掛，以與其他專案共享通用邏輯和行為。根/父專案是目錄階層頂端的專案。

您應該使用 plugins {} 區塊，因為它可以確保在外掛在專案的評估階段之前套用和配置。這樣，您可以安全地使用類型安全存取器來存取外掛引入的任何模型元素

settings.gradle.kts

rootProject.name = "multi-project-build"
include("domain", "infra", "http")

build.gradle.kts

plugins {
    id("com.gradleup.shadow") version "8.3.4" apply false
    id("io.ratpack.ratpack-java") version "1.8.2" apply false
}

domain/build.gradle.kts

plugins {
    `java-library`
}

dependencies {
    api("javax.measure:unit-api:1.0")
    implementation("tec.units:unit-ri:1.0.3")
}

infra/build.gradle.kts

plugins {
    `java-library`
    id("com.gradleup.shadow")
}

http/build.gradle.kts

plugins {
    java
    id("io.ratpack.ratpack-java")
}

dependencies {
    implementation(project(":domain"))
    implementation(project(":infra"))
    implementation(ratpack.dependency("dropwizard-metrics"))
}

在根/父 build.gradle(.kts) 中，外掛已宣告但未套用（透過 apply false）。這種方法雖然是可選的，但會使外掛可用於在特定子專案中明確套用。如果沒有 apply false，在根專案中宣告的外掛就無法僅明確套用到某些子專案。

apply false 是可選的。如果在根建置檔案中宣告外掛時未使用 apply false，則這些外掛將自動套用到根專案。

在 infra 子專案中，明確套用了在根專案中提供的 com.gradleup.shadow 外掛。http 子專案套用了 io.ratpack.ratpack-java。domain 子專案未套用來自根專案的外掛。

4. 套用來自 `buildSrc` 目錄的慣例外掛

buildSrc 是 Gradle 專案根目錄下的可選目錄，其中包含用於建置主要專案的建置邏輯（即外掛）。只要外掛具有已定義的 ID，您就可以套用位於專案 buildSrc 目錄中的外掛。

以下範例顯示如何將外掛實作類別 my.MyPlugin（在 buildSrc 中定義）連結到 ID「my-plugin」

buildSrc/build.gradle.kts

plugins {
    `java-gradle-plugin`
}

gradlePlugin {
    plugins {
        create("myPlugins") {
            id = "my-plugin"
            implementationClass = "my.MyPlugin"
        }
    }
}

buildSrc/build.gradle

plugins {
    id 'java-gradle-plugin'
}

gradlePlugin {
    plugins {
        myPlugins {
            id = 'my-plugin'
            implementationClass = 'my.MyPlugin'
        }
    }
}

然後可以透過 ID 套用外掛

build.gradle.kts

plugins {
    id("my-plugin")
}

build.gradle

plugins {
    id 'my-plugin'
}

5. 使用 `buildscript{}` 區塊套用外掛

若要定義在建置腳本本身中使用的程式庫或外掛，您可以使用 buildscript 區塊。buildscript 區塊也用於指定在何處尋找這些相依性。

使用較新版本的 Gradle 時，這種方法不太常見，因為 plugins {} 區塊簡化了外掛的使用。但是，在處理自訂或非標準外掛儲存庫以及程式庫相依性時，buildscript {} 可能仍然是必要的

build.gradle.kts

import org.yaml.snakeyaml.Yaml
import java.io.File

buildscript {
    repositories {
        maven {
            url = uri("https://plugins.gradle.org/m2/")
        }
        mavenCentral()  // Where to find the plugin
    }
    dependencies {
        classpath("org.yaml:snakeyaml:1.19") // The library's classpath dependency
        classpath("com.gradleup.shadow:shadow-gradle-plugin:8.3.4") // Plugin dependency for legacy plugin application
    }
}

// Applies legacy Shadow plugin
apply(plugin = "com.gradleup.shadow")

// Uses the library in the build script
val yamlContent = """
        name: Project
    """.trimIndent()
val yaml = Yaml()
val data: Map<String, Any> = yaml.load(yamlContent)

build.gradle

import org.yaml.snakeyaml.Yaml

buildscript {
    repositories { // Where to find the plugin or library
        maven {
            url = uri("https://plugins.gradle.org/m2/")
        }
        mavenCentral()
    }
    dependencies {
        classpath 'org.yaml:snakeyaml:1.19' // The library's classpath dependency
        classpath 'com.gradleup.shadow:shadow-gradle-plugin:8.3.4' // Plugin dependency for legacy plugin application
    }
}

// Applies legacy Shadow plugin
apply plugin: 'com.gradleup.shadow'

// Uses the library in the build script
def yamlContent = """
        name: Project Name
    """
def yaml = new Yaml()
def data = yaml.load(yamlContent)

6. 使用舊版 `apply()` 方法套用腳本外掛

腳本外掛是一種特設外掛，通常在同一個建置腳本中編寫和套用。它使用舊版應用方法套用

build.gradle.kts

class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        println("Plugin ${this.javaClass.simpleName} applied on ${project.name}")
    }
}

apply<MyPlugin>()

build.gradle

class MyPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        println("Plugin ${this.getClass().getSimpleName()} applied on ${project.name}")
    }
}

apply plugin: MyPlugin

外掛管理

pluginManagement{} 區塊用於配置外掛解析的儲存庫，並為建置腳本中套用的外掛定義版本約束。

pluginManagement{} 區塊可以在 settings.gradle(.kts) 檔案中使用，它必須是檔案中的第一個區塊

settings.gradle.kts

pluginManagement {
    plugins {
    }
    resolutionStrategy {
    }
    repositories {
    }
}
rootProject.name = "plugin-management"

settings.gradle

pluginManagement {
    plugins {
    }
    resolutionStrategy {
    }
    repositories {
    }
}
rootProject.name = 'plugin-management'

該區塊也可以在初始化腳本中使用

init.gradle.kts

settingsEvaluated {
    pluginManagement {
        plugins {
        }
        resolutionStrategy {
        }
        repositories {
        }
    }
}

init.gradle

settingsEvaluated { settings ->
    settings.pluginManagement {
        plugins {
        }
        resolutionStrategy {
        }
        repositories {
        }
    }
}

自訂外掛儲存庫

預設情況下，plugins{} DSL 從公用 Gradle 外掛入口網站解析外掛。

許多建置作者也希望從私有 Maven 或 Ivy 儲存庫解析外掛，因為它們包含專有的實作細節，或為了更精確地控制其建置可用的外掛。

若要指定自訂外掛儲存庫，請使用 pluginManagement{} 內部的 repositories{} 區塊

settings.gradle.kts

pluginManagement {
    repositories {
        maven(url = file("./maven-repo"))
        gradlePluginPortal()
        ivy(url = file("./ivy-repo"))
    }
}

settings.gradle

pluginManagement {
    repositories {
        maven {
            url = file('./maven-repo')
        }
        gradlePluginPortal()
        ivy {
            url = file('./ivy-repo')
        }
    }
}

這會告知 Gradle 在解析外掛時首先在 ../maven-repo 的 Maven 儲存庫中尋找，如果 Maven 儲存庫中找不到外掛，則檢查 Gradle 外掛入口網站。如果您不希望搜尋 Gradle 外掛入口網站，請省略 gradlePluginPortal() 行。最後，將檢查 ../ivy-repo 的 Ivy 儲存庫。

外掛版本管理

pluginManagement{} 內部的 plugins{} 區塊允許在單個位置定義建置的所有外掛版本。然後可以透過 ID 將外掛套用到任何建置腳本，透過 plugins{} 區塊。

以這種方式設定外掛版本的一個好處是 pluginManagement.plugins{} 沒有與建置腳本 plugins{} 區塊相同的受限語法。這允許從 gradle.properties 取得外掛版本，或透過其他機制載入。

透過 pluginManagement 管理外掛版本

settings.gradle.kts

pluginManagement {
  val helloPluginVersion: String by settings
  plugins {
    id("com.example.hello") version "${helloPluginVersion}"
  }
}

build.gradle.kts

plugins {
    id("com.example.hello")
}

gradle.properties

helloPluginVersion=1.0.0

settings.gradle

pluginManagement {
  plugins {
        id 'com.example.hello' version "${helloPluginVersion}"
    }
}

build.gradle

plugins {
    id 'com.example.hello'
}

gradle.properties

helloPluginVersion=1.0.0

外掛版本從 gradle.properties 載入，並在設定腳本中配置，允許將外掛新增到任何專案而無需指定版本。

外掛解析規則

外掛解析規則允許您修改在 plugins{} 區塊中提出的外掛請求，例如，變更請求的版本或明確指定實作成品座標。

若要新增解析規則，請使用 pluginManagement{} 內部的 resolutionStrategy{}

settings.gradle.kts

pluginManagement {
    resolutionStrategy {
        eachPlugin {
            if (requested.id.namespace == "com.example") {
                useModule("com.example:sample-plugins:1.0.0")
            }
        }
    }
    repositories {
        maven {
            url = uri("./maven-repo")
        }
        gradlePluginPortal()
        ivy {
            url = uri("./ivy-repo")
        }
    }
}

settings.gradle

pluginManagement {
    resolutionStrategy {
        eachPlugin {
            if (requested.id.namespace == 'com.example') {
                useModule('com.example:sample-plugins:1.0.0')
            }
        }
    }
    repositories {
        maven {
            url = file('./maven-repo')
        }
        gradlePluginPortal()
        ivy {
            url = file('./ivy-repo')
        }
    }
}

這會告知 Gradle 使用指定的外掛實作成品，而不是其從外掛 ID 到 Maven/Ivy 座標的內建預設映射。

自訂 Maven 和 Ivy 外掛儲存庫必須包含外掛標記成品以及實作外掛的成品。請閱讀 Gradle 外掛開發外掛，以取得有關將外掛發佈到自訂儲存庫的更多資訊。

有關使用 pluginManagement{} 區塊的完整文件，請參閱 PluginManagementSpec。

外掛標記成品

由於 plugins{} DSL 區塊僅允許透過其全域唯一外掛 ID 和 版本 屬性宣告外掛，因此 Gradle 需要一種方法來查詢外掛實作成品的座標。

為此，Gradle 將尋找座標為 plugin.id:plugin.id.gradle.plugin:plugin.version 的外掛標記成品。此標記需要相依於實際的外掛實作。發佈這些標記由 java-gradle-plugin 自動化。

例如，以下來自 sample-plugins 專案的完整範例顯示了如何使用 java-gradle-plugin、maven-publish 外掛和 ivy-publish 外掛的組合，將 com.example.hello 外掛和 com.example.goodbye 外掛發佈到 Ivy 和 Maven 儲存庫。

build.gradle.kts

plugins {
    `java-gradle-plugin`
    `maven-publish`
    `ivy-publish`
}

group = "com.example"
version = "1.0.0"

gradlePlugin {
    plugins {
        create("hello") {
            id = "com.example.hello"
            implementationClass = "com.example.hello.HelloPlugin"
        }
        create("goodbye") {
            id = "com.example.goodbye"
            implementationClass = "com.example.goodbye.GoodbyePlugin"
        }
    }
}

publishing {
    repositories {
        maven {
            url = uri(layout.buildDirectory.dir("maven-repo"))
        }
        ivy {
            url = uri(layout.buildDirectory.dir("ivy-repo"))
        }
    }
}

build.gradle

plugins {
    id 'java-gradle-plugin'
    id 'maven-publish'
    id 'ivy-publish'
}

group = 'com.example'
version = '1.0.0'

gradlePlugin {
    plugins {
        hello {
            id = 'com.example.hello'
            implementationClass = 'com.example.hello.HelloPlugin'
        }
        goodbye {
            id = 'com.example.goodbye'
            implementationClass = 'com.example.goodbye.GoodbyePlugin'
        }
    }
}

publishing {
    repositories {
        maven {
            url = layout.buildDirectory.dir('maven-repo')
        }
        ivy {
            url = layout.buildDirectory.dir('ivy-repo')
        }
    }
}

在範例目錄中執行 gradle publish 會建立以下 Maven 儲存庫佈局（Ivy 佈局類似）

舊版外掛應用

隨著外掛 DSL 的引入，使用者應該幾乎沒有理由使用舊版套用外掛的方法。在此處記錄它是為了防止建置作者由於其目前運作方式的限制而無法使用外掛 DSL。

build.gradle.kts

apply(plugin = "java")

build.gradle

apply plugin: 'java'

可以使用外掛 ID 套用外掛。在上述情況下，我們使用簡短名稱「java」來套用 JavaPlugin。

除了使用外掛 ID 之外，也可以透過簡單地指定外掛的類別來套用外掛

build.gradle.kts

apply<JavaPlugin>()

build.gradle

apply plugin: JavaPlugin

上述範例中的 JavaPlugin 符號指的是 JavaPlugin。此類別嚴格來說不需要匯入，因為 org.gradle.api.plugins 套件已在所有建置腳本中自動匯入（請參閱預設匯入）。

此外，需要在 Kotlin 中附加 ::class 後綴以識別類別文字，而不是 Java 中的 .class。

此外，在 Groovy 中識別類別文字時，無需像在 Java 中一樣附加 .class。

您也可能會看到 apply 方法用於包含整個建置檔案

build.gradle.kts

apply(from = "other.gradle.kts")

build.gradle

apply from: 'other.gradle'

使用版本目錄

當專案使用版本目錄時，可以在套用時透過別名引用外掛。

讓我們看一下一個簡單的版本目錄

libs.versions.toml

[versions]
groovy = "3.0.5"
checkstyle = "8.37"

[libraries]
groovy-core = { module = "org.codehaus.groovy:groovy", version.ref = "groovy" }
groovy-json = { module = "org.codehaus.groovy:groovy-json", version.ref = "groovy" }
groovy-nio = { module = "org.codehaus.groovy:groovy-nio", version.ref = "groovy" }
commons-lang3 = { group = "org.apache.commons", name = "commons-lang3", version = { strictly = "[3.8, 4.0[", prefer="3.9" } }

[bundles]
groovy = ["groovy-core", "groovy-json", "groovy-nio"]

[plugins]
versions = { id = "com.github.ben-manes.versions", version = "0.45.0" }

然後可以使用 alias 方法將外掛套用到任何建置腳本

build.gradle.kts

plugins {
    `java-library`
    alias(libs.plugins.versions)
}

build.gradle

plugins {
    id 'java-library'
    alias(libs.plugins.versions)
}

Gradle 為目錄項目產生類型安全存取器。

下一步： 了解如何編寫外掛 >>

此頁面是否對您有幫助？