【andorid】gradle相关知识点总结

2019年6月9日 167次阅读 来源: 当时不是寻常

0、看一下基本配置的意思

// Top-level build file where you can add configuration options common to all sub-projects/modules.
 
buildscript {
    //构建过程依赖的仓库
    repositories {
    jcenter()
}
//构建过程需要依赖的库
dependencies {
     //下面声明的是gradle插件的版本
     classpath 'com.android.tools.build:gradle:1.1.0'
     // NOTE: Do not place your application dependencies here; they belong
     // in the individual module build.gradle files
}
}
//这里面配置整个项目依赖的仓库,这样每个module就不用配置仓库了
allprojects {
     repositories {
          jcenter()
     }
}

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

//声明插件，这是一个android程序，如果是android库，应该是com.android.library
apply plugin: 'com.android.application'
android {
     //安卓构建过程需要配置的参数
     compileSdkVersion 21//编译版本
     buildToolsVersion "21.1.2"//buildtool版本

     defaultConfig {//默认配置，会同时应用到debug和release版本上
     applicationId "com.taobao.startupanim"//包名
     minSdkVersion 15
     targetSdkVersion 21
     versionCode 1
     versionName "1.0"
 }
 buildTypes {
     //这里面可以配置debug和release版本的一些参数，比如混淆、签名配置等
     release {
         //release版本
         minifyEnabled false//是否开启混淆
         proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'//混淆文件位置
     }
 }
}
dependencies {
     //模块依赖
     compile fileTree(dir: 'libs', include: ['*.jar'])//依赖libs目录下所有jar包
     compile 'com.android.support:appcompat-v7:21.0.3'//依赖appcompat库
}

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

1、IDE创建好，要了解默认的Android工程有哪些task，可以运行一下指令：

gradle task [--all]

2、常用配置

apply plugin: 'com.android.application'
android {
    compileSdkVersion 23 // 编译sdk版本
    buildToolsVersion "23.0.2" // 构建工具版本

    defaultConfig {
        applicationId "com.yuqirong.koku" // 应用包名
        minSdkVersion 15 // 最低适用sdk版本
        targetSdkVersion 23 // 目标sdk版本
        versionCode 1 // 版本号
        versionName "1.0" // 版本名称
    }
    buildTypes {
        release {
            minifyEnabled true // 开启混淆
            zipAlignEnabled true // 对齐zip
            shrinkResources false // 删除无用资源
            debuggable false // 是否debug
            versionNameSuffix "_release" // 版本命名后缀
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' // 混淆文件
        }

        debug {
            zipAlignEnabled false
            shrinkResources false
            minifyEnabled false
            versionNameSuffix "_debug"
            signingConfig signingConfigs.debug
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.2.1'
    compile 'com.android.support:design:23.2.1'
}

3、签名配置

signingConfigs {
    
    release { // 正式版本的签名
        storeFile file("../koku.jks") // 密钥文件位置
        storePassword "xxxxxxxxx" // 密钥密码
        keyAlias "koku" // 密钥别名
        keyPassword "xxxxxxxxx" // 别名密码
    }
    
    debug { // debug版本的签名
        // no keystore
    }
}

使用时只要在 buildTypes 的 release 中加一句 signingConfig signingConfigs.release 就好了。

如果你觉得把密钥密码和别名密码放在 app/build.gradle 里不安全，那么可以把相关密码放到不加入版本控制系统的 gradle.properties 文件：

KEYSTORE_PASSWORD=xxxxxxxxxx
KEY_PASSWORD=xxxxxxxxx

对应的 signingConfigs 配置：

signingConfigs {
    release {
        try {
            storeFile file("../koku.jks")
            storePassword KEYSTORE_PASSWORD
            keyAlias "koku"
            keyPassword KEY_PASSWORD
        }catch (ex) {
            throw new InvalidUserDataException("You should define KEYSTORE_PASSWORD and KEY_PASSWORD in gradle.properties.")
        }
    }
}

4、Java 编译版本配置：

compileOptions { // java 版本
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

这里需要注意下，如果 Java 编译版本为1.8的话，另外在 defaultConfig 里要配置 Jack 编译器：

jackOptions {
    enabled true
}

5、Lint 检查配置：

lintOptions {
    abortOnError false // 是否忽略lint报错
}

6、多渠道信息配置：

productFlavors {
    xiaomi {}
    googleplay {}
    wandoujia {}
}

7、如何自定义配置文件。为了方便管理，可以在根目录下新建 config.gradle 文件

root
  --module1
    --build.gradle
  --module2
    --build.gradle
  ...
  --build.gradle
  --config.gradle

在 config.gradle 中添加如下代码（具体情况根据自己项目来定）：

ext {
    android = [
            compileSdkVersion: 23,
            buildToolsVersion: "24.0.0 rc1",
            applicationId    : "com.sivan.rxretrofitdemo",
            minSdkVersion    : 16,
            targetSdkVersion : 23,
            versionCode      : 1,
            versionName      : "1.0"
    ]

    dependencies = [
            "appcompat-v7"       : "com.android.support:appcompat-v7:23.3.0",
            "rxjava"             : "io.reactivex:rxjava:1.1.3",
            "rxandroid"          : "io.reactivex:rxandroid:1.1.0",
            "retrofit"           : "com.squareup.retrofit2:retrofit:2.0.0-beta4",
            "gson"               : "com.google.code.gson:gson:2.6.2",
            "converter-gson"     : "com.squareup.retrofit2:converter-gson:2.0.0-beta4",
            "adapter-rxjava"     : "com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4",
            "butterknife"        : "com.jakewharton:butterknife:7.0.1",
            "logging-interceptor": "com.squareup.okhttp3:logging-interceptor:3.0.1"
    ]
}

在 root 目录下的build.gradle 中加上apply from: “config.gradle”

《【andorid】gradle相关知识点总结》 image.png

  • android 节点的使用
android {
    compileSdkVersion rootProject.ext.android.compileSdkVersion
    buildToolsVersion rootProject.ext.android.buildToolsVersion

    defaultConfig {
        applicationId rootProject.ext.android.applicationId
        minSdkVersion rootProject.ext.android.minSdkVersion
        targetSdkVersion rootProject.ext.android.targetSdkVersion
        versionCode rootProject.ext.android.versionCode
        versionName rootProject.ext.android.versionName
    }

}
  • dependencies 节点的使用
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile rootProject.ext.dependencies["appcompat-v7"]
    compile rootProject.ext.dependencies["rxjava"]
    compile rootProject.ext.dependencies["rxandroid"]
    compile rootProject.ext.dependencies["gson"]
    compile rootProject.ext.dependencies["converter-gson"]
    compile rootProject.ext.dependencies["adapter-rxjava"]
    compile rootProject.ext.dependencies["retrofit"]
    compile rootProject.ext.dependencies["butterknife"]
}

以后再对依赖包升级的时候直接修改 config.gradle 文件就 OK 了

8、如果是gradle.properties文件就直接使用

对依赖进行统一管理的另一种方法是使用配置文件 gradle.properties（通常 IDE 会自动生成此文件），在此文件中添加键值对：

LOGGING_INTERCEPTOR=com.squareup.okhttp3:logging-interceptor:3.0.1
CARD_VIEW=com.android.support:cardview-v7:23.3.0

在 Module 的 build.gradle 中使用：

dependencies {
    compile LOGGING_INTERCEPTOR
    compile CARD_VIEW
}

9、根目录下的 gradle 文件夹

gradle 文件夹中主要是 gradle-wrapper.properties 文件比较重要，主要用来声明 Gradle 目录以及 Gradle 下载路径等：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip

10、根目录下的 build.gradle

根目录下的 build.gradle 主要作用就是定义项目中公共属性，比如有依赖仓库、 Gradle 构建版本等：

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.1'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        jcenter()
        mavenCentral()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}
setting.gradle

11、setting.gradle 的作用就是一些模块被包含后，会在这里进行申明：

include ‘:app’

12、gradle和gradlew区别

Gradlew是包装器，是为了解决不同项目gradle版本不同而推出的，它自动下载包装里定义好的gradle 版本，保证编译环境统一，gradle 是用本地的gradle。

  • gradlew build 和 gradle build 有区别吗?
    使用gradle wrapper是gradle官方推荐的build方式，而gradlew正是运行了wrapper task之后生成的（运行wrapper task是Android Studio自动做的）。使用gralde wrapper的一个好处就是每个项目可以依赖不同版本的gradle，构建的时候gradle wrapper会帮你自动下载所依赖的版本的gradle。而如果你使用gradle build的话，同时你又有多个项目使用不同版本的gradle，那就需要你手动在自己的机器上配置多个版本的gradle，稍微麻烦一些

  • 避免每次工程都下载gradle可以使用gradle命令打包而不是gradlew
    方法：配置gradle到环境变量；工程中使用自己配置变量的gradle即可。
    先找到gralde的根目录，在系统变量里添加两个环境变量：

变量名为：GRADLE_HOME，变量值就为gradle的根目录；

比如变量值为：
D:androidandroid-studio-ide-143.2739321-windowsandroid-studiogradlegradle-2.10

还有一个在系统变量里PATH里面添加gradle的bin目录

比如：
D:androidandroid-studio-ide-143.2739321-windowsandroid-studiogradlegradle-2.10\bin

这样就配置完了，执行以下这个命令：gradle assembleRelease，看看是不是可以了。

13、设置GRADLE_USER_HOME的几种方法
Android Studio的gradle在缓存处理上有时候会莫名其妙的出问题，必要时需要手动删除缓存，然后重新编译。有时也有出于其他考虑指定gradle缓存路径。

在gradle的安装目录，编辑bin文件夹下的gradle文件，然后找到如下语句:

# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script

在这句话的下面加上如下这一句:

GRADLE_OPTS=-Dgradle.user.home=/yourpath/gradle/gradle_cache

即设置GRADLE_OPTS这个变量即可.这种修改方法尤其适合需要用gradle脚本就行编译的环境中，本文就采用这种方法。

  • 方法1

通过修改AndroidStudio的设置项，找到gradle相关的设置:

《【andorid】gradle相关知识点总结》 image

直接修改Service directory path即可。这种方法适合只使用AndroidStudio进行编译的环境。

  • 方法2，修改gradle.properties文件

在其中增加一句:

gradle.user.home=D:/Cache/.gradle

缺点:每个项目都要这么加一次.

  • 方法3，设置GRADLE_USER_HOME环境变量

在/etc/profile或~/.bash_profile增加如下:

export GRADLE_USER_HOME=D:/Cache/.gradle

  • 方法4，通过gradle自带参数

gradle -g D:/Cache/.gradle build build

可以通过gradle --help查看各参数的含义。

总结

个人推荐修改bin/gradle文件的方法 或 方法3.

14、gradle-wrapper.properties中各属性的含义

1. gradle-wrapper.properties

每一个用gradle编译的工程，都会有一个gradle\wrapper目录。该目录下有2个文件：gradle-wrapper.jar和gradle-wrapper.properties。

其中gradle-wrapper.properties的内容如下：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-3.1-bin.zip

注：目前最新的是3.3版。

1.1 distributionUrl

distributionUrl是要下载的gradle的地址，使用哪个版本的gradle，就在这里修改。

gradle的3种版本：

  1. gradle-xx-all.zip是完整版，包含了各种二进制文件，源代码文件，和离线的文档。例如，https://services.gradle.org/distributions/gradle-3.1-all.zip

  2. gradle-xx-bin.zip是二进制版，只包含了二进制文件（可执行文件），没有文档和源代码。例如，https://services.gradle.org/distributions/gradle-3.1-bin.zip

  3. gradle-xx-src.zip是源码版，只包含了Gradle源代码，不能用来编译你的工程。例如，https://services.gradle.org/distributions/gradle-3.1-src.zip

如果只是为了编译，可以不用完整版，只需要二进制版即可，例如，gradle-3.1-bin.zip。

1.2 其他4个属性

zipStoreBase和zipStorePath组合在一起，是下载的gradle-3.1-bin.zip所存放的位置。
zipStorePath是zipStoreBase指定的目录下的子目录。

distributionBase和distributionPath组合在一起，是解压gradle-3.1-bin.zip之后的文件的存放位置。
distributionPath是distributionBase指定的目录下的子目录。

下载位置可以和解压位置不一样。

zipStoreBase和distributionBase有两种取值：GRADLE_USER_HOME和PROJECT。

其中，GRADLE_USER_HOME表示用户目录。
在windows下是%USERPROFILE%/.gradle，例如C:\Users\<user_name>\.gradle\。
在Linux下是$HOME/.gradle，例如~/.gradle。

PROJECT表示工程的当前目录，即gradlew所在的目录。

15、app/build.gradle 配置文件

一般来说，新建的一个项目，在 app 目录会生成一个 build.gradle 文件，app 目录基本是项目的一个主要目录了，所有的功能开发都是在这个目录下，自然该目录下的 build.gradle 也是整个项目最重要的配置文件，这个文件对全新的项目来说会包含三部分

最顶部的 apply plugin 声明
android {} 节点
dependencies {} 节点
apply plugin 声明

最顶部有一行代码是这样的：

apply plugin: 'com.android.application'

代表该项目是一个 Android 项目，而且一个 Android 项目只有一句这个声明，别问为什么这样写，这是规范。

如果你的项目有引用一些 module ，你可以理解成通过源码的方式引用一些 android library ，那么你的 module 开头需要声明是一个 android library ，那需要这样写：

apply plugin: 'com.android.library'

是不是很容易理解？

16、 BuildType

  • 1.1默认buildType
buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

// release版本中设置了开启混淆，并且定义了混淆文件的位置

默认情况下还有一个debug版本，我们也可以添加对debug版本的一些设置

buildTypes {
    debug {
        minifyEnabled false
    }
}

// debug版本中关闭混淆
  • 1.2自定义buildType

除了默认的构建版本，还可以创建自己的构建版本

buildTypes {
    custom.initWith(buildTypes.debug)
    custom {
        applicationIdSuffix  ".custom"
        versionNameSuffix  "-custom"    }}
// custom使用initWith方法复制debug版本并创建了一个新的构建版本，相当于继承了debug版本
// custom版本中添加applicationId后缀，添加versionName后缀

其他属性的设置可以查看buildType的文档。

17、定义变量

Groovy作为一门动态语言，所以肯定是支持动态类型。那么在定义变量的时候是可以不指定变量类型的。

使用def关键字来定义变量，但是def关键字也是可以省略的。例如：

def a = 1           //使用def关键字定义变量a
a = 1               //省略def同样可以
def int a = 1       //指定变量类型
int a = 1       //省略def关键字，并指定变量类型

但是这并没有突出动态语言的特性，既然是动态语言，那么变量a可以是任意类型的，比如：

def a = 1       //声明的时候是一个int类型
a = 'hello groovy'      //然后赋值一个String
assert a instanceof String      //断言测试是没有问题的

但是如果在定义变量的时候指定了变量类型，那么这个变量就不在是动态变量，例如：

def int a = 1       //声明变量的时候指定变量a是一个int型
a = 'hello groovy'      //将一个String赋值给a的时候会报错

18、String

Groovy里面的String比较的变态，因为他的表达方式太多，下面一一列举一下String几种形式：

def v = '支持占位符'

def a = '单引号形式'
def b = "双引号形式，${v}"
def c = '''三个单引号形式
支持多行
不支持占位符'''
def d = """三个双引号形式
支持多行
支持占位符，${v}"""
def e = /反斜杠形式
支持多行
支持占位符，${v}/
def f = $/美刀反斜杠形式
支持多行
支持占位符，${v}/$

String的形式虽然很多，但是还是建议你只使用’和”这两种形式，以防别人看不懂你写的代码，并不是大家都有同样的Groovy语法基础，如果你一定要用的话，也请你注释清楚这是什么意思。

19、List

Groovy中的List使用的是java.util.List，默认使用ArrayList，如果你想要使用LinkedList需要特别指明；List是动态的，里面可以同时放不同类型的数据。

//动态类型，可以同时存放任意类型的值
def list = [0, "list", 1.2, false]      

//指定LinkedList的两种方式
LinkedList linkedList = [1, 2, 3]
def linkedList2 = [1, 2, 3] as java.util.LinkedList

//根据下标获得list数据的方式
assert list.get(2) == 1.2
assert list[2] == 1.2

20.Array数组

在Groovy中，使用Array数组和使用List最大的区别就是，Array数组必须指定类型。

//声明数组的两种方式，必须指定类型
def String[] arrStr = ["a", "b", "c"]
def arrNum = [1, 2, 3] as int[]
//创建一个有界限范围的空数组
def String[] arrStr2 = new String[2]

//二维数组
def int[][] matrix2 = [[1, 2], [3, 4]]

21.Map

Groovy中的Map使用非常的简单。

//定义一个map
def person = [name: '阿，希爸', age: 30, sex: 'male']
//获取对应的key值
assert person['name'] == '阿，希爸'
assert person.age == 30
assert person.get('sex') == 'male'

//修改key对应的值
person.age == 31
//添加新的键值对
person.country =  '中国'
person.put('province', '安徽')

//空map
def emptyMap = [:]

================================================

22.Gradle Warpper

为什么我在Github下了一个项目导入要这么久？

Gradle到底在干点啥浪费了我这么多青春？

一般这种情况的罪魁祸首是Gradle Wapper，他的主要作用是来适配不同的Gradle版本的。

比如你在github上面下了一个项目，项目的目录结构大概是这样的：

.
├── app
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
└── settings.gradle

其中gradlew文件是Linux和MacOS环境下运行的，gradlew.bat是window环境下运行的。而定义项目的执行版本在/gradle/wrapper/gradle-wrapper.properties文件中，内容如下：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip

这文件是说我这个项目需要你用2.10版本的gradle来编译。

如果你当前AndroidStudio所使用的Gradle版本与文件中指定的不一致，Gradle会去下载对应的版本，下载好了用这个版本去编译。

一个Gradle的压缩文件大概50M以上，如果你的网络环境差一点，是比较痛苦的。

解决这个问题的方法有两个，一个是让gradle-wrapper.properties中的Gradle版本与当前AndroidStudio所使用的Gradle版本一致，一个是自己下载好所需要的版本。但是两个方法都会有一些问题，我们来一个一个分析。

使用同一个版本的Gradle

首先查看你当前AndroidStudio所使用的Gradle是什么版本，然后将gradle-wrapper.properties中的Gradle改成同一个版本。

查看AndroidStudio中Gradle版本的方法如下图：

《【andorid】gradle相关知识点总结》 image.png

这里建议将Gradle home配置成本地环境。也就是说自己下载一个Gradle然后配置到系统环境中，这样在终端就可以使用了。

上图中所使用的Gradle版本是2.14.1。而刚才我们列出来的gradle-wrapper.properties中的Gradle版本是2.10。

gradle-wrapper.properties中的Gradle版本是2.14.1就可以避免去下载2.10版本。但是这样做有风险，如果新的版本对旧版本的一些语法不在支持了，那么就会编译错误，结果会得不偿失，除非你对版本变更了解的非常透彻，能够手动将文件变动的地方重新修改，那么用这种方法没有问题。但是如果你不了解，建议不要采用这种方法。

接着介绍第二种。

手动下载Gradle版本

既然对Gradle的版本变更不熟悉，我们就按照gradle-wrapper.properties文件中的配置内容，使用下载工具去下载，来避免他下载过慢的问题，而且如果我们积累了比较常用的版本，也就不用每次都去下载了。

gradle-wrapper.properties中基本都给出来了下载链接，https://services.gradle.org/distributions/可以查看所有版本。

如果你的网络访问这个页面或者使用下载工具还是下载很慢的话，可以到androiddevtools上面去下载相关的安装包。

但是这种做法也有一个问题，那就是他的下载机制。还是用刚才的栗子。

目前我的AndroidStudio使用的Gradle是2.14.1。

我的gradle-wrapper.properties中的Gradle版本是2.10。

那么执行编译，Gradle会先到gradle-wrapper.properties配置的目标路径下去找这个文件是否存在，其中的GRADLE_USER_HOME一般是对应下图中的Service directory path

《【andorid】gradle相关知识点总结》 image.png

那么连起来就是/Users/username/.gradle/wrapper/dists这个目录，为了后面引用我们给这个路径起名叫做wrapperPath。

如果路径下不存在这个版本的目录，那么Gradle会去创建相关文件目录，并开始下载对应版本的压缩包。内容如下图。

《【andorid】gradle相关知识点总结》 image.png

如果你现在嫌他下载太慢，删除gradle-2.10-all目录，然后将自己下载的压缩文件解压出来以为就万事大吉了，那就太天真了，当年我就是这么天真的。

我们先来看他下载好了是什么样的。

《【andorid】gradle相关知识点总结》 image.png

我们可以看到多了一个gradle-2.10-all.zip.part变成了gradle-2.10-all.zip.ok。同时多了文件压缩包和解压出来的对应文件目录。并且在一个目录名为看似一串随机码的目录下。

解释一下，Gradle会在 /wrapperPath/gradle-2.10-all/随机码/ 目录下去检查是否有一个gradle-2.10-all.zip.ok文件，如果有就直接编译，即使你将gradle-2.10这个目录删除了，他的编译会报错，但是他还是不会去下载。

如果没有这个文件，那么Gradle就会开始去下载gradle-2.10-all.zip文件，gradle-2.10-all.zip.part文件就是正在下载的gradle-2.10-all.zip文件，下载完成自动解压，在执行编译。

其中的随机码目录根据官方的介绍应该是由SHA-256 hash生成的，只是我的猜想。

如果我们想要骗过他就让他先执行下载，生成相关的文件目录，然后将你下载好的压缩包解压后放进去，在创建一个gradle-2.10-all.zip.ok文件，就可以了。

《【andorid】gradle相关知识点总结》 image.png

我将1.7以后的版本都手动配置好了。

以上，相信你能够填上Gradle Wrapper给你挖的坑了。

23.加速编译过程

  • 3.1 Gradle Daemon

Gradle Daemon是一个长期在后台执行的一个进程，用来避免每次开始编译在JVM启动Gradle所消耗的时间，同时也会在内存中保存一些你的项目数据来加速编译过程。Gradle3.0默认是开启Daemon的。

想要开启Daemon功能可以在.gradle/gradle.properties文件中添加org.gradle.daemon = true。

  • 3.2 Gradle Parallel

Gradle Parallel一般是对多个项目使用并行编译，他会在配置阶段对项目进行预编译，分析项目之间的依赖关系，而且已经编译过的项目，如果没有更改，直接用上次编译好的去构建目标项目，例如我们Android开发时在libraries里面的项目，只要编译一次就可以了，不会每次都去编译。

可以通过在项目根目录下的gradle.properties中添加org.gradle.parallel=true来开启此功能。

  • 3.3 Configuration on demand

Configuration on demand简单的说就是能够缩短multi-projects的配置时间。

可以通过在项目根目录下的gradle.properties中添加org.gradle.configureondemand=true来开启此功能。

  • 3.4 增加jvm进程的最大堆内存

通过修改项目根目录下的gradle.properties中的org.gradle.jvmargs属性来设置。根据你的配置可以改成org.gradle.jvmargs=-Xmx2048m 或者 org.gradle.jvmargs=-Xmx3072m

  • 3.5 使用固定版本的依赖项

如果你在依赖项中使用了动态版本配置，那么编译的时候会去检查是否有更新的版本，如果有就会下载新版本的依赖项。所以尽量使用固定版本的依赖，减少 + 号的使用。

24、dependencies 节点

我们先来看下 dependencies 节点，dependencies 是 denpendency 的复数，意为依赖的意思，所以这里就是用来管理依赖的地方。这里以我的开源项目 9GAG 为例，依赖一般有三种：

《【andorid】gradle相关知识点总结》 image.png

我们知道我们可以在 AS 中直接依赖 jar 文件，靠的就是这行代码 compile fileTree(dir: ‘libs’, include: [‘*.jar’]) ，意思是编译 libs 目录下的所有 jar 包，当然你可以更改这个目录。

第二种就比较常见了，现在大家都已经很熟悉了，就是直接依赖远程项目名字 + 版本号，至于该项目是放在哪里的呢？一般是放在 jcenter 和 maven 仓库的，这个可以在项目根目录下的 build.gradle 指定远程仓库地址，甚至可以在本地搭建一个私有仓库，然后指定本地仓库地址。

如果文章当中有任何不正确的地方，还请广大读者纠正，非常感谢！

    原文作者：当时不是寻常
    原文地址: https://www.jianshu.com/p/696d8cacd836
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞