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 介绍
Gradle真能干掉Maven？今天体验了一把，贼爽！