Gradle 插件

亦凉 2023-09-28 05:17 134阅读 0赞

### 1、使用插件的原因 ###

通过应用插件可以:

> 1.促进代码重用、减少功能类似代码编写、提升工作效率  
> 2.促进项目更高程度的模块化、自动化、便捷化  
> 3.可插拔式的的扩展项目的功能

### 2、插件的作用 ###

在项目构建过程中做很多事情，把插件应用到项目中，通常可以完成:  
1、可以添加任务【task】到项目中，从而帮助完成测试、编译、打包等。  
2、可以添加依赖配置到项目中。  
3、可以向项目中拓展新的扩展属性、方法等。  
4、可以 对项目进行一些约定，如应用 Java 插件后，约定 src/main/java 目录是我们的源代码存在位置，编译时编译这个 目录下的 Java 源代码文件

### 3、插件的分类和使用 ###

![在这里插入图片描述][58cd29b96df6463c8dbc54ce2b0f9fbc.png]

第一种：脚本插件

脚本插件的本质就是一个脚本文件，使用脚本插件时通过 apply from:将脚本加载进来就可以了，后面的脚本文件可以是 本地的也可以是网络上的脚本文件，下面定义一段脚本，我们在 build.gradle 文件中使用它，具体如下：

//version.gradle文件 
    ext {
        
        company= "aa" 
        cfgs = [ 
            compileSdkVersion : JavaVersion.VERSION_1_8 
        ]
        spring = [
            version : '5.0.0' 
        ] 
    }

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

//build.gradle文件 
    //map作为参数 
    apply from: 'version.gradle' 
    task taskVersion{
         
        doLast{
         
            println "公司名称为：${company},JDK版本是${cfgs.compileSdkVersion},版本号是${spring.version}" 
        } 
    }

执行结果如下：

> >D:\\repos\\idearepos\\root> gradle -q taskVersion  
> 版本是2.0,版本号是1

**意义：** 脚本文件模块化的基础，可按功能把我们的脚本进行拆分一个个公用、职责分明的文件，然后在主脚本文件引用， 比如：将很多共有的库版本号一起管理、应用构建版本一起管理等。

第二种：对象插件之内部插件\[核心插件\]

二进制插件\[对象插件\]就是实现了 org.gradle.api.Plugin 接口的插件，每个 Java Gradle 插件都有一个 plugin id。

![在这里插入图片描述][1b95312088ad435d99fc48087cc6b6b7.png]

可通过如下方式使用一个 Java 插件：

`apply plugin : 'java' //map具名参数方式`

或者：

//也可以使用闭包作为project.apply方法的一个参数 
    apply{
        
        plugin 'java' 
    }

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

//使用方式1：Map具名参数,全类名 
    apply plugin:org.gradle.api.plugins.JavaPlugin 
    //org.gradle.api.plugins默认导入：使用方式2 
    apply plugin:JavaPlugin 
    apply plugin: 'java' //核心插件，无需事先引入，使用方式3:插件的id

Gradle 中提供的二进制插件【核心插件】,可参考:[https://docs.gradle.org/current/userguide/plugin\_reference.html][https_docs.gradle.org_current_userguide_plugin_reference.html]

第二种：对象插件之第三方插件

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

//使用传统的应用方式 
    buildscript {
         
        ext {
        
            springBootVersion = "2.3.3.RELEASE" 
        }
        repositories {
         
            mavenLocal() 
            maven {
         url 'http://maven.aliyun.com/nexus/content/groups/public' } 
            jcenter() 
        }
        // 此处先引入插件 
        dependencies {
         
            classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") 
        } 
    }
    //再应用插件 
    apply plugin: 'org.springframework.boot' //社区插件,需要事先引入，不必写版本号

但是如果是第三方插件已经被托管在[网站][Link 1]上，就可以不用在 buildscript 里配置 classpath 依赖了，直接使用新出的 plugins DSL 的方式引用，案例如下：

使用 plugins DSL 方式

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

注意：

1.如果使用老式插件方式 buildscript\{\}要放在 build.gradle 文件的最前面,而新式 plugins\{\}没有该限制。  
2.托管在网站 gradle 插件官网的第三方插件有两种使用方式，一是传统的 buildscript 方式，一种是 plugins DSL 方式 。

第二种：对象插件之用户自定义插件

interface GreetingPluginExtension {
         
        Property<String> getMessage() 
        Property<String> getGreeter() 
    }
    class GreetingPlugin implements Plugin<Project> {
         
        void apply(Project project) {
         
            def extension = project.extensions.create('greeting', GreetingPluginExtension)
            project.task('hello') {
         
                doLast {
         
                    println "${extension.message.get()} from ${extension.greeter.get()}" 
                } 
            } 
        } 
    }
    
    apply plugin: GreetingPlugin // Configure the extension using a DSL block 
    greeting {
         
        message = 'Hi' 
        greeter = 'Gradle' 
    }

直接执行 hello 任务./gradle hello 即可,这种方式实现的插件我们一般不使用，因为这种方式局限性太强，只能本 Project，而其他的 Project 不能使用。

### 4、buildSrc 项目 ###

buildSrc 是 Gradle 默认的插件目录，编译 Gradle 的时候会自动识别这个目录，将其中的代码编译为插件。

1.  首先先建立一个名为 buildSrc 的 java Module,将 buildSrc 从 included modules 移除,重新构建,然后只保留 build.gradle 和 src/main 目录，其他全部删掉,注意名字一定是 buildSrc,不然会找不到插件。
2.  然后修改 Gradle 中的内容

1.  创建入口目录，在 src/main 下创建代码入口目录
2.  然后实现插件代码 Text.groovy，注意文件后缀为 groovy,文件要引入 package com.atguigu

package com.atguigu 
    import org.gradle.api.Plugin 
    import org.gradle.api.Project 
    class Text implements Plugin<Project>{
         
        @Override 
        void apply(Project project) {
         
            project.task("atguigu"){
         
                doLast{
         
                    println("自定义atguigu插件") 
                } 
            } 
        } 
    }

1.  在 main 目录下创建 resources 目录,在 resources 目录下创建 META-INF 目录，在 META-INF 目录下创建 gradle-plugins 目录，在 gradle-plugins 目录下创建 properties 文件
2.  properties 文件可以自己命名，但是要以.properties 结尾，比如 com.atguigu.plugin.properties,其 com.atguigu.plugin 就是 定义的包名路径
3.  最后需要在 properties 文件中指明我们实现插件的全类名 implementation-class=com.atguigu.Text

到目前为止我们的插件项目已经写完了，在 module 引入我们写的插件 apply plugin:‘com.atguigu.plugin’,然后执行插件的 Task，./gradle atguigu

这种形式的写法，在我们整个工程的 module 都可以使用，但也只是限制在本工程，其他工程不能使用。

改进：

第二种写插件的方式他只能在本工程中使用，而其他的项目工程不能使用，有时候我们需要一个插件在多个工程中使用， 这时候我们就需要把插件上传 maven 中。  
第一步: 首先将上述 buildSrc 目录复制一份，修改文件夹名，然后在 settings.gradle 文件中使用 include 引入  
第二步：修改 build.gradle 文件，发布到 maven 仓库中

apply plugin: 'groovy' //必须 
    apply plugin: 'maven-publish' 
    dependencies {
         
        implementation gradleApi() //必须 
        implementation localGroovy() //必须 
    }
    repositories {
         
        google() 
        jcenter() 
        mavenCentral() //必须 
    }
    sourceSets {
         //把项目入口设置为src/main/groovy 
        main {
        
             groovy {
         
                srcDir 'src/main/groovy' 
            } 
        } 
    }
    publishing {
         
        publications {
         
            myLibrary(MavenPublication) {
         
                groupId = 'com.atguigu.plugin' //指定GAV坐标信息 
                artifactId = 'library' 
                version = '1.1' 
                from components.java//发布jar包 
                //from components.web///引入war插件，发布war包 
            } 
        }
        repositories {
        
            maven {
         url "$rootDir/lib/release" } 
            //发布项目到私服中 
            // maven { 
                // name = 'myRepo' //name属性可选,表示仓库名称，url必填 
                //发布地址:可以是本地仓库或者maven私服 
                // //url = layout.buildDirectory.dir("repo") 
                // //url='http://my.org/repo' 
                // // change URLs to point to your repos, e.g. http://my.org/repo 
                // //认证信息:用户名和密码 
                // credentials { 
                    // username = 'joe' 
                    // password = 'secret' 
                //} 
            // } 
        }    
    }

第三步：执行 publish 指令,发布到根 project 或者 maven 私服仓库。  
第四步：使用插件,在项目级 build.gradle 文件中将插件添加到 classpath：

buildscript {
         
        repositories {
         
            maven {
         url "$rootDir/lib/release" } 
        }
        dependencies {
         
            classpath "com.atguigu.plugin:library:1.1" 
        } 
    }
    apply plugin: 'java' 
    //是在 atguiguplugin 中定义的插件 ID 
    apply plugin: 'com.atguigu.plugin'

第五步：执行 gradle build 指令就会在控制台看到自定义插件的输出，说明自定义插件就已经生效了。

\{ url “$rootDir/lib/release” \}  
\}  
dependencies \{  
classpath “com.atguigu.plugin:library:1.1”  
\}  
\}  
apply plugin: ‘java’  
//是在 atguiguplugin 中定义的插件 ID  
apply plugin: ‘com.atguigu.plugin’

第五步：执行 gradle build 指令就会在控制台看到自定义插件的输出，说明自定义插件就已经生效了。

[58cd29b96df6463c8dbc54ce2b0f9fbc.png]: https://img-blog.csdnimg.cn/58cd29b96df6463c8dbc54ce2b0f9fbc.png
[1b95312088ad435d99fc48087cc6b6b7.png]: https://img-blog.csdnimg.cn/1b95312088ad435d99fc48087cc6b6b7.png
[https_docs.gradle.org_current_userguide_plugin_reference.html]: https://docs.gradle.org/current/userguide/plugin_reference.html
[Link 1]: https://plugins.gradle.org/