作为 Android 开发者必须了解的 Gradle 知识（作为老师如何组织幼儿园游戏）

作为 Android 开发者必须了解的 Gradle 知识（作为老师如何组织幼儿园游戏）

在Android开发中，很多时候我们不需要修改 *.gradle 文件太多，我们添加依赖、修改target compile、最低支持API level，或者修改签名配置和build类型。其它更复杂一些逻辑，我们最后可能就是从Stack Overflow中copy了一些自己也不太懂的代码。本文中我们将一步一步介绍Android工程中用到的gradle文件及其背后的原理。

1. Groovy

1.1 语法

Gradle文件其实是用Groovy脚本写的，我们都会写java，所以入门Groovy非常简单。首先我们需要了解一下几点：

1.调用至少包含一个参数的方法时不需要使用括号：

def printAge(String name, int age) {

print("$name is $age years old")

}

def printEmptyLine() {

println()

}

def callClosure(Closure closure) {

closure()

}

printAge "John", 24 // Will print "John is 24 years old"

printEmptyLine() // Will, well, print empty line

callClosure { println("From closure") } // Will print "From closure"

2.如果方法的最后一个参数是闭包（或者说是lambda表达式），可以写在括号外(注：这个特性很重要，gradle文件中的很多配置其实都是参数为闭包的方法)：

def callWithParam(String param, Closure closure) {

closure(param)

}

callWithParam("param", { println it }) // Will print "param"

callWithParam("param") { println it } // Will print "param"

callWithParam "param", { println it } // Will print "param"

3.对于Groovy方法中命名过的参数，会被转移到一个map中做为方法的第一个参数，那些没有命名的参数则加在参数列表之后：

def printPersonInfo(Map person) {

println("${person.name} is ${person.age} years old")

}

def printJobInfo(Map job, String employeeName) {

println("$employeeName works as ${job.title} at ${job.company}")

}

printPersonInfo name: "John", age: 24

printJobInfo "John", title: "Android developer", company: "Tooploox"

这段程序会打印“John is 24 years old”和“John works as Android developer at Tooploox”，方法调用的参数可以是乱序的，map会被作为第一个参数传入！这里的方法调用也省略了括号。

1.2 闭包

闭包是一个非常重要的特性，需要解释一下。闭包可以理解为lambada。他们是一段可以被执行的代码，可以有参数列表和返回值。我们可以改变一个闭包的委托：

class WriterOne {

def printText(str) {

println "Printed in One: $str"

}

}

class WriterTwo {

def printText(str) {

println "Printed in Two: $str"

}

}

def printClosure = {

printText "I come from a closure"

}

printClosure.delegate = new WriterOne()

printClosure() // will print "Printed in One: I come from a closure

printClosure.delegate = new WriterTwo()

printClosure() // will print "Printed in Two: I come from a closure

我们可以看到 printClosure 调用了不同委托的 printText 方法，之后会解析这个特性在gradle中的重要性。

2. Gradle

2.1 脚本文件

有三个主要的gradle脚本，每个都是一个代码块。

build.gradle 文件，针对 Project 对象

settings.gradle文件，针对 Settings 对象

全局配置的初始化gradle脚本，针对 Gradle 实例

2.2 Projects

gradle 构建一般包含多个Project(在Android中每个module对应这里的project)，project中包含tasks。一般至少有一个root project，包含很多subprojects，subproject也可以嵌套project（注：Android 中对应每个library module还可以依赖其它library module）。

3. 构建基于Gradle的Android工程

Android工程中我们一般有如下的结构：

1是root project的setting文件，被 Settings 执行

2是root project的build配置

3是App project的属性文件，会被注入到 App的 Settings 中

4是App project的build配置

3.1 创建gradle工程

我们新建一个文件夹，命名为 example ， cd 进入后执行 gradle projects 命令，之后就已经拥有一个gradle project了：

$ gradle projects

:projects

------------------------------------------------------------

Root project

------------------------------------------------------------

Root project 'example'

No sub-projects

To see a list of the tasks of a project, run gradle :tasks

For example, try running gradle :tasks

BUILD SUCCESSFUL

Total time: 0.741 secs

3.2 配置projects层级

如果我们要建立一个默认的Android project（空的root project和一个包含Application的app project），我们就需要配置 settings.gradle ， the documentation 中介绍 settings.gradle ：

声明需要实例化的配置和build的project的层级体系配置

我们通过void include( String [] projectPaths)方法来添加projects：

这里的冒号 : 用于分隔子project，可以参考这里 here 。因此我们在这里写 :app ， 而不是直接写 app 。

在 settings.gradle 中写 rootProject.name = <> 也是一个比较好的实践。如果没有写，那么root project 的默认名字就是project所在文件夹的名字。

3.3 配置Android 子project

我们已经配置了root project的 build.gradle ，现在来看看如何配置Android project。

从 user guide 可以知道我们首先要为app project配置 com.android.application 插件，我们来看看 apply 方法：

void apply(Closure closure)

void apply(Map options)

void apply(Action super ObjectConfigurationAction> action)

尽管第三个方法很重要，我们通常使用是第二个方法，它用到我们之前提到的特性，通过map来传递参数。通过文档我们可以查看可以使用哪些参数：

void apply(Map( options)

以下是可用的参数：

from: 可以引入一个脚本apply(...)，如 apply from: "bintray.gradle" 从而导入一个可用脚本。

plugin: apply的plugin的id或者实现类

to: 委托目标

我们知道需要传递一个id值作为 plugin 的参数，可以写作： apply(plugin:'com.android.application') ，这里的括号也可以省略，我们在app的 build.gradle 中配置：

命令行中运行：

报错了，找不到 com.android.application 的定义，这不奇怪，我们并没有配置，但是gradle是如何查找Android的plugin jar包呢？在 user guide 可以找到答案，我们需要配置plugin的路径。

现在我们可以在root project或者app的 build.gradle 中配置路径，但是因为 buildscript 闭包是 ScriptHandler 执行的，其它子project也需要使用，因此最好配置在root project的 build.gradle 中：

buildscript {

repositories {

jcenter()

}

dependencies {

classpath 'com.android.tools.build:gradle:2.3.0-beta2'

}

}

如果我们在上边的代码中添加括号，那么就会发现其实都是带有闭包参数的方法调用。如果我们研究下 文档 ，我们就可以知道是有哪些对象执行这些闭包的，总结如下：

buildscript(Closure) 是 Project 实例中调用的，传递的闭包的由 ScriptHandler 执行

repositories(Closure) 是在 ScriptHandler 实例中调用，传递的闭包由 RepositoryHandler 执行

dependencies(Closure) 是在 ScriptHandler 实例中调用，传递的闭包由 DependencyHandler 执行。

也就是说 jcenter() 是由 RepositoryHandler 调用

classpath(String) 是由 DependencyHandler(*) 调用

译者注：如果这里看不懂的同学，可以再回头看看groovy的语法部分，其实这里上边的代码都是方法，如buildscript是Project的方法，我们知道groovy语法中如果最后一个参数是闭包的话，可以不写括号。

如果查看 DependencyHandler 的代码，我们会发现其实没有 classpath 这个方法，这是一种特殊的调用，我们在稍后讨论。

3.4 配置Android subproject

如果我们现在执行Gradle task，依然有错误：

显然，我们还没有设置Android相关的配置，但是我们的Android plugin已经可以被正确apply了，我们增加一些配置：

android {

buildToolsVersion "25.0.1"

compileSdkVersion 25

}

到这里我们知道，android方法被加入到了 Project 实例中，闭包传递给了delegate（这里是AppExtension），定义了 buildToolsVersion 和 compileSdkVersion 方法，Android plugin使用这种方式接收所有的配置，包括default configuration，flavors等等。

想要执行gradle task，还需要两个文件： AndroidManifest.xml 和 local.properties ， local.properties 中配置 sdk.dir ，（或者在系统环境中配置 ANDROID_HOME ）,指向Android SDK的位置。

3.5 扩展

android 方法是如何出现在 Project 实例中的呢，还有我们的build.gradle是怎样被执行的？简单的说，Android plugin 用android这个名字注册 AppExtension 类为 extension 。这个超出了本文的范围，但是我们要知道Gradle可以为每一个注册过的 plugin增加闭包配置。

3.6 依赖

还有一个重要的部分，dependencies还没有讨论：

dependencies {

compile 'io.reactivex.rxjava2:rxjava:2.0.4'

testCompile 'junit:junit:4.12'

annotationProcessor 'org.parceler:parceler:1.1.6'

}

为什么这里特殊呢，因为如果查看 DependencyHandler ，也就是执行这个闭包的委托，它是没有 compile , testCompile 等方法的。这个问题是有意义的，如果我们随意增加一个 freeCompile 'somelib' ，可以吗？ DependencyHandler 不会定义所有的方法，其实这里涉及到Groory语音的另一个特性： methodMissing ，这允许在运行时catch对于未定义方法的调用。

实际上Gradle使用了 MethodMixIn 中声明的 methodMissing ，类似的机制在为定义的属性中也是一样的。

相关的dependency操作可以在 这里 找到，它的行为如下：

如果未定义方法的调用方有至少一个参数，如果存在 configuration() 与被调用方法有相同的名字，那么就根据参数的类型和数量，调用具有相关参数的 doAdd 方法。

每个plugin都可以增进configuration到dependencies handler中，如Android插件增加了 compile, compileClasspath, testCompile 和一些其它配置 here ，Android 插件还增加了 annotationProcessor 配置，根据不同build类型和产品形式还有 Compile, TestCompile 等等。

由于 doAdd 是私有方法，一次这里调用的是公有的 add 方法，我们可以重写上边的代码，但最后不要这样做：

dependencies {

add('compile', 'io.reactivex.rxjava2:rxjava:2.0.4')

add('testCompile', 'junit:junit:4.12')

add('annotationProcessor', 'org.parceler:parceler:1.1.6')

}

3.7 Flavors, build types, signing configs

我们看以下代码：

productFlavors {

prod {

}

dev {

minSdkVersion 21

multiDexEnabled true

}

}

如果我们查看源码，可以发现productFlavors是这样声明的：

void productFlavors(Action super

NamedDomainObjectContainer> action) {

action.execute(productFlavors)

}

Action 是Gradle中定义的由 T 执行的闭包

所有这里我们有了 NamedDomainObjectContainer ， NamedDomainObjectContainer 可以创建和配置多个 ProductFlavorDsl 类型的对象，并根据 ProductFlavorDsl 的名字保存 ProductFlavorDsl 。

这个容器可以使用动态方法创建指定类型的对象（这里的ProductFlavorDsl），并和名字一起存放在容器中，所以当我们使用 {} 参数调用 prod 方法时，他被 productFlavors 实例执行，执行说明如下：

NamedDomainObjectContainer 获取到被调用方法的名字，生成 ProductFlavorDsl 对象，配置给定的闭包，保存方法名字到新的配置 ProductFlavorDsl 的映射。

Android plugin可以从 productFlavors 中获取 ProductFlavorDsl ，我们可以把它作为属性进行访问： productFlavors.dev ，这样我们就可以拿到名字为 dev 的 ProductFlavorDsl ，这也是我们可以写 signingConfig signingConfigs.debug 的原因。

4. 总结

对于Android开发者来说，Gradle文件是非常常用的，并不是什么黑魔法。但是Gradle有很多约定，而且使用Groovy语言也增加了一些复杂性，知道这两点，Gradle并不是什么魔法。希望了解通过这篇文章介绍的内容，即使是从stackoverflow中粘贴代码，也能知道它背后的意义。

来自：http://jianshu.com/p/c31513f5f550

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。