gradle插件基础

gradle插件分为两种，一种是`脚本插件`，一种是`对象插件`。

脚本插件:脚本插件就是一个普通的xxx.gradle文件，通过在xxx.gradle定义一系列task，在另一个gradle文件中通过
apply from:'xxx.gradle'引用即可使用xxx.gradle定义的task。

主工程根目录创建xxx.gradle文件（xxx代表任意）

xxx.gradle文件
task testPlugin{
    doLast{
        println("xxx.gradle doLast")
    }
}

module工程引用，本次是app主工程的build.gradle引用：

apply from:"../xxx.gradle"

主要xxx.gradle与app工程同级因此需要../

引用完成后就可以输入编译命令：

gradle testPlugin

输出：

> Task :app:testPlugin
xxx.gradle doLast

对象插件
对象插件是指实现了org.gradle.api.Plugin接口的类。类需要实现void apply(T target)方法，T为泛型代表插件
作用到的对象。通常为Project对象。

编写对象插件有三种方式：

1.直接在gradle脚本文件中
2.在工程的buildSrc工程下面
3.独立工程

相比而言，1和2两种方式都是不对外暴露的，只能在当前工程或者module之间使用，如果要让其他项目使用还是需要使用
第三种方式。
下面我们一一来实现一下：

在gradle脚本中实现

此方法最简单，直接打开app.gradle写入，下面代码增加动态配置的代码
1.实现Plugin接口，重写apply方法

插件拓展
class CustomExtension{
    def message = "extension message"
    def what = 0
}

class CustomPlugin implements Plugin<Project> {

    @Override
    void apply(Project target) {
        //插件扩展参数为名称 类型 和参数（可无）
        def extension = target.extensions.create("cusExtension",CustomExtension)
        target.task("pluginTask"){
            doLast{
                println("task name is ${name}  message is ${extension.message}  what is ${extension.what}")
            }
        }
    }
}

配置扩展

cusExtension.message = "extension change   message"

通过DSL块配置扩展

cusExtension{
    message = "extension DSL change   message"
    what = 2
}

2.依赖插件

apply plugin : CustomPlugin

执行命令：

gradlew pluginTask

输出结果：

> Task :pluginTask
task name is pluginTask  message is extension DSL change   message  what is 2

buildSrc目录下

工程目录下新建buildSrc moudle，因为buildSrc不是一个Android moudle工程，因此需要我们做一些处理。

1.删除工程目录下main文件夹中的资源

2.在main文件夹下新建`groovy`文件夹（`buildSrc/src/main/groovy`）并创建包名文件夹，在包名文件夹下创建 `CustomAlonePlugin.groovy`文件（CustomAlonePlugin是文件名），我们的插件代码在写在其中。

注意：一定要写.groovy后缀，不然工具识别不出

package com.myplugin

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

public class CustomAlonePlugin implements Plugin<Project> {

    @Override
    void apply(Project target) {
        //插件扩展参数为名称 类型 和参数（可无）
        def extension = target.extensions.create("cusExtension",CustomExtension)
        target.task("pluginTask"){
            doLast{
                println("task name is ${name}  message is ${extension.message}  what is ${extension.what}")
            }
        }
    }
}

class CustomExtension{
    def message = "extension message"
    def what = 0
}

其中CustomExtension是配置项，供依赖项动态配置修改，配置方法和上面配置一样

3.main文件夹下面创建`resources`文件夹，在此文件夹下创建`META-INF/gradle-plugins`文件夹路径，在此文件夹中创建`myCustomPlugin.properties`文件（`buildSrc/src/main/resources/META-INF/gradle-plugins/myCustomPlugin.properties`）。

注意myCustomPlugin就是插件的id（可修改），供其他module依赖。

4.myCustomPlugin.properties文件夹下配置代码：

implementation-class = com.myplugin.CustomAlonePlugin//对应插件的类

5.build.gradle下添加依赖

apply plugin: 'groovy'
dependencies {
    implementation gradleApi()
    implementation localGroovy()
}

6.依赖插件

写完上面的代码后，module就可以依赖了

apply plugin : 'myCustomPlugin'
//配置扩展
cusExtension.message = "extension change   message"

//通过DSL块配置扩展
cusExtension{
    message = "extension DSL change   message"
    what = 2
}

执行：

gradlew pluginTask

结果：

> Task :pluginTask
task name is pluginTask  message is extension DSL change   message  what is 2

独立工程

buildSrc中创建插件只能在单一工程下多模块复用，要想在多个项目中复用就需要使用独立工程编写插件
，然后将插件上传到maven仓库中，最后在需要以来的项目中显式的添加对插件的依赖。

为了节省时间我们直接在本工程中创建一个standalone插件模块，但是我们要注意的是这是一个完全独立模块。
可以看到独立工程的模块和buildSrc模块结构是一样的。区别在于buildSrc代码在构建是自动会被编译并被引用。
而独立模块的则需要编译之后上传到maven仓库中，然后在需要引用的项目中显式的引用。

插件代码和之前一样只是改了名称

package com.myplugin

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

public class StandAlonePlugin implements Plugin<Project> {

    @Override
    void apply(Project target) {
        //插件扩展参数为名称 类型 和参数（可无）
        def extension = target.extensions.create("cusExtension",StandExtension)
        target.task("pluginTask"){
            doLast{
                println("task name is ${name}  message is ${extension.message}  what is ${extension.what}")
            }
        }
    }
}


class StandExtension{
    def message = "extension message"
    def what = 0
}

build.gradle则有的不同，因为需要发布到maven，所以增加了发布的代码:
引用依赖apply plugin: 'maven'，通过maven插件快速的配置group version和uploadArchives相关属性。
为了方便本次上传到主工程repo文件夹下面

apply plugin: 'groovy'
apply plugin: 'maven'
dependencies {
    implementation gradleApi()
    implementation localGroovy()
}
group 'com.myplugin.plugin'
version '1.0.0'
uploadArchives{
    repositories {
        mavenDeployer {
            repository(url:uri('../repo'))
        }
    }
}

然后执行命令gradlew uploadArchives或者在AS右侧边栏对应工程的tasks中找到uploadArchives，
点击执行。执行完毕后就可以在主工程找到repo目录。里面存放的是生成好的jar包与一些文件。maven-metadata.xml存放的是配置信息

<metadata>
  <groupId>com.myplugin.plugin</groupId>
  <artifactId>standalone</artifactId>
  <versioning>
    <release>1.0.0</release>
    <versions>
      <version>1.0.0</version>
    </versions>
    <lastUpdated>20191225120458</lastUpdated>
  </versioning>
</metadata>

然后我们就可以在主工程build.gradle依赖插件。依赖规则

classpath 'groupId:artifactId:version'

同时在repositories中添加依赖路径

maven {
 url uri('repo')
}
buildscript下配置代码如下：
buildscript {
    repositories {
        //maven仓库路径
        maven {
            url uri('repo')
        }
        google()
        jcenter()

    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.1'
        //依赖
        classpath 'com.myplugin.plugin:standalone:1.0.0'

    }
}

依赖完成后我们可以在对应的子工程的build.gradle中进行依赖插件

apply plugin :'standAlonePlugin'
cusExtension.message = "extension change    message"

//通过DSL块配置扩展
cusExtension{
    message = "extension DSL change   message"
    what = 2
}

执行命令：

gradlew pluginTask

输出日志：

StandAlonePlugin task name is pluginTask  message is extension DSL change   message  what is 2

说明引用成功。

总结：

1.插件分为脚本插件和对象插件
2.脚本插件直接在.gradle文件中编写，通过apply from '文件名.gradle'引用
3.对象插件需要继承Plugin类，实现apply方法。可以在当前build.gradle中编写也可以在buildSrc模块中
编写还可以在独立工程中编写。当前模块下编写的可以通过apply plugin :'ClassName'依赖。buildSrc和独立模块通过pluginId依赖apply plugin:'pluginId'

本文写的插件只是一些简单的插件，目的是简单了解一下gradle的流程。
本文参考：玉刚说文章
 官方自定义插件文章