Android—Gradle教程(八)

2,045 阅读5分钟

这是我参与11月更文挑战的第6天,活动详情查看:2021最后一次更文挑战

前言

到目前为止,Gradle基础知识已经讲解完毕,对Gradle的实战也讲解了好几个了。在本篇里,将会以Gradle在组件化的使用进行详解。

1. 什么是组件化?

在回答这个问题之前首先回想一下以前我们是怎么开发的。

1.png

如图所示

之前我们开发项目的时候,就是通过定义不同的包名来表示对应的功能,比如这里的product用来表示商品列表以及商品详情相关的业务逻辑【这部分由程序员A完成】;order用来表示订单相关的业务逻辑【这部分由程序员B完成】

突然有一天,程序员A找到程序员B,怒气冲冲的说到:“你干嘛要改我商品相关的输出参数,你这一改我商品部分全乱套了!”。程序员B回怼到:“我的订单输入参数写的很规范很标准,你那太不规范了,你调用我的订单就要按照我的标准来!”。。。。

此时作为Android组长的你,看到自己俩手下争得不可开交。就思考着能不能把他们负责的功能模块从总工程移出去,让他们自己开发自己的,然后像导入Library的方式一样,将他们负责的模块引入到主工程里。

Library并不能单独运行,但又想做到他们自己开发自己的,就思考着能不能他们开发的时候,对应模块能够独立运行,组装功能点的时候,又把他们开发的功能模块切换成Library

于是乎,你带着疑问就开始查看主Module 与 Library的区别:

对应的bulid.gradle

2.png

对应的AndroidManifest.xml

3.png

我们发现,主Module 与 Library的区别无非就是这两点不同。那尝试一下将Library改成主Module

4.png

这里按照刚刚的区别,重新引入了关于主Module 的AGP脚本插件,并且在defaultConfig里面额外添加了ApplicationId属性。

5.png

对应的AndroidManifest.xml 也丰富了起来,重新编译项目。

7.png

已经成功编译,此时你应该清楚了 主Module 与 Library 相互之间转换的步骤。

所以说组件化就是开发时每个模块都可成为独立运行模块,给主Module 组装功能时又会变成对应模块的Library !

2. 开始搭建组件化框架

2.1 组件化框架初始版

于是乎,你就对原Library 进行改造。

//plugins {
//    id 'com.android.library'
//    id 'kotlin-android'
//}


project.ext{
    isModuleDebug=true
}

if (project.isModuleDebug) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

apply plugin: 'kotlin-android'

android {
    compileSdkVersion 30

    defaultConfig {
        if (project.isModuleDebug) {
            applicationId "com.hqk.main"
        }
        minSdkVersion 28
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }

    sourceSets {
        main {	//通过 sourceSets  可以指定 编译对象对应的目标路径
            if (project.isModuleDebug) {
                manifest.srcFile "src/debug/AndroidManifest.xml"
            } else {
                manifest.srcFile "src/main/AndroidManifest.xml"
            }
        }
    }

}

dependencies {

    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation 'androidx.core:core-ktx:1.3.1'
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.2.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.1'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}

你选择通过一个变量来控制该模块是Module 还是 Library ,这样就可以根据变量值动态切换Module 与 Library之间的状态!

但是现在问题来了,因为每个人都负责自己独立这块,就可能会出现:编译版本不统一,还有个更严重的问题就是依赖功能点不同。比如说程序员A喜欢用OKHttp,程序员B喜欢用XUtil,他俩互相看不惯对方依赖的三方库,到后面组装功能点的时候还是会吵起来,而且还会造成更多的冗余代码。

那思考下有啥方法可以避免该问题呢?能不能把这些配置,以及依赖统一放在一起,然后每个功能模块单独引入一下?引入??好像之前学的那个脚本插件就是靠引入的方式的嘛!

于是乎,你对Gradle脚本进行了大改。

2.2 组件化框架进阶版

在根目录创建新的脚本文件:common.gradle

project.ext {

    // 模块是否单独运行调试
    isModuleDebug = true

	//统一版本号
    minSdkVersion = 21
    targetSdkVersion = 30
    versionCode = 1
    versionName = "1.0"
    compileSdkVersion = 30
    applicationId = "com.hqk.gradledemo06"

	//    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
//    implementation 'androidx.core:core-ktx:1.3.1'
//    implementation 'androidx.appcompat:appcompat:1.2.0'
//    implementation 'com.google.android.material:material:1.2.1'
//    implementation 'androidx.constraintlayout:constraintlayout:2.0.1'

//	  implementation 'com.alibaba:arouter-api:arouter:1.5.1'





	//组装所有模块依赖的对象
    libs = [
            "appcompat"       : "androidx.appcompat:appcompat:1.2.0",
            "k-stdlib"        : "org.jetbrains.kotlin:kotlin-stdlib:1.5.10",
            "ktx"             : "androidx.core:core-ktx:1.3.1",
            "material"        : "com.google.android.material:material:1.2.1",
            "constraintlayout": "androidx.constraintlayout:constraintlayout:2.0.1",
            "arouter"         : "com.alibaba:arouter-api:1.5.1"
    ]


    apts = [
            "ARouterCompiler": "com.alibaba:arouter-compiler:1.5.1",
    ]

    // 专门用来设置application module的
    setAppDefaultConfig = {
        project ->
            project.apply plugin: "com.android.application"
            project.apply plugin: "kotlin-android"
            setAndroidConfig project.android
            setDependencies project.dependencies
    }

    setAndroidConfig = {
        android ->
            android.compileSdkVersion project.compileSdkVersion

            android.defaultConfig {
                minSdkVersion project.minSdkVersion
                targetSdkVersion project.targetSdkVersion
                versionCode project.versionCode
                versionName project.versionName
				
				//如果当前project是主module的话加入project.applicationId
                if (project.name == 'app') {
                    applicationId project.applicationId
                } else if (project.isModuleDebug) {
                	//如果功能模块需要独立运行的话,在原有applicationId后加上对应模块的后缀
                    applicationId project.applicationId
                    applicationIdSuffix = project.name
                }

                testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

                javaCompileOptions {
                    annotationProcessorOptions {
                        // 路由每个模块的名称
                        arguments += [AROUTER_MODULE_NAME: project.name]
                    }
                }
            }

            android.buildTypes {
                release {
                    minifyEnabled false
                    proguardFiles android.getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
                }
            }
            android.compileOptions {
                sourceCompatibility JavaVersion.VERSION_1_8
                targetCompatibility JavaVersion.VERSION_1_8
            }
            android.kotlinOptions {
                jvmTarget = '1.8'
            }

            android.sourceSets {
                main {
                    if (project.name != 'app') {
                    	//如果当前project为功能模块的话,将会根据是否独立运行来设置AndroidManifest路径
                        if (project.isModuleDebug) {
                            manifest.srcFile "src/debug/AndroidManifest.xml"
                        } else {
                            manifest.srcFile "src/main/AndroidManifest.xml"
                        }
                    }
                }
            }
    }

    // 定义专门为library情况下进行配置
    setLibDefalutConfig = {
        project.apply plugin: "com.android.library"
        project.apply plugin: "kotlin-android"
        setAndroidConfig project.android
        setDependencies project.dependencies
    }

    setDependencies = {
        dependencies ->
            delegate = dependencies
            //遍历依赖上面组装好的依赖
            project.libs.each {
                k, v -> implementation v
            }
            project.apts.each {
                k, v -> annotationProcessor v
            }
            testImplementation 'junit:junit:4.+'
            androidTestImplementation 'androidx.test.ext:junit:1.1.2'
            androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

			//如果当前project为主module并且其他功能模块为library时,需要依赖对应的功能模块
            if (project.name == 'app' && !project.isModuleDebug) {
                implementation project(':buissiness:login')
                implementation project(':buissiness:main')
            }
    }

}

if (project.name == 'app' || isModuleDebug) {
    // 除了app以外,还有组件调试的情况,就直接调用setAppDefaultConfig
    project.setAppDefaultConfig project
} else {
    project.setLibDefalutConfig project
}

大致的统一的脚本写好了,剩下的就只是各个功能模块以及主Module依赖该脚本了。

主Module对应的build.gradle

apply from: "${rootProject.rootDir}/common.gradle" // 这是一种脚本插件

对应功能模块对应的build.gradle【首页main功能模块】

apply from: "${rootProject.rootDir}/common.gradle" // 这是一种脚本插件

对应功能模块对应的build.gradle【登录login功能模块】

apply from: "${rootProject.rootDir}/common.gradle" // 这是一种脚本插件

//下面只是举例,在依赖公共脚本的同时,可以对单个功能点做特殊处理。
// 自己这个工程的处理就再次调用相关的这些闭包执行
android {

}

dependencies {
    println "login dependencies"
    api project(':base:baseLib')
}

到这所有配置全部配置完毕,现在来试一下效果:

isModuleDebug = true 时

8.png

所有的功能模块都能单独运行!

那么当isModuleDebug = false 时

9.png

功能模块就已经变成了对应library资源了。也就是说,我们的Gradle在组件化的配置已经成功了。

Demo下载地址:点我下载

结束语

好了,今天Gradle对应的组件化配置实战到这里结束了。在之后的架构专栏里,将会完美的实现组件化的所有操作。

因为Gradle脚本既支持Groovy脚本,也支持Kotlin脚本,所以后面会涉及到Gradle如何从Groovy脚本转换成Kotlin脚本。考虑到还有小伙伴未加入Kotlin大军来,因此下一章将会从零开始讲解Kotlin。