本篇文章主要介绍 Gradle 插件，Gradle 内置了很多常用的插件，Gradle 中的插件可在一定的场景中可以帮助我们提高开发效率，可以通过扩展现有的插件来实现更多功能，比如 Android Gradle 插件就是基于内置的 Java 插件来实现的。

  1. 插件的作用
  2. 如何应用一个插件
  3. 自定义插件

插件的作用

先来一下 Gradle 插件的作用，主要有以下几个方面：

  1. 添加任务到项目中，可对项目进行测试、编译、打包；
  2. 添加依赖到项目中，可用来配置项目构建过程中需要的依赖；
  3. 可以向项目中现有的对象类型添加新的扩展属性、方法等，可方便项目的配置和构建优化，比如 Android 项目构建中的 android{} 就是 Android Gradle 插件为 Project 对象添加的一个扩展；
  4. 可以对项目进行一些约定，如使用 Java Gradle 插件可以约定 src/main/java 目录下源代码的存放位置，在编译的时候就可以编译指定目录下的 Java 源代码文件。

如何应用一个插件

在使用一个插件之前要先使用 Project 的 apply 方法来应用该插件，插件分为二进制插件和脚本插件。

二进制插件的使用

二进制插件就是实现了 org.gradle.api.Plugin 接口的插件，每个 Java Gradle 插件都有一个 plugin id，可以通过如下方式使用一个 Java 插件：

  1. apply plugin : 'java'

通过上述代码就将 Java 插件应用到我们的项目中了，其中 java 是 Java 插件的 plugin id，对于 Gradle 自带的核心插件都有唯一的 plugin id，这里的 java 对应的具体类型是 org.gradle.api.plugins.JavaPlugin，所以可以使用如下方式使用 Java 插件：

  1. apply.plugin:org.gradle.api.plugins.JavaPlugin
  2. //org.gradle.api.plugins默认导入
  3. apply.plugin:JavaPlugin

二进制插件一般是打包在一个 Jar 中发布的，如自定义插件的时候在发布的时候要指定插件的 Plugin id，这个 plugin id 必须是唯一的，可使用应用包名来保证 plugin id 的唯一性。

脚本插件的使用

脚本插件的使用实际上就是某个脚本文件的使用，使用脚本插件时将脚本加载进来就可以了，使用脚本插件要使用到关键字 from，后面的脚本文件可以是本地的也可以是网络上的脚本文件，下面定义一段脚本，我们在 build.gradle 文件中使用它，具体如下：

  1. //version.gradle文件
  2. ext{
  3.     versionName = "1.0"
  4.     versionCode = 1
  5. }

下面将将在构建文件中使用这个脚本文件，具体如下：

  1. //build.gradle文件
  2. apply from: 'version.gradle'
  4. task taskVersion{
  5.     doLast{
  6.         println "版本是${versionName},版本号是${versionCode}"
  7.     }
  8. }

上述代码的执行结果如下：

  1. PS E:\Gradle\study\GradlePlugin> gradle taskVersion
  3. > Task :taskVersion
  4. 版本是1.0,版本号是1
  7. BUILD SUCCESSFUL in 2s
  8. 1 actionable task: 1 executed

显然，通过 apply from 引用到插件脚本了，脚本插件的使用可将构建使用的脚本文件分段整理，可将脚本文件分离成职责分明的单个脚本文件，然后直接使用 apply from 关键字来使用这些脚本文件，如可将某些工具性质的方法以及各个依赖使用的版本号分别定义到单个 gradle 文件中，方便统一调用和管理各个依赖的版本号等。

apply方法的用法

Project.apply() 可以接收三种不同的参数，具体如下：

  1. //闭包作为参数
  2. void apply(Closure closure);
  3. //配置一个ObjectConfigurationAction
  4. void apply(Action<? super ObjectConfigurationAction> action);
  5. //Map作为参数
  6. void apply(Map<String, ?> options);

使用上面三种方式可以配置一个插件，三种方式的写法如下：

  1. //Map作为参数
  2. apply plugin:'java'
  3. //闭包作为一个参数
  4. apply{
  5.     plugin 'java'
  6. }
  7. //配置一个ObjectConfigurationAction
  8. apply(new Action<ObjectConfigurationAction>() {
  10.     @Override
  11.     void execute(ObjectConfigurationAction objectConfigurationAction) {
  12.         objectConfigurationAction.plugin('java')
  13.     }
  14. })

使用第三方发布的插件

大多时候需要第三方的插件来构建项目，使用的时候必须要在 buildscript{} 里配置 classpath 才能使用，如 Android Gradle 插件使用的时候就需要在 buildgradle{} 里面配置对应的 classpath，代码参考如下：

  1. buildscript {
  2.     repositories {
  3.         google()
  4.         jcenter()
  5.     }
  6.     dependencies {
  7.         classpath 'com.android.tools.build:gradle:3.0.1'
  8.     }
  9. }

buildscript{} 块主要是在项目构建之前配置好项目构建的相关依赖，配置好这些依赖就可以通过如下方式使用插件了：

  1. //使用时必须先在buildscript{}中配置相应的classpath
  2. apply plugin: 'com.android.application'

使用plugins DSL应用插件

plugins DSL 是一种新的插件的应用方式，这种方式只能在 Gradle 2.1 以上才可以使用，使用方式参考如下：

  1. //plugins DSL 方式
  2. plugins{
  3.     id 'java'
  4. }
  5. //如果第三方插件托管到https://plugins.gradle.org/,就不用在
  6. //buildscript中配置classpath了
  7. plugins{
  8.     id "插件id" version '插件版本号'
  9. }

关于插件的使用就到此为止。

自定义插件

大多时候需要自定义插件来完成一些项目的构建操作，自定义插件必须实现 Plugin 接口，接口中的 apply 方法会在插件被应用的时候执行，可实现该方法在里面进行相关操作，下面使用 Android Studio 来进行一个简单插件的开发，插件的作用创建一个任务，这里主要借助 Android Studio 来创建一个 Groovy 工程，然后进行相关代码的开发。

在 Android Studio 中创建一个 Module , 删除出 src/main、build.gradle 以外的其他文件，然后创建一个 .groovy 文件实现 Plugin 接口，文件内容如下：

  1. package com.manu.plugin
  3. import org.gradle.api.Plugin
  4. import org.gradle.api.Project
  6. /**
  7.  * 自定义插件
  8.  */
  9. class MPlugin implements Plugin<Project>{
  11.     @Override
  12.     void apply(Project target) {
  13.         target.task('taskPlugin')  {
  14.             doLast {
  15.                 println "自定义插件创建任务"
  16.             }
  17.         }
  18.     }
  19. }

然后，指定该插件的 plugin id，在 src/main 下面创建 resources/META-INF/gradle-plugins 目录，然后创建一个带有 plugin id 的 properties 文件，文件内容如下：

  1. //指定插件具体实现类
  2. implementation-class=com.manu.plugin.MPlugin

下面是 build.gradle 文件对应的配置参考如下：

  1. apply plugin: 'groovy'
  3. dependencies {
  4.     //gradle sdk
  5.     compile gradleApi()
  6.     //groovy sdk
  7.     compile localGroovy()
  8. }

可以说一个简单的插件就定义好了，为了方便实用将该插件项目生成 jar 包，然后就可以在其他项目中使用了，下面来一张自定义插件项目目录截图：

Gradle(五) Gradle插件 - 图1

最后，在构建项目中使用该插件，复制插件到某个项目中，如复制到项目中的 libs 文件夹中，指定插件的 classpath ，使用 apply 方法使用插件即可：

  1. apply plugin: 'com.manu.plugin'
  3. buildscript{
  4.     dependencies{
  5.         classpath files('libs/plugin.jar')
  6.     }
  7. }

上述代码的执行结果如下：

  1. PS E:\Gradle\study\GradlePlugin> gradle taskPlugin
  3. > Task :taskPlugin
  4. 自定义插件创建任务
  7. BUILD SUCCESSFUL in 2s
  8. 1 actionable task: 1 executed

因为插件创建了任务 taskPlugin，所以可以使用该任务，插件的基本使用如上所述，接下来将会继续学习 Java Gradle 插件的使用。