gradle入门

构建系统介绍

以前只会用 make,第一次接触 gradle 时,明显感觉和 make 的套路很不一样。如果说 make 是通用构建系统,那 gradle 构建脚本第一眼看上去甚至感觉跟构建毫无关联。

本文章解决的疑问: 对比 make/ant, 为什么 gradle 被称为构建系统以及和其他构建系统的相似之处。

make

make 是一个非常古老且经久不衰的构建系统。

make 的关键: shell/文件。

make 的规则

make 是基于 shell 的构建系统。

make 的规则非常简单,一个简单的用法就是把长命令精简为短命令. 下面是一个简单的例子。


mycli:
    echo "this is a very very long command!"
    echo "this is another very very long command!"

将上面的内容保存到当前目录的 makefile 文件,然后测试以下命令。

$ make mycli

    echo "this is a very very long command!"
    this is a very very long command!
    echo "this is another very very long command!"
    this is another very very long command!

这种用法下, make 相当于给一组命令提供了快捷方式,当执行 make <shortcut> 的时候,
就会执行对应的命令,而且会把执行的命令打印出来。
不过一般情况下,这样回显命令不太好看,可以加上 -s 取消回显。
(在每条命令前面加上 @ , 也可以防止命令回显)

$ make -s mycli

    this is a very very long command!
    this is another very very long command!

这个例子中 mycli 可以看作是make 的 目标.

make 目标的依赖

声明目标时,可以冒号后面声明依赖的子目标。
语法如下:

<target>: <subtarget1> <subtarget2>
    command1
    command2
    ...

<subtarget1>: ...
    ...

上面声明的 target 依赖了 subtarget1/subtarget2

make 目标的状态

make 真正的作用是作为构建系统,而 make 的目标有另外一层含义,
目标一般来说并不是一个简单的字符串,而是一个文件名。

下面看一个真实的例子:

# 过滤出 test.txt 里面所有非空行, 生成 content.txt
content.txt: test.txt
    grep -E ".+" test.txt > content.txt

测试:

$ make content.txt
    grep -E ".+" test.txt > content.txt

$ make content.txt
    make: “content.txt”已是最新。

可以看到,第一次生成 content.txt 后,第二次执行 make 会跳过命令,
它的原理是比较目标和依赖的时间戳,只有发现依赖(test.txt)更新的情况下
才会执行下面的 grep 命令生成(content.txt)目标。
即 make 通过文件系统时间戳来表示构建目标的状态。

这另一个例子,组合了上面所有特性。


backup.tar.gz: content.txt
    tar -zcvf backup.tar.gz userlist.txt

content.txt: test.txt
    grep -E '.*' text.txt > content.txt

ant

apache ant 是一个类似 make 的构建系统,主要优势在于使用 java 编写,跨平台。

下载地址

对比

ant 与 make 对比

_makeant
目标文件字符串
脚本makefilexml
指令shelljava class

样例

一个简单的 ant 脚本(build.xml):

<project name="MyProject">
    <target name="MyTarget" depends="SubTarget">
        <echo message="This is target message." level="error"/>
    </target>
    <target name="SubTarget">
        <echo message="This is sub-target message1." />
        <echo message="This is sub-target message2." />
    </target>
</project>

运行效果:

$ ant MyTarget
Buildfile: D:\sphinx\record\docs\gradle\build.xml

SubTarget:
     [echo] This is sub-target message1.
     [echo] This is sub-target message2.

MyTarget:
     [echo] This is target message.

BUILD SUCCESSFUL
Total time: 0 seconds

这个组织结构和 makefile 很像。

原理

xml 中分为三层: project、target、task。
其中 target 即对应 makefile 中的目标,重点是 task。

makefile 中 task 一般对应一条 shell 命令,而 ant 的 task 一般对应执行了一个 java class。

例如 <echo message="This is target message." level="error"/>, 可以翻译成代码:
new Echo("This is target message", "error").execute(),

echo 伪代码如下:

public class Echo extends Task {
    Echo(String message, String level) {
        this.message = message;
        this.level = level;
    }
    void execute() {
        System.out.println("[%s] %s", this.level, this.message);
    }
}

ant 中内置了很多这种常用 task 。而且用户也可以自己实现自定义 Task。

构建系统的基本要素

从 make 和 apache ant 中可以大致感知到, 构建系统两个重要功能就是:

  1. 状态管理(增量构建)
  2. 依赖管理(DAG 图)

gradle

gradle 是一个更偏向 Java 定制化的构建工具。

使用的话,最好使用新版的 gradle,如果要跟 jetbrains、kotlinDsl 结合使用,最好用 gradle-all 版本。

下面的例子全部使用 kotlin-dsl 举例,构建脚本为 build.gradle.kts

注意: 使用 jetbrains idea 可以对 gradle 构建脚本有更好的提示。

简介

gradle 使用 groovy/kotlin 语言作为构建语言,可以理解为是一个构建脚本。

Ant 中存在 project、target、task 的概念,gradle 也拥有 project/task 的概念。对比如下

概念antgradle
项目projectproject
构建目标targettask
构建指令taskgroovy/kotlin代码

需要注意的是 gradle 的 task 对应了 ant 的 target。
脚本中可以通过类似与引用全局变量的方式引用 tasks。

用法

// build.gradle.kts
tasks.register("hello") {
    doLast {
        println("Hello world!")
    }
}
tasks.register("intro") {
    dependsOn("hello")
    doLast {
        println("I'm Gradle")
    }
}

运行:

$ gradle intro

    Hello world!
    I'm Gradle
  • task.register(name: String): 定义指定名称的 task, 大括号体包含构建这个 task 的代码。
  • doLast: task 构建完成后的执行函数。
  • dependsOn: 本 task 依赖的其他 task。

也可以编写任意复杂的脚本。

repeat(4) {
    tasks.register("intro${it}") {
        doLast {
            println("I'm ${it}")
        }
    }
}

project

对于 ant 来说,整个 build.xml 的顶层元素就是 project; gradle 也类似。

对整个 build.gradle.kts 来说, 整个文件都处在 project 的作用域中,
可以通过 this 访问 project 本身及其成员、方法, 不过一般都省略 this,
比如用 repositories {...}, 而不是 this.repositories {...} 。

project

如上面的例子,整个构建流程类似于下面的伪代码:

    interface Task {
        fun doLast();
        fun dependsOn();
        ...
    }
    class TaskContainer extends Set<Task> {
        fun register(name: String): Task
    }
    class Project {
        val tasks: TaskContainer

        fun build() {
            // Start: 将 build.gradle.kts 的内容在这里展开
+           tasks.register("hello") {
+               doLast {
+                   println("Hello world!")
+               }
+           }
+           tasks.register("intro") {
+               dependsOn("hello")
+               doLast {
+                   println("I'm Gradle")
+               }
+           }
            // End: 
        }
    }

    new Project().build()

Project 具体声明见: org.gradle.api.Project

除了 tasks 外,几乎构建脚本中所有调用的方法都绑定于 Project,
这些方法的作用是设置 Project 属性。
这类似于 Ant, Ant 也有很多针对 Project 的属性设置。

比如 defaultTasks 设置默认构建目标, repositories 设置项目 maven 源, dependencies 设置项目依赖的第三方包, group 设置项目包名。

tasks

tasks 是 Project 的成员。可以通过 tasks 访问,其底层是一个容器(Set<Task>),
不过提供了很多自定义方法做其他管理操作。

tasks 具体声明见: org.gradle.api.tasks.TaskContainer

基本操作

// 创建 task: 默认类型为 DefaultTask
tasks.register("myTask") {
    // 可以在里面做一些操作
    doLast {...}
}
// 也可以在后期引用,然后进行其他设置
tasks.named("myTask") {
    dependsOn(...)
}

// 创建指定类型的 Task
tasks.registor<Copy>("copyTask") {
    from(file("srcDir"))
    to(...)
}

创建 task 可以指定类型,如上面的 Copy ,
此时可以调用 Copy 的专有方法,如 from()。

第三方库

对于 kotlin-dsl, 构建脚本中可以使用任何 kotlin 代码,也可以使用kotlin 标准库。

但是构建脚本默认无法使用第三方库,如果需要第三方库,则要在 buildScripts 中引入.

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        "classpath"(group = "commons-codec", name = "commons-codec", version = "1.2")
    }
}

tasks.register("encode") {
    doLast {
        val encodedString = Base64().encode("hello world\n".toByteArray())
        println(String(encodedString))
    }
}

buildScripts.dependencies 表示构建脚本本身的第三方依赖,而不是用户项目的依赖。

plugins

gradle 脚本中默认作用域就是 Project, 所以构建脚本中可以随意调用 Project 的方法。但 Project 中的方法是有限的,可能满足不了业务需求。

gradle 插件可以扩充 Project 的方法,或者增加其他功能、task 等。

plugin 的使用:

plugins {
    id("org.jetbrains.kotlin.jvm") version "1.4.10"
}

plugins 和 dependencies 的声明方法差不多,

由于 maven 下载速度可能很慢,可以新建 settings.gradle.kts 设置 plugins 源。

pluginManagement {
    repositories {
        maven(url="https://maven.aliyun.com/repository/public/")
        maven(url="https://maven.aliyun.com/repository/gradle-plugin")
    }
}

下一步

task入门

完整文档: gradle 安装目录的 docs。

评论

暂无评论