BenBen

Gradle 基本语法结构

发表于 分类于
Gradle 基本语法结构 Closure：闭包，一个可以被传递的方法...

Gradle 基本语法结构

语法一

Closure：闭包，一个可以被传递的方法

1
2
3
4
5
6
7
void test(int i , Closure data) {
    println("test run!")
    data.run()// 触发 closure 函数
}
test 1, {
    println("test closure!")
}// 这里调用 test 函数省略了括号
语法二

methodMissing：默认方法，当调用不存在的方法时会触发该函数

1
2
3
4
5
6
7
class A{
	public Object methodMissing(String name, Object args) {
		// ... do something
	}
}
def a = new A()
a.gogo(1, 2, 3) // 当A类没有该函数时回触发a的 methodMissing 方法
buildTypes

构建类型

1
2
3
4
5
6
7
8
9
buildTypes {
    internal {	// 自建类型
        initWith debug // 继承至debug
    }
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}

可通过 BuildVariants 选项选取要编译的类型

也可通过配置对应文件夹进行代码配置，以执行不同的逻辑

productFlavors

多版本打包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
flavorDimensions 'paying','nation'	// 分组
productFlavors { // 构建版本
    free { // 免费
        dimension 'paying'	// 所属组
    }
    paid { // 付费
        dimension 'paying'
    }
    china { // 中国版
        dimension 'nation'
    }
    global { // 国际版
        dimension 'nation'
    }
}

可通过 BuildVariants 选项选取要编译的类型

此时构建类型会有以下组合：buildTypes数量 * productFlavors组1数量 * productFlavors组2数量

freeChinaDebug、freeChinaRelease、freeGlobalDebug ……

跟buildTypes一样，同样可以通过配置对应文件夹进行代码配置，以执行不同的逻辑，文件夹名称以构建类型自由组合，如：free、freeDebug、china、chinaDebug、freeChinaDebug等等

这样就可以非常精细的配置类型

task

groovy 任务，被 task 声明的函数内部都属于配置项

1
2
3
4
5
6
7
8
9
10
11
// 无论是执行 gradlew 还是执行 gradlew clean，都会打印 1、2 和 7
task clean(type: Delete) {
    println 1
    delete rootProject.buildDir // 这一行需要 gradlew clean 才回进行真正的delete，否则只是单纯的配置
    println 2
    doFirst {} // 需要 gradlew clean 才会执行
    doLast {} // 需要 gradlew clean 才会执行
}
task test() {
    println 7
}

先行任务doFirst：如果task有多个doFirst，第二个会插在第一个的前面，第三个插在第二个前面，以此类推

后续任务doLast：如果task有多个doLast，会在doFirst后面进行按顺序插入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 执行 gradlew clean，会以1、2、7 和 5、3、4、6的形式打印
task clean(type: Delete) {
    println 1
    delete rootProject.buildDir
    println 2

    doFirst {
        println 3
    }
    doLast {
        println 4
    }
    doFirst {
        println 5
    }
    doLast {
        println 6
    }
}
task test() {
    println 7
}
task依赖

通过 dependsOn: task 的方式来依赖另一个任务，会先执行依赖任务再执行自身任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 会先 打印 1、2 再打印 3、4
task task1() {
    doFirst {
        println 1
    }
    doLast {
        println 2
    }
}

task task2(dependsOn: task1) {
    doFirst {
        println 3
    }
    doLast {
        println 4
    }
}
Gradle生命周期

三个阶段：初始化阶段（setting.gradle） -> 定义阶段/配置阶段（build.gradle） -> 执行阶段