首页 > 其他分享> 文章详细

Gradle入门

2022-05-16 00:04:46 阅读：145 来源： 互联网

标签：插件 task 入门 gradle build println Gradle

Gradle基础
- Gradle的基础概念
  - Distribution
  - Wrapper
  - GradleUserHome
  - Daemon
- Groovy基础
  - 动态调用与MOP
  - 闭包
Gradle构建
- Gradle的核心模型
  - Project
  - Task
  - Lifecycle与Hook
插件编写
- 构建逻辑的复用
- 简单插件
- script插件
- buildSrc插件
- 发布的插件
实际插件分析

Gradle基础

Gradle的基础概念

Distribution

Gradle官网最新发行版下载：http://services.gradle.org/distributions/

一般地，我们不需要通过这种方式去下载gradle，其实我们也可以通过wrapper的方式下载

gradle安装配置：
https://www.cnblogs.com/Ai-Hen-Jiao-zhi/p/14375265.html

gradle安装包项目结构

Wrapper

由于Gradle发布版本太快，在项目中为了保持版本的稳定，一般的方式是使用wrapper

cd wrapper-demo
gradle init #创建的 Java 项目目录结构（或使用gradle wrapper）

gradle的gradle-wrapper.jar包很小

在项目根目录下新建一个空的build.gradle脚本
执行./gradlew wrapper命令，会启动一个非常轻量级的JVM Client，加载gradle-wrapper.jar文件，然后去下载gradle-wrapper.properties文件中指定的gradle版本，保证了项目版本的稳定

GradleUserHome

gradle除了与项目打交道，还会与user家目录（~/.gradle）打交道

Daemon

maven的构建，本质上是启动了一个Maven的JVM进程，在里面执行Lifecycle等等，所有的事情都是在一个JVM中做了。
而在Gradle中构建不太一样，JVM启动很慢，而且要加载很多的jar包；因此，在Gradle3.0之后默认使用daemon模式
daemon是什么？

例如：
./gradlew compileJava启动一个任务
1).gradlew脚本先会启动一个非常轻量级的JVM，检查有没有安装对应版本的gradle(如7.4.2)；若有，则执行下一步，否则，下载该版本；
2).查找7.4.2版本的Daemon JVM进程（并与当前构建参数所兼容的），若没有找到，则启动一个Daemon，否则，连接这个Daemon（Socket连接）。

执行一下命令，第三条命令明显加快了：
./gradlew --stop
./gradlew help
./gradlew help

Groovy基础

动态调用与MOP

List l = []
Map m = [a:1]

class A {
    int a

    void printA() {
        println(a)
    }
}

// Java: invokedynamic
new A(a: 1).printA()
// Groovy: MOP
def a = new A(a: 1)

invokeMethod(a, "printA", [])

a['printA']()

闭包

//List list = [1,2,3,4,5]
//
//list.findAll {it % 2 != 0}

//List result []
//for (int e: list) {
//    if(e%2 != 0) {
//        result.add(e)
//    }
//}
//
//list.stream().filter().collect()


def closure = { it + 1 }

println(closure(2))

def test(int i, Closure c) {
    return c(i)
}

println test(2, { 2 * it })
println test(2) { 2 * it }

//plugins({
//    id("com.diffplug.gradle.spotless").version("3.13.0")
//})

buildscript({
    ext {

    }
})

Gradle构建

Gradle的核心模型

Project

vim build.gradle

println "helloworld"

使用IDEA打开build.gradle，作为Project打开

gradle lifecycle分为三个：

Task

//println "helloworld"

task('helloworld', {
    println('configure')

    doLast({
        println('Executing task')
    })
})

一个closure是一个configuration

DSL写法：

//println "helloword"

task('helloword') {
    println('configure')

    doLast {
        println('Executing task')
    }
}

动态使用task:

//for (int i = 0; i < 10; i++) {
//    task('task' + i) {
//        def captureI = i
//        doLast {
//            println("Excution task ${captureI}")
//        }
//    }
//}

task('first') {
    println('configuring')

    doLast { println("I'm first task") }
}

(0..<10).each { i ->
    task('task' + i) {
        def captureI = i
        doLast {
            println("Excution task ${captureI}")
        }
    }
}

Lifecycle与Hook

钩子函数，在依次完成Initialization(初始化)、Configuration之后，执行Task（Execution）之前被执行
代码：

afterEvaluate {
    println('after evaluate')
}

task('first') {
    println('configuring')

    doLast { println("I'm first task") }
}

(0..<10).each { i ->
    task('task' + i) {
        def captureI = i
        doLast {
            println("Excution task ${captureI}")
        }
    }
}

执行结果：

插件编写

构建逻辑的复用

所谓的插件，就是逻辑的打包结构

class MyAwesomePlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        (0..<10).each { i ->
            project.task('task' + i) {
                def captureI = i
                doLast {
                    println("Excution task ${captureI}")
                }
            }
        }
    }
}

apply plugin: MyAwesomePlugin

groovy去语法糖：
apply plugin: MyAwesomePlugin
等价于：apply([plugin: MyAwesomePlugin])

其实结果就是调用MyAwesomePlugin类的apply函数：

简单插件

我们还可以把通用插件MyAwesomePlugin放到服务器上，直接通过URL使用：
apply plugin: 'http://myserver.com/my-script'

script插件

1).build.gradle要使用的工具类，必须要先引入到build.gradle的classpath中，同理，compileJava要使用的类，也必须要先引入到compileJava的classpath中，才可以直接使用它。
例：在build.gradle要使用StringUtils工具类，该怎么做呢？
必须要为这个构建脚本额外的声明一个buildscript，它的classpath有一套独立的系统

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
    }
}

这样，就完成在build.gradle的构建脚本中享用第三方类库的过程

import org.apache.commons.lang3.StringUtils

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
    }
}

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
}

if (StringUtils.isNotEmpty()) {
    // Execute builds
}

2).要在build.gradle中使用你的Java类（如：MyPlugin），必须要把你的MyPlugin所在的jar包，加入到你的构建脚本的classpath中
如：

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath group: 'com.mycompany.myplugin', name: 'myplugin', version: '1.0.0'
    }
}

apply plugin: MyPlugin

buildSrc插件

在build.gradle中使用你的Java类，还可以这么做：
1).在外层build.gradle中应用你的插件
apply plugin: MyPlugin
2).在build.gradle同级目录创建buildSrc文件夹，新建空的build.gradle，并在src/main/java路径编写你的插件类

运行流程：
在外层的build.gradle运行之前，首先会编译buildSrc，然后把这些代码打包输出的结果（jar包）添加到外层build.gradle的buildscript的classpath中；
所以自动添加到了build.gradle的classpath中，只要apply plugin: MyPlugin直接使用它。
这是一种把逻辑抽取成公有逻辑的方法，把它变成一个独立的项目放在buildSrc中，这个非常像Maven中的install到本地目录，然后在项目中去引用它。

发布的插件

实际插件分析

参考链接：
来自Gradle开发团队的Gradle入门教程
 gradle安装配置
 Gradle Wrapper 介绍

标签：插件,task,入门,gradle,build,println,Gradle
来源： https://www.cnblogs.com/yydscn/p/16273319.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9