Android 中需要了解的 Gradle 语法

一、第三方依赖库统一管理

1.第一种方法，在根目录的 build.gradle 中添加 ext 变量

ext {
    string_key = "value"
    boolean_key = true
    int_key = 0
    list_key = [
            item_1: "string item",
            item_2: false,
            item_3: 1
    ]
}

然后在 app 模块的 build.gradle 中读取：

dependencies {
    ...
    println string_key
    println boolean_key
    println int_key
    println list_key.item_1
    println list_key.item_2
    println list_key.item_3
}

运行 gradle （在 Android Studio 中点击 sync 就可以了），输出如下：

value
true
0
string item
false
1

2.第二种方法：新建配置文件 config.gradle，然后在根目录的 build.gradle 中引用

新建配置文件 config.gradle，编辑如下：

ext {
    string_key = "value"
    boolean_key = true
    int_key = 0
    list_key = [
            item_1: "string_item",
            item_2: false,
            item_3: 1
    ]
}

在根目录的 build.gradle 中引用此文件：

buildscript {
    apply from: "config.gradle"
    ...
}

然后在 app 模块的 build.gradle 中读取：

dependencies {
    ...
    println string_key
    println boolean_key
    println int_key
    println list_key.item_1
    println list_key.item_2
    println list_key.item_3
}

运行 gradle，输出如下：

value
true
0
string item
false
1

PS：需要注意一点，如果 ext 中定义的变量名与 build.gradle 中的关键字重名，直接使用变量名称会导致编译出错，此时要使用 rootProject.ext.变量名 来引用 ext 中的变量。所以定义变量时最好不要和 build.gradle 中的关键字重名。

3.第三方依赖库统一配置

有了前面的基础知识，我们就可以在 ext 中定义几个变量，然后在各个模块的 build.gradle 文件中引用这些变量即可。比如：

ext {
    compileSdkVersionExt = 29
    defaultConfigExt = [
            applicationId   : "com.example.myapplication",
            minSdkVersion   : 15,
            targetSdkVersion: 29,
            versionCode     : 1,
            versionName     : "1.0"
    ]
    dependenciesExt = [
            kotlin          : 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.50',
            appCompat       : 'androidx.appcompat:appcompat:1.1.0',
            coreKtx         : 'androidx.core:core-ktx:1.1.0',
            constraintLayout: 'androidx.constraintlayout:constraintlayout:1.1.3'
    ]
}

在 app 模块的 build.gradle 中，引用这些变量：

...

android {
    compileSdkVersion compileSdkVersionExt

    defaultConfig {
        applicationId defaultConfigExt.applicationId
        minSdkVersion defaultConfigExt.minSdkVersion
        targetSdkVersion defaultConfigExt.targetSdkVersion
        versionCode defaultConfigExt.versionCode
        versionName defaultConfigExt.versionName
    }
}

dependencies {
    implementation dependenciesExt.kotlin
    implementation dependenciesExt.appCompat
    implementation dependenciesExt.coreKtx
    implementation dependenciesExt.constraintLayout
}

这里我们还可以用循环遍历的方式来引用 ext 中的列表变量：

dependencies {
    dependenciesExt.each {
        implementation it.value
    }
}

或者，我们可以不使用键值对列表，直接使用字符串列表。也就是直接在 ext 中这样定义：

ext {
    ...
    dependenciesExt = [
            'org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.50',
            'androidx.appcompat:appcompat:1.1.0',
            'androidx.core:core-ktx:1.1.0',
            'androidx.constraintlayout:constraintlayout:1.1.3'
    ]
}

引用时就可以直接这样：

dependencies {
    dependenciesExt.each {
        implementation it
    }
}

如果要在 ext 的字符串中引用变量，引用的地方需要使用双引号 ""，如：

ext {
    kotlinVersion = '1.3.50'
    ...
    dependenciesExt = [
            "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlinVersion",
            ...
    ]
}

二、Gradle 读取 properties 文件

1.新建一个属性文件 version.properties

编辑如下：

STRING_KEY = value
INT_KEY = 1
BOOLEAN_KEY = true

2.在 module 中的 build.gradle 文件中，读取这个 version.properties 文件

def versionPropFile = file('../version.properties')
Properties versionProp = new Properties()
versionProp.load(new FileInputStream(versionPropFile))

3.获取自定义的键值对

int intValue = versionProp['INT_KEY'].toInteger()
String stringValue = versionProp['STRING_KEY'].toString()
boolean booleanValue = versionProp['BOOLEAN_KEY'].toBoolean()

System.out.println(intValue + "," + stringValue + "," + booleanValue)

运行 gradle，程序输出如下：

1,value,true

三、多渠道打包配置

1.获取 app 各个渠道打包信息

applicationVariants.all { variant ->
    variant.outputs.each { output ->
        System.out.println("variant:\nbaseName = ${variant.baseName}"
                + "\nversionName = ${variant.versionName}"
                + "\nbuildType.name = ${variant.buildType.name}\n")
        System.out.println("output:\nname = ${output.name}"
                + "\nversionNameOverride = ${output.versionNameOverride}"
                + "\nversionCodeOverride = ${output.versionCodeOverride}"
                + "\noutputFileName = ${output.outputFileName}")
    }
}

运行 gradle，输出如下：

variant:
baseName = debug
versionName = 1.0
buildType.name = debug

output:
name = debug
versionNameOverride = 1.0
versionCodeOverride = 1
outputFileName = app-debug.apk

2.修改输出文件的 versionName 或者 输出文件的名字

为 output 重新赋值即可。如：

applicationVariants.all { variant ->
    variant.outputs.each { output ->
        output.versionNameOverride = variant.versionName + "." + variant.buildType.name
        output.outputFileName = "MyApp_${variant.buildType.name}_${variant.versionName}.apk"
    }
}

这样修改以后，build 出来的 apk 就会是我们自定义的名字了。

四、配置签名

android {
    ...
    signingConfigs {
        // 这个 key 只是一个名字，可以随意命名，只要保证 buildType 中配置的签名名字和这里一致即可
        key {
            // keyStore 文件路径
            storeFile file('D:\\keyStoreName.jks')
            // keyStore 密码
            storePassword 'keyStorePassword'
            // key 别名
            keyAlias = 'keyAlias'
            // key 密码
            keyPassword 'keyPassword'
        }
    }
    buildTypes {
        release {
            ...
            // 这里的 key 就是 signingConfigs 中的名字
            signingConfig signingConfigs.key
        }
    }
}

五、注入字符串、BuildConfig 变量

1.在 module 的 build.gradle 文件夹中注入

android {
    defaultConfig {
        ...
        resValue "string", "my_string", "MyApp"
        resValue "bool", "my_bool", "true"
        resValue "integer", "my_integer", "1"
        buildConfigField "String", "my_string", '"MyApp"'
        buildConfigField "boolean", "my_bool", "true"
        buildConfigField "int", "my_integer", "1"
    }
    ...
}

resValue 的效果等同于在 values 文件夹下的 xml 文件中，添加了资源

<string name="my_string">MyApp</string>
<integer name="my_integer">1</integer>
<bool name="my_bool">true</bool>

buildConfigField 配置之后，会在 BuildConfig 中添加以下变量：

public final class BuildConfig {
  ...
  public static final boolean my_bool = true;
  public static final int my_integer = 1;
  public static final String my_string = "MyApp";
}

2.代码中获取注入的值

val string = getString(R.string.my_string)
val bool = resources.getBoolean(R.bool.my_bool)
val integer = resources.getInteger(R.integer.my_integer)
Log.d("~~~", "$string,$bool,$integer,${BuildConfig.my_string},${BuildConfig.my_bool},${BuildConfig.my_integer}")

运行程序，Log 控制台输出如下：

~~~: MyApp,true,1,MyApp,true,1

需要注意的是，注入的值不能和已有的值冲突，否则编译会出错。

3.多渠道打包时注入不同的值

在 build.gradle 的 defaultConfig 中注入的值会在所有的渠道中生效，如果需要在不同的渠道中注入不同的字符串，将代码写到 buildTypes 的不同渠道中即可。如：

buildTypes {
    debug {
        resValue "string", "build_type", "debug"
    }
    release {
        resValue "string", "build_type", "release"
    }
}

以上，就是 Android 开发中需要了解的一些 Gradle 语法。