Android studio Gradle 入门

一.gradle 是什么？

Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化建构工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，抛弃了基于XML的各种繁琐配置，使的它更简洁，灵活而且gradle完全兼容maven和ivy。

二.gradle 在 AS 中的表现形式

AS 中的 Project 是一个工作空间，可以包含很多不同的 module，有些module是可以独立运行的，有些是公共库。 在AS 中project 会对应一个 build.gradle ，每个 modle

对应一个 build.gradle，这个 build.gradle 文件就是 gradle的配置文件。

这是一个android工程的project视图，上面那个是module下的build.gradle文件。下面那个是project下的build.gradle文件。这两个文件是有区别的，project下的build.gradle是基于整个project的配置，而module下的build.gradle是每个模块自己的配置。下面看下这两个build.gradle里面的内容：

project#build.gradle:

1. buildscript {
2.     //构建过程依赖的仓库
3.     repositories {
4.     jcenter()
5. }
6. //构建过程需要依赖的库
7. dependencies {
8.      //下面声明的是gradle插件的版本
9.      classpath 'com.android.tools.build:gradle:1.1.0'
10.      // NOTE: Do not place your application dependencies here; they belong
11.      // in the individual module build.gradle files
12. }
13. }
14. //这里面配置整个项目依赖的仓库,这样每个module就不用配置仓库了
15. allprojects {
16.      repositories {
17.           jcenter()
18.      }
19. }

注：大家可能很奇怪，为什么仓库repositories需要声明两次，这其实是由于它们作用不同，buildscript中的仓库是gradle脚本自身需要的资源，而allprojects下的仓库是项目所有模块需要的资源。所以大家千万不要配错了。

module#build.gradle:

1. //声明插件，这是一个android程序，如果是android库，应该是com.android.library
2. apply plugin: 'com.android.application'
3. android {
4.      //安卓构建过程需要配置的参数
5.      compileSdkVersion 21//编译版本
6.      buildToolsVersion "21.1.2"//buildtool版本
7.      defaultConfig {//默认配置，会同时应用到debug和release版本上
8.      applicationId "com.taobao.startupanim"//包名
9.      minSdkVersion 15
10.      targetSdkVersion 21
11.      versionCode 1
12.      versionName "1.0"
13. }
14.  buildTypes {
15.      //这里面可以配置debug和release版本的一些参数，比如混淆、签名配置等
16.      release {
17.          //release版本
18.          minifyEnabled false//是否开启混淆
19.          proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'//混淆文件位置
20.      }
21. }
22. }
23. dependencies {
24.      //模块依赖
25.      compile fileTree(dir: 'libs', include: ['*.jar'])//依赖libs目录下所有jar包
26.      compile 'com.android.support:appcompat-v7:21.0.3'//依赖appcompat库
27. }

defaultConfig中是一些基本配置，它会同时应用到debug/release版本上，下面列举了所有可配项及对应的值：

buildTypes结点很重要，这里可以配置构建的版本的一些参数，默认有两个构建版本release/debug，当然你可以自定义一个构建版本，比如叫foo,然后通过gradlew assembleFoo就可以生成对应的apk了。

buildTypes里还有很多可配置项，下面列举了所有可配项以及debug/release版本的默认值：

1.gradle.properties：

从名字上就知道它是一个配置文件，没错，这里面可以定义一些常量供build.gradle使用，比如可以配置签名相关信息如keystore位置，密码，keyalias等。

2.settings.gradle：

这个文件是用来配置多模块的，比如你的项目有两个模块module-a,module-b,那么你就需要在这个文件中进行配置，格式如下：

include ':module-a',':module-b'

3.gradle文件夹：

这里面有两个文件，gradle-wrapper.jar和gradle-wrapper.properties,它们就是gradle wrapper。gradle项目都会有，你可以通过命令gradle init来创建它们（前提是本地安装了gradle并且配置到了环境变量中）。

4.gradlew和gradlew.bat:

这分别是linux下的shell脚本和windows下的批处理文件，它们的作用是根据gradle-wrapper.properties文件中的distributionUrl下载对应的gradle版本。这样就可以保证在不同的环境下构建时都是使用的统一版本的gradle，即使该环境没有安装gradle也可以，因为gradle wrapper会自动下载对应的gradle版本。

gradlew的用法跟gradle一模一样，比如执行构建gradle build命令，你可以用gradlew build。gradlew即gradle wrapper的缩写。

2.gradle仓库：

gradle有三种仓库，maven仓库，ivy仓库以及flat本地仓库。声明方式如下：

1. maven{
2. url "..."
3. }
4. ivy{
5. url "..."
6. }
7. flatDir{
8. dirs 'xxx'
9. }

有一些仓库提供了别名，可直接使用：

1. repositories{
2. mavenCentral()
3. jcenter()
4. mavenLocal()
5. }

3.gradle任务：

gradle中有一个核心概念叫任务，跟maven中的插件目标类似。

gradle的android插件提供了四个顶级任务

1. assemble 构建项目输出
2. check 运行检测和测试任务
3. build 运行assemble和check
4. clean 清理输出任务

执行任务可以通过gradle/gradlew+任务名称的方式执，执行一个顶级任务会同时执行与其依赖的任务，比如你执行

gradlew assemble

它通常会执行:

1. gradlew assembleDebug
2. gradlew assembleRelease

这时会在你项目的build/outputs/apk或者build/outputs/aar目录生成输出文件

注：linux下执行构建任务需要首先更改gradlew脚本的权限，然后才能执行该脚本：

1. chmod +x gradlew
2. ./gradlew assemble

可以通过：

gradlew tasks

列出所有可用的任务。在Android Studio中可以打开右侧gradle视图查看所有任务。

四.常见问题

1.导入本地jar包：
跟eclipse不太一样，android studio导入本地jar除了将jar包放到模块的libs目录中以外，还得在该模块的build.gradle中进行配置，配置方式是在dependencies结点下进行如下声明：

compile files('libs/xxx.jar')

如果libs下有多个jar文件，可以这样声明：

compile fileTree(dir: 'libs', include: ['*.jar'])

2.导入maven库：

compile 'com.android.support:appcompat-v7:21.0.3'

可见，格式为

compile 'groupId:artifactId:version'

3.导入某个project：
你的app是多模块的，假设有两个模块app和module-A,并且app模块是依赖module-A的，这时候我们就需要在app模块的build.gradle中的dependencies结点下配置依赖：

compile project(':module-A')

并且你需要在settings.gradle中把module-A模块包含进来：

include ':module-A',':app'

此外，这种情况下module-A模块是作为库存在的，因而它的build.gradle中的插件声明通常应该是这样的：

apply plugin: 'com.android.library'

而且，作为library的模块module-A的build.gradle文件的defaultConfig中是不允许声明applicationId的，这点需要注意。

4.声明三方maven仓库：
可能你项目需要的一些库文件是在你们公司的私服上，这时候repositories中仅有jcenter就不行了，你还需要把私服地址配到里面来，注意，应该配到project的build.gradle中的allprojects结点下或者直接配到某个模块中如果仅有这个模块用到。
配置方式：

1. repositories{
2. maven{
3. url="http://mvnrepo.xxx.com"
4. }
5. }

5.依赖三方aar文件：

compile 'com.aaa.xxx:core:1.0.1@aar'

6.将库项目导出为aar：

首先你的项目必须是一个库项目，build.gradle中进行配置：

apply plugin : 'com.android.library'

然后你可以在命令行中进到项目目录，执行如下gradle任务：

gradlew assembleRelease//确保该目录下有gradlew文件

生成的aar在/build/output/aar文件夹中

7.引用本地aar：
首先将aar文件放到模块的libs目录下，然后在该模块的build.gradle中声明flat仓库：

1. repositories{
2. flatDir{
3. dirs 'libs'
4. }
5. }

最后在dependencies结点下依赖该aar模块：

1. dependencies{
2. compile (name:'xxx',ext:'aar')
3. }

8.排除依赖：
当出现依赖冲突的时候可以通过排除依赖解决，具体方式如下：

1. compile (group:'xxx',name:'xxx',version:'xxx'){
2. exclude group:'xxx',module:'xxx'//module对应的就是artifactId
3. }

9.多dex支持（打包65k方法数限制）
首先在build.gradle的buildConfig中增加如下配置：

multiDexEnabled true

接着，在dependencies结点下增加如下依赖：

1. dependencies{
2. compile 'com.android.support:multidex:1.0.0'
3. }

最后，让你的Application继承MultiDexApplication,如果你的应用没有声明Application，可以在manifest文件的application结点下增加name属性，值为android.support.multidex.MultiDexApplication。

详细内容参见官方文档。

10.自动移除不用资源

可以在buildTypes结点中增加如下配置：

1. buildTypes{
2. release{
3. minifyEnabled true
4. shrinkResources true
5. }
6. }

11.忽略lint错误：
可以在build.gradle文件中的android结点下增加如下配置：

1. android{
2. lintOptions{
3. abortOnError false
4. }
5. }

12.声明编译的java版本
可以在build.gradle文件中的android结点下增加如下配置：

1. compileOptions {
2. sourceCompatibility JavaVersion.VERSION_1_7
3. targetCompatibility JavaVersion.VERSION_1_7
4. }

13.应用签名配置
首先在module的build.gradle中增加这些字段：

1. storeFiles:keystore文件存储位置,通常是.jks文件
2. storePassword 密码
3. keyAlias keystore别名
4. keyPassword 密码

具体配置方式为：

首先在build.gradle的android结点下增加如下配置：

1. signingConfigs {
2. //debug版本的签名配置,通常不用配，因为有默认的debug签名
3. debug {
4. }
5. release {
6. storeFile file("key.jks")
7. storePassword "123456"
8. keyAlias "mykey"
9. keyPassword "123456"
10. }
11. }

注：debug的默认签名为:

signingConfig android.signingCongfigs.debug

位置为

${home}\.android\debug.keystore

然后在buildTypes结点下的对应版本中添加上面的配置：

1. buildTypes{
2. release{
3. signingConfig signingConfigs.release
4. }
5. }

当然，release不是固定的名称，你可以随便取，比如这样：

1. android {
2. signingConfigs {
3. debug {
4. storeFile file("debug.keystore")
5. }
6. myConfig {
7. storeFile file("other.keystore")
8. storePassword "android"
9. keyAlias "androiddebugkey"
10. keyPassword "android"
11. }
12. }
13. buildTypes {
14. foo {
15. debuggable true
16. jniDebuggable true
17. signingConfig signingConfigs.myConfig
18. }
19. }
20. }

真实开发中，把密码配置到build.gradle中不是很好的做法，最好的做法是放在gradle.properties中:

1. RELEASE_STOREFILE=xxx.jks
2. RELEASE_STORE_PASSWORD=123456
3. RELEASE_KEY_ALIAS=mykey
4. RELEASE_KEY_PASSWORD=123456

然后直接引用即可：

1. storeFile file(RELEASE_STOREFILE)
2. storePassword RELEASE_STORE_PASSWORD
3. keyAlias RELEASE_KEY_ALIAS
4. keyPassword RELEASE_KEY_PASSWORD

14.定制buildConfig：
在build.gradle中配置:

1. buildTypes{
2. release{
3. buildConfigField "string","type","\"release\""
4. }
5. debug{
6. buildConfigField "string","type","\"debug\""
7. }
8. }

这样就会在BuildConfig类中生成type字段：

1. //build/generate/source/buildConfig/release/包名/ 路径下的BuildConfig.java
2. public static final String type = "release"
3. //build/generate/source/buildConfig/debug/包名/ 路径下的BuildConfig.java
4. public static final String type = "debug"