浅学习Gradle

一、什么是Gradle

Gradle 是一种开源构建自动化工具，足够灵活，可以构建几乎任何类型的软件。支持依赖管理和多项目，类似 Maven。

二、Gradle的优势

1. 具有高度可定制的属性，由于Gradle基于Groovy语言，提供了丰富且简洁的语法，可以像写代码一样在Gradle的脚本文件中编写对应的语句行对应的操作
2. Gradle的性能非常快速和高效
3. 在脚本文件里，根据约定进行配置，简洁易读

三、Gradle的基本术语

• Projects: Gradle是一个多项目构建工具，每个项目是一个特定的应用程序或库。
• Task：是Gradle的基本单元，它代表项目构建过程中的一个操作。例如，编译代码、运行测试、生成Javadoc等。

四、Gradle构建的生命周期

1. 初始化：为构建设置环境并确定哪些项目将参与其中。
2. 配置：执行gradle配置的脚本配置，确定需要运行哪些任务以及用何种顺序运行。
3. 执行：运行在配置阶段结束时选择的任务。

五、简单任务

定义

定义任务名称：任务名称必须是一个有效的标识符，以描述任务的具体操作。
指定任务依赖项：可以指定任务依赖项，即指定该任务必须在执行其它任务之后再执行。这样可以确保任务按正确的顺序执行，以避免出现构建错误。
配置任务行为：可以在任务中使用闭包或方法来定义任务的行为。

编写一个build.gradle文件：

task demo {
    // doFirst是一个闭包，在任务执行之前执行。使用doFirst可以在任务执行之前添加某些动作
    doFirst {
        println "start my task"
    }
    
    // doLast是一个闭包，在任务执行之后执行。使用doLast可以在任务执行之后添加某些动作
    doLast {
        println "end my task"
    }
}

依赖

任务的依赖是指一个任务需要另一个任务完成之后才能执行。通过定义任务之间的依赖关系，可以确保任务按正确的顺序执行，从而避免构建错误。
任务依赖关系可以是单向的，也可以是双向的。

task A {
    doFirst {
        println "任务A"
    }
}

task B(dependsOn:"A") {
    doFirst {
        println "任务B"
    }
}

也可以依赖多个任务

task C {
    dependsOn(B, A)
    doFirst {
        println "任务C"
    }
}

注意：使用dependsOn依赖的任务会默认在当前任务之前执行。

多依赖顺序执行

task D {
    dependsOn A,B
    // 表示被依赖的任务必须在当前任务之前执行，即强制必须按指定的顺序执行。
    mustRunAfter B
    // 表示被依赖的任务应该在当前任务之前执行，即尽量按指定的顺序执行，但不是必须的。
    shouldRunAfter A
    doFirst {
        println "任务C"
    }
}
A.dependsOn(B)

注意：如果存在循环依赖或者不能解析依赖关系导致的死锁情况，Gradle会抛出异常。因此，在定义任务依赖关系时应该避免循环依赖，并确保依赖关系正确。

动态任务

动态任务是在构建运行时根据条件动态地生成的任务，可以根据需要在构建过程中动态地生成或删除任务。

task executeTasks {
    doLast {
        tasks.findAll {it.name.startsWith("task")}.each { task ->
            println "Executing ${task.name}"
        }
    }
}

(1..5).each { num ->
    def taskName = "task${num}"
    tasks.create(taskName) {
        doLast {
            println "Task ${taskName} has been executed."
        }
    }
    executeTasks.dependsOn(tasks."${taskName}")
}

任务属性定义

任务属性定义语法是在任务对象外部使用ext关键字，并使用属性名来定义任务属性。

task myTask {
    ext.myProperty = "Hello, world!"
    doLast {
        println myProperty
    }
}

定义方法

String appenStr(String s1, String s2) {
    return s1 + s2
}

task myTaskB {
    doLast {
        println appenStr("Hello", "Gradle")
    }
}

懒加载方式(只有在当任务被使用时才会进行初始化)：

def myMethod() {
    println "我的方法"
}

project.getTasks().register("myTask") {
    doLast {
        myMethod()
    }
}

另一种定义方式：

// 此处表示是一个自定义的任务类型
// 需要注意的是，@TaskAction只存在于继承自DefaultTask的类型中
class MyTaskC extends DefaultTask {
    @TaskAction
    def myAction() {
        println "Hello, World!"
    }
}

task myTaskC(type: MyTaskC)

定义默认方法

定一个或多个默认任务，也可以使用settings.gradle.kts文件中的rootProject.defaultTasks属性来指定。
在执行gradle命令时，如果没有指定要执行的任务，则会默认执行myTaskC和myTask这两个任务。

rootProject.defaultTasks("myTaskC", "myTask")

设置监听

gradle.taskGraph.whenReady { taskGraph ->
    println "=== Task Execution Graph ==="
    taskGraph.getAllTasks().each { task ->
        println task.name
    }
    println "=== End of graph ==="
}

六、Java仓库配置

// Maven仓库中心
repositories {
    mavenCentral()
}

// 本地Maven仓库
repositories {
    mavenLocal()
}

// 自定义的仓库地址
repositories {
    maven {
        url "仓库地址"
    }
}
// 需要密码的仓库的配置方式- 基本认证方式
repositories {
    maven {
        url '仓库地址'
        credentials {
            username "user"
            password "password"
        }
        authentication {
            basic(BasicAuthentication)
        }
    }
}
// 需要密码的仓库的配置方式- Header认证方式
repositories {
    maven {
        url "仓库地址"
        credentials(HttpHeaderCredentials) {
            name = "Private-Token"
            value = "TOKEN"
        }
        authentication {
            header(HttpHeaderAuthentication)
        }
    }
}

七、依赖

作用域

compileOnly（仅在编译时）、annotationProcessor（编译时）、testImplementation（测试时，编译和运行时）、implementation（编译和运行时）、runtimeOnly（仅在运行时）等

dependencies {
    implementation '依赖地址'
    compileOnly '依赖地址'
    annotationProcessor '依赖地址'
    testImplementation '依赖地址t'
    implementation '依赖地址'
}

排除依赖

dependencies {
    implementation('依赖地址') {
        exclude group: '依赖地址'
    }
    implementation '依赖地址'
}

禁止传递依赖

每个依赖项都可以有一个或多个transitive依赖项，这些依赖项通常是该依赖项所依赖库的依赖项。transitive依赖项通常是自动传递的，因为一个库很少能够在自己的代码中实现所有功能。因此，当一个库被引入项目中时，它可能还会引入其他依赖项。Gradle的默认行为是启用transitive依赖项。
使用transitive关键字来控制依赖项的transitive依赖。例如，使用transitive = false将禁用依赖项的transitive依赖，

dependencies {
    implementation('依赖地址') {
        transitive = false
    }
}

八、详细学习和高级使用方法，参考书籍

《实战Gradle》