[移动开发]Android 根目录下和应用目录下的build.gradle的详解，以及groovy语法的讲解

前言：

Gradle的作用:

1. 打apk包
2. 打插件包
3. 自动化构建
4. 多渠道打包
5. 自动化签名
6. 后台java打包
7. 生成文件
8. 使用的是groovy语法，shell脚本，能够完成数据处理，文件操作
9. groovy和java是一家，JDK支持两种语言java和groovy，在groovy中直接调用java包
10. groovy和java进行了一个动态的补充，groovy是一个动态的语言，java是一个静态的编程语言，java处理不了的工作，可以用groovy来做

Gradle的特性

一、根目录下的build.gradle，注解给出了解释说明

// Top-level build file where you can add configuration options common to all sub-projects/modules.
//根目录的构建脚本
buildscript {
    //指定了仓库
    repositories {
        google()
        jcenter()
    }
    dependencies {
        //gradle 插件版本
        classpath "com.android.tools.build:gradle:4.1.3"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

//所有的仓库依赖地址
allprojects {
    //项目本身需要的依赖，配置所有的Module公共依赖
    repositories {
        google()
        jcenter()
    }

}
//任务,清除所有build文件 执行Build -> Clean Project 触发这个指令
task clean(type: Delete) {
    delete rootProject.buildDir
}

二、应用目录下的build.gradle，以及groovy语法的使用

plugins {
    //表示这是一个应用程序模块，com.android.library表示这是一个库模块
    id 'com.android.application'
}
apply from: 'config.gradle'
apply from: '../config.gradle'


//自定义插件，groovy,java也能做插件，一般做插件用groovy
//1.脚本插件
//对象插件
//2.直接写在gradle的脚本文件中
//3.半独立插件，在buildSrc ,只能在本项目中使用
//4.独立插件，在独立的项目中

android {
    //编译SDK版本
    compileSdkVersion 30
    //编译工具版本
    buildToolsVersion "30.0.3"

    defaultConfig {
        //appId
        applicationId "com.example.exercisetest"
        //最小支持SDK版本
        minSdkVersion 23
        //目标版本
        targetSdkVersion 30
        //版本号
        versionCode 1
        //版本名称
        versionName "1.0"

        //测试单元
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    //构建类型
    buildTypes {
        //生产环境
        release {
            //表示是否对项目的代码进行混淆，true表示混淆 false表示不混淆
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
            println getUrlPath('release')
        }

        //测试环境
        debug {
            println getUrlPath('debug')
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

//用groovy语法 获取配置文件中的配置信息(文件操作)
def getUrlPath(String str) {
    def url

    Properties properties = new Properties()
    def proFile = file('src\\main\\filter\\' + str + '\\config.properties')
    if (proFile.canRead()) {
        properties.load(new FileInputStream(proFile))
        if (properties != null) {
            url = properties['SERVER2']
        }
    }
    url
}

//依赖相关信息
dependencies {

    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'com.google.android.material:material:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

    implementation 'com.umeng.umsdk:common:9.4.7'// 必选
    implementation 'com.umeng.umsdk:asms:1.4.0'// 必选
}

//groovy语法 与java语法类似，java语法严谨，groovy是糖果语法
//1.字符串 2.list 集合 3.map集合 4.方法 对象 5.任务task  6.文件操作
task stringTest {
    def str1 = "abcde"
    def str2 = "frr"
    println "${str1}-----${str2}"
}

task list {
    def list = [1, 2, 3, 4, 5]
    println list[0]
    //方式1
//    for(int i in list){
//        println list[i]
//    }

//    for(int i=0;i<list.size();i++){
//        println(list[i])
//    }

    //奇特方式2
//    for (int i in 0..4) {
//        println list[i]
//    }

    //奇特方式3 it 就表示this 这里就是每一个元素
    list.each {
        println it
    }
}

task map {
    def map = ['name': 'andy', 'age': 18]
    println map['name']
    map.each {
        println "Key:${it.key},vlaue:${it.value}"
    }
}

task method {
    def a = methodA(3, 5)
    println a
}

def methodA(int a, int b) {
    //groovy语法，默认将函数的非空(空白，注释，标点定位为空)最后一行作为结果进行返回
    a + b
}

task javaBeanTest {
    Student student = new Student()
    student.name = "groovy"
    student.age = 18
    student.setName("lily")
    student.setAge(28)
    println "name:${student.name}"
    println "nianling:${student.age}"
}

class Student {
    private String name
    private int age

    private String getName() {
        return name
    }

    private void setName(String name) {
        this.name = name
    }

    private int getAge() {
        return age
    }

    private void setAge(int age) {
        this.age = age
    }
}

//闭包类似于Java的interface,类似于前端的callback,钩子
//闭包只针对特定区域有效，{}

task closure {
    mEach {
        print it
    }

    println ""

    mEachWithParams { m, n ->//m,n ->将闭包的参数和主体区分离开来
        println "${m} is ${n}"
    }
}

def mEach(Closure<?> closure) {
    for (int i in 1..5) {
        closure(i)
    }
}

def mEachWithParams(Closure<?> closure) {
    def map = ['name': 'groovy', 'age': 10]
    map.each {
        closure(it.key, it.value)
    }
}

//app模块下的build.gradle文件中定义对象插件
//对象插件 直接写在gradle的脚本文件中
class CustomGradlePlugin implements Plugin<Project> {
    @Override
    void apply(Project target) {
        target.task("showCustomPlugin") {
            doLast {
                println("this is CustomGradlePlugin")
            }
        }
    }
}

当编译此项目后，输出对应的语句

> Configure project :app
"www.baidu.com"
"www.qq.com"
abcde-----frr
1
1
2
3
4
5
andy
Key:name,vlaue:andy
Key:age,vlaue:18
8
name:lily
nianling:28
12345
name is groovy
age is 10

2022深度学习开发者峰会

5月20日13:00让我们相聚云端，共襄盛会！