插件的作用

插件可以帮助我们促进代码的重用、项目更高程度的模块化、自动化和便捷化，减少功能类似代码的编写，实现可插拔式地扩展项目功能，从而提升工作效率。

插件可以将任务添加到项目中，从而帮助完成测试、编译和打包等工作。也可以添加依赖配置到项目中，并且给项目扩展新的属性、方法等，并对项目进行一些约定。比如应用java插件后，约定src/main/java目录是我们源码存放的位置，编译时要编译该目录下的java代码。

插件的分类和使用

脚本插件

本质上是一个本地或网络上的脚本文件，使用脚本插件时通过apply from:将脚本加载进来即可。以下面一段脚本为例：

ext {
    author = "szc"
    cfg = [
            compileSdkVersion: JavaVersion.VERSION_1_8
    ]
    hometown = [
            "city": "Anyang",
            "province": "Henan"
    ]
}

我们在build.gradle中引入并使用它：

apply from: "version.gradle"

task "test_plugin_0" {
    println "author name: ${author} from city ${hometown.city}, compileVersion is ${cfg.compileSdkVersion}"
}

运行该任务的输出如下：

10:23:17: Executing task '"test_plugin_0"'...

> Configure project :
author name: szc from city Anyang, compileVersion is 1.8

......

BUILD SUCCESSFUL in 224ms
10:23:18: Task execution finished '"test_plugin_0"'.

脚本文件是模块化的基础，可按功能将我们的脚本拆分成一个个公用且职责分明的文件，而后在主脚本文件中使用，比如将很多公用的库版本号或应用的构建版本一起管理等。

对象插件

对象插件是实现了org.gradle.api.plugin接口的插件，每个Java Gradle插件均有一个pluginId。

可通过如下方式引用一个java插件：

apply plugin : 'java' // 方式1：引用pluginId为java的插件

apply { // 方式2： 闭包导入
    plugin "java"
}

// 方式3：全类名导入
apply plugin:org.gradle.api.plugins.JavaPlugin

// 由于org.gradle.api.plugins包默认导入，因此可用使用方式4：类名导入
apply plugin:JavaPlugin

第三方插件

如果使用了第三方发布的二进制插件，一般需要配置对应的仓库及类路径：

// 使用传统的应用方式，且buildScript标签必须在所有标签之前
buildscript {
    ext {
        springBootVersion = "2.3.3.RELEASE"
    }
    repositories {
        mavenLocal()
    }

    // 此处先引入插件
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

.....

// 而后再应用插件，在plugins标签之后应用
apply plugin: 'org.springframework.boot' // 社区插件,需要事先引入，不必写版本号

如果第三方插件已经被托管在了https://plugins.gradle.org/，则无需在buildscript里配置类路径，直接用新的plugins DSL引用即可：

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

用户自定义插件

第一步，定义插件接口，以及其中的属性

interface IMyPlugin {
    Property<String> getMessage()
    Property<String> getName()
}

第二步，定义插件类，实现Plugin接口及其中的apply()方法

class MyPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        def plugin = project.extensions.create("plugin_test", IMyPlugin) // 创建自定义插件接口对象，并起名

        // 设置插件任务
        project.task("test_myplugin") {
            doLast {
                println "getMessage: ${plugin.message.get()}, getName: ${plugin.name.get()}" // 输出插件接口属性
            }
        }
    }
}

第三步，应用插件类

apply {
    plugin MyPlugin
}

第四步，给插件类中的插件接口对象属性赋值

plugin_test {
    message = "test message"
    name = "szc"
}

输出结果：

(base) PS D:\develop\ideaWorkspace\GradleTest> gradle -q test_myplugin
getMessage: test message, getName: szc

更多参见官方文档，但这种方式我们不推荐，因为局限性太强，产生的插件只能在本项目中使用。

buildSrc项目

buildSrc是Gradle默认的插件目录，编译时Gradle会自动将该目录里的源码编译为插件。

编写步骤

首先，建立一个名为buildSrc的java模块（名字固定），而后从include modules中移除，并只保留其中的build.gradle和src/main目录，并重新构建项目的gradle。
然后，将以下内容写入buildSrc/build.gradle：

apply plugin: 'groovy' //必须
apply plugin: 'maven-publish'

dependencies {
    implementation gradleApi() //必须
    implementation localGroovy() //必须
}

repositories {
    google()
    jcenter()
    mavenCentral() //必须
}


// 把项目入口设置为src/main/szc
sourceSets {
     main {
         groovy {
             srcDir 'src/main/szc'
         }
     }
}

第三步，在buildSrc的项目入口中，新建文件MyPlugin.groovy（一定是groovy文件）：

package com.szc

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

public class MyPlugin implements Plugin<Project>{
    @Override
    void apply(Project project) {
        project.task("myPluginTask") {
            doLast {
                println "from my plugin Task"
            }
        }
    }
}

位置如下：

第四步，在buildSrc目录下，创建resources/META-INF/gradle-plugins目录，并在其中创建properties文件，文件名为MyPlugin的包名，如com.szc.properties：

第五步，在com.szc.properties文件中，指明插件的全类名：

implementation-class = com.szc.MyPlugin

然后就可以在module中引入我们的插件了：

apply {
    plugin com.szc.MyPlugin
}

执行任务输出如下：

(base) PS D:\develop\ideaWorkspace\GradleTest> gradle -q myPluginTask
from my plugin Task

其他项目/模块引用步骤

上述方式写出来的插件也只能在本工程中使用，若要其他工程也使用，则需要进行以下步骤：
首先，在工程根路径下，复制一份上述buildSrc目录，重命名（例如myplugin），并在settings.gradle中包含：

.....
include ':myplugin'

第二步，在myplugin/build.gradle中添加publishing标签，内容如下：

publishing {
    publications {
        mylib(MavenPublication) { // 创建发布包
            groupId = 'com.szc' // 定义组ID、包ID和版本号
            artifactId = 'lib'
            version = '1.1'

            from components.java // 打成jar包
        }
    }

    repositories {
        // 发布项目到本地目录
        maven { url "$rootDir/lib/release" }

        //发布项目到私服中
//        maven {
//            name = 'myRepo'
//            url = layout.buildDirectory.dir("repo")
//            // url='http://my.org/repo'
//            credentials {
//                username = 'joe'
//                password = 'secret'
//            }
//        }
    }
}

而后，执行发布命令：

完成后，就可以在项目根目录/lib/release中看到发布情况：

这样，我们就可以在其他项目中引用我们的插件了：

buildscript {
    repositories {
        maven { url "D:\\develop\\ideaWorkspace\\GradleTest\\lib\\release" } // 本地插件库的路径
    }

    dependencies {
        classpath "com.szc:lib:1.1"
    }
}

apply plugin: 'java'
apply plugin: 'com.szc' // 插件的组ID

在其他项目中的执行输出如下：

(base) PS D:\develop\ideaWorkspace\TestGradle2> gradle -q myPluginTask
from my plugin Task

java插件常用属性