Android—Gradle教程（八）_android-gradle 教程 android_hqk

前言

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

1. 什么是组件化？

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

如图所示

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

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

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

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

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

对应的bulid.gradle

对应的AndroidManifest.xml

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

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

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

已经成功编译，此时你应该清楚了 主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'
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

你选择通过一个变量来控制该模块是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
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

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

主Module对应的build.gradle

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

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

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

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

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

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

}

dependencies {
    println "login dependencies"
    api project(':base:baseLib')
}
1
2
3
4
5
6
7
8
9
10
11
12

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

isModuleDebug = true 时

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

那么当isModuleDebug = false 时

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

Demo下载地址:点我下载

结束语

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

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