1. Gradle插件是什么

Gradle插件(Plugin)是一种用于扩展和定制Gradle构建系统功能的机制。Gradle插件可以执行各种任务，包括编译代码、执行测试、打包文件、生成文档等等。插件可以访问和操作Gradle的构建模型，如项目、任务、依赖关系等等，从而实现对构建过程的控制和定制。
许多流行的工具和框架，例如Kotlin，Spring Boot，Android都有相应的Gradle插件。
比如熟悉的Android插件com.android.application

plugins {id 'com.android.application'
}

2. 为什么需要插件

• 定制：如果需要在编译期做一些插桩，Hook之类的自定义操作，也需要用到编译插件
• 封装：把具体的逻辑抽出去，只需运行插件，不需要写在某个build.gradle文件中
• 复用：把通用的逻辑抽离出去，需要用的时候apply应用插件即可，不需要一遍遍的复制，也可以提供给别的项目使用

3. 编写插件位置

• 写在build.gradle文件中，作用域当前project
• 写在buildSrc里，作用域为当前项目所有
• 写在单独项目里，发布后可提供给所有项目

4. 编写插件

编写一个插件Plugin，只需要实现Plugin接口，并实现唯一apply方法即可。
在build.gradle文件中

class YiRanPlugin implements Plugin<Project>{@Overridevoid apply(Project target) {println("this is plugin ${this.class.name}")}
}apply plugin: YiRanPlugin

apply方法是调用的PluginAware接口的apply()方法，参数是一个map,用来映射Plugin id

点击sync，输出结果

Task是Project里的方法，我们可以通过Project取创建一个Task，apply方法中提供了Project对象，可以通过Plugin去创建一个Task

class YiRanPlugin implements Plugin<Project>{@Overridevoid apply(Project target) {println("this is plugin ${this.class.name}")target.task("YiRanPluginTask"){task ->task.doLast{println("this is Plugin ${this.class.name},create a task ${task.name}")}}}
}apply plugin: YiRanPlugin

我们在Plugin里创建了一个Task，这时候sync是不会执行Task里面打印的东西，因为是doLast在 task 执⾏过程中被执⾏，发⽣在 execution 阶段。因此需要单独执行

./gradlew YiRanPluginTask    

输出

> Configure project :app
this is plugin YiRanPlugin> Task :app:YiRanPluginTask
this is Plugin YiRanPlugin,create a task YiRanPluginTask

当我们依赖YiRanPlugin插件的时候，这个apply就会把插件放到PluginContainer里，同时这个apply也是在编译阶段执行Plugin接口的apply()方法，所有sync同步后构建会有输出。

5. 自定义插件扩展

自定义插件的时候经常会有这种自定义配置的需求，通过自定义的配置可以让我们的插件提供更丰富的能力。这些配置就是通过扩展插件来的。

5.1 订阅扩展对象

可以是一个接口，也可以是一个类

interface YiRanPluginExtension{Property<String> getTitle()
}

5.2 把扩展添加给Plugin并使用

class YiRanPlugin implements Plugin<Project>{@Overridevoid apply(Project target) {println("this is plugin ${this.class.name}")def extension = target.extensions.create("YiRan",YiRanPluginExtension)target.task("YiRanPluginTask"){task ->task.doLast{println("this is Plugin ${this.class.name},create a task ${task.name}")println("-------")println(extension.title.get())}}}
}

target.extensions.create方法接收两个参数：

• 1.名字，比如android，YiRan
• 2.扩展对象，然后返回这个扩展对象，通过这个扩展对象的方法可以获取自定义的配置参数

5.3 配置参数

有两种方式可以写

YiRan.title = "YiRan"

YiRan{title = "YiRan"
}

如果没有设置配置参数的话，Gradle也提供了默认值的配置

extension.title.convention("YiRan")

5.4 嵌套扩展

向我们app目录下的build.gradle文件中，android{}里面还有defaultConfig{}

android {namespace 'com.example.gradlestudy'compileSdk 35defaultConfig {applicationId "com.example.gradlestudy"minSdk 24targetSdk 34versionCode 1versionName "1.0"testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"}
}

嵌套扩展其实就是套娃

5.4.1 定义扩展

class YiRanPluginExtension{String titleint chapterNumSubExtension subExtensionYiRanPluginExtension(Project project){subExtension = project.extensions.create("sub",SubExtension.class)}
}class SubExtension{String author
}

增加定义了一个SubExtension类，然后在YiRanPluginExtension实例化的时候加到ExtensionContainer中。
类嵌套的话，不能写成内部类，不然编译识别不过。

5.4.2 获取扩展属性

class YiRanPlugin implements Plugin<Project>{@Overridevoid apply(Project target) {println("this is Plugin：${this.class.name}")def extension = target.extensions.create("YiRan",YiRanPluginExtension)target.task("YiRanTaskPluginTask"){ task ->task.doLast{println("this is Plugin ${this.class.name},create a task ${task.name}")println("title = ${extension.title}")println("chapter = ${extension.chapterNum}")println("author = ${extension.subExtension.author}")}}}
}

可以看到和上面的例子，少了Property对象的.get()方法，如果需要的话，在类对象定义即可，例如
增加setter/getter方法

class YiRanPluginExtension{String titleint chapterNumSubExtension subExtensionYiRanPluginExtension(Project project){subExtension = project.extensions.create("sub",SubExtension.class)}void setTitle(String name){title = name}String getTitle(){return title}
}

使用的时候

extension.setTitle("调用get方法")
extension.getTitle()

5.4.3 使用

YiRan{title = "测试一下"chapterNum = 100sub{author = "YiRan"}
}

闭包配置中多了一个sub｛｝的闭包，就是在YiRanPluginExtension类中定义的

5.4.4 执行

./gradlew YiRanTaskPluginTask       

5.4.5 输出

6. 编写在单独项目里

上面的例子，我们的Plugin是写在build.gradle文件中，而在实际项目中，为了复用，一般都是写在buildSrc或者单独项目中。
测试写一个打印项目中所有依赖的插件

6.1 新建Module

类型选择Library，或下面的Java or Kotlin Library

6.2 新建文件添加依赖

6.2.1 添加依赖

在plugin>build.gradle文件中依赖插件：

//java、gradleApi()依赖
apply plugin:'java-gradle-plugin'
//kotlin
apply plugin: 'org.jetbrains.kotlin.jvm'

6.2.2 新建类

新建一个DependenciesPlugin类

6.3 本地发布

6.3.1 Maven插件

在plugin>build.gradle文件中先依赖一个maven发布的插件’maven-publish’

apply plugin: 'maven-publish'dependencies {implementation 'com.android.tools.build:gradle:8.6.1'}

6.3.2 发布配置

添加发布配置

group 'com.example.plugin'
version '1.0.1'publishing {//配置Plugin GAVpublications {maven(MavenPublication){groupId = groupartifactId = 'dependencies'version = version}}//配置仓库地址repositories {maven {url layout.buildDirectory.dir("maven-repo")}}
}

6.3.3 执行发布操作

./gradlew publish

build文件夹下生成有本地发布配置的maven-repo文件夹

6.4 使用

1.settings.gradle文件中配置仓库地址

pluginManagement {repositories {// ...maven {url './plugin/build/maven-repo'}
}
}

dependencyResolutionManagement {repositories {// ...maven {url './plugin/build/maven-repo'}}
}

libs.versions.toml中添加插件依赖

[plugins]
//-----
dependencies = { id = "com.example.plugin.dependencies", version.ref = "dependencies" }

app目录build.gradle引入

plugins {
//------alias(libs.plugins.dependencies)
}

本地依赖使用的时候，要先发布，再依赖插件，否则就会出现cannot found找不到依赖的情况。
编译查看效果

> Configure project :app
---> com.example.plugin.DependenciesPlugin

能够正确打印

6.5 具体功能实现

上面只是一个打印，继续实现我们的功能，把所有的依赖打印出来。
打印依赖的方式有很多，比如可以使用Gradle命令

./gradlew app:dependencies

改造Plugin

package com.example.pluginimport com.android.build.gradle.AppExtension
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.Dependency
import org.gradle.api.artifacts.ModuleVersionIdentifierclass DependenciesPlugin:Plugin<Project> {companion object{const val TAG = "DependenciesPlugin  >>>>>"}override fun apply(target: Project) {println("---> ${this.javaClass.name}")//获取扩展对象val extension:DependenciesPluginExtension = target.extensions.create("printDependencies",DependenciesPluginExtension::class.java)//配置阶段完成才能读取参数，才能拿到所有依赖target.afterEvaluate {extension.getEnable.convention(false)if(extension.getEnable.get()){println("$TAG 已开启依赖打印")val androidExtension:AppExtension = target.extensions.getByType(AppExtension::class.java)androidExtension.applicationVariants.all { applicationVariant->println("$TAG >>>>>> applicationVariant.getName() = ${applicationVariant.name}")val configuration:Configuration = applicationVariant.compileConfigurationval allDependencies:Set<Dependency> = configuration.allDependenciesval androidLibs = ArrayList<String>()val otherLibs = ArrayList<String>()configuration.resolvedConfiguration.lenientConfiguration.allModuleDependencies.forEach {resolvedDependency ->val identifier: ModuleVersionIdentifier = resolvedDependency.module.idif(identifier.group.contains("androidx")||identifier.group.contains("com.google")||identifier.group.contains("org.jetbrains")){androidLibs.add(identifier.group+":"+identifier.name+":"+identifier.version)}else{otherLibs.add(identifier.group+":"+identifier.name+":"+identifier.version)}}println("--------------官方库 start--------------");androidLibs.forEach(System.out::println);println("--------------官方库 end--------------");println("--------------三方库 start--------------");otherLibs.forEach(System.out::println);println("--------------三方库 end--------------");}}else{println("$TAG 已关闭依赖打印")}}}
}

project.afterEvaluate方法中去获取扩展配置，因为apply plugin的执行时机早于扩展配置，否则获取不到扩展配置的值
扩展：

package com.example.pluginimport org.gradle.api.provider.Propertyinterface DependenciesPluginExtension {val getEnable:Property<Boolean>}

使用：

printDependencies {setGetEnable(true)
}

编译输出：

通过独立项目中定义插件，把所有依赖的区分打印出来了。