Android项目管理依赖方式总结

Posted yubo_725

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android项目管理依赖方式总结相关的知识，希望对你有一定的参考价值。

随着android项目越来约大，管理项目中依赖的三方库成了一个非常重要的部分，若管理不当，不同module中可能会依赖同一个库的不同版本，这将导致非常严重的问题，要么是代码冲突，要么是APK包体积增大，亦或是项目构建的时间变长，拖慢开发效率。使用好的方式管理Android项目的依赖库显得尤其重要，本文记录了当下几种不同的管理Android依赖的方法，希望跟大家一起学习进步！

原始方式

这种管理依赖的方式是我们以前用得最多的，即直接将依赖的库写在module的build.gradle文件中，如下代码所示：

implementation "com.squareup.okhttp3:okhttp:5.0.0-alpha.2"
implementation "org.greenrobot:eventbus:3.2.0"
implementation "com.github.bumptech.glide:glide:4.12.0"
annotationProcessor "com.github.bumptech.glide:compiler:4.12.0"
implementation "io.reactivex.rxjava3:rxjava:3.0.13"
implementation "com.tencent:mmkv-static:1.2.10"
implementation "com.squareup.retrofit2:retrofit:2.9.0"

这种管理依赖的方式缺点非常明显，如果项目中有多个不同的module，你需要在多个module的build.gradle文件中都做对应的配置，还要确保依赖的库的版本号一致，配置项要重复编写多次。

Ext方式

这种方式是在项目根目录下创建config.gradle配置文件（你也可以取任意文件名），然后将项目中需要的依赖项统一放在这个配置文件中，再在根目录下的build.gradle中引用这个配置文件，比如下面的代码所示：

// 第一步：在项目根目录下创建config.gradle文件，内容如下
ext {
    versions = [
            okhttp_verison  : '5.0.0-alpha.2',
            eventbus_version: '3.2.0',
            glide_version   : '4.12.0',
            rxjava_version  : '3.0.13',
            mmkv_version    : '1.2.10',
            retrofit_version: '2.9.0',
    ]
}

// 第二步：在项目根目录下的build.gradle文件中引用上面的config.gradle文件：

apply from: './config.gradle'
buildscript {
    ext.kotlin_version = "1.5.20"
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.2.2"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

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

// 第三步：在module的build.gradle文件中引用
def vs = rootProject.ext.versions

dependencies {
    implementation "com.squareup.okhttp3:okhttp:${vs.okhttp_version}"
    implementation "org.greenrobot:eventbus:${vs.eventbus_version}"
    implementation "com.github.bumptech.glide:glide:${vs.glide_version}"
    annotationProcessor "com.github.bumptech.glide:compiler:${vs.glide_version}"
    implementation "io.reactivex.rxjava3:rxjava:${vs.rxjava_version}"
    implementation "com.tencent:mmkv-static:${vs.mmkv_version}"
    implementation "com.squareup.retrofit2:retrofit:${vs.retrofit_version}"
}

这种方式的优点是，将所有依赖库的版本统一放到一个文件中管理了，若有多个不同的module，引用方式和上面第三步中一样，不会导致同一个库出现不同版本，但是上面第三步的配置在有多个module的情况下还是稍微有些冗余了，如果多个module中都需要用到okhttp，类似implementation "com.squareup.okhttp3:okhttp:${vs.okhttp_version}"的配置代码就需要写多次了，针对这种情况可以做如下改进：

// 修改根目录下的config.gradle文件如下：
ext {
    // 定义所有依赖库的版本
    versions = [
            okhttp_version  : '5.0.0-alpha.2',
            eventbus_version: '3.2.0',
            glide_version   : '4.12.0',
            rxjava_version  : '3.0.13',
            mmkv_version    : '1.2.10',
            retrofit_version: '2.9.0',
    ]

    // 定义所有依赖库的全路径
    deps = [
            okhttp        : "com.squareup.okhttp3:okhttp:${versions.okhttp_version}",
            eventbus      : "org.greenrobot:eventbus:${versions.eventbus_version}",
            glide         : "com.github.bumptech.glide:glide:${versions.glide_version}",
            glide_compiler: "com.github.bumptech.glide:compiler:${versions.glide_version}",
            rxjava        : "io.reactivex.rxjava3:rxjava:${versions.rxjava_version}",
            mmkv          : "com.tencent:mmkv-static:${versions.mmkv_version}",
            retrofit      : "com.squareup.retrofit2:retrofit:${versions.retrofit_version}",
    ]
}

// 然后在module的build.gradle文件中用下面的方式来引用：

def deps = rootProject.ext.deps

dependencies {
    implementation deps.okhttp
    implementation deps.eventbus
    implementation deps.glide
    annotationProcessor deps.glide_compiler
    implementation deps.rxjava
    implementation deps.mmkv
    implementation deps.retrofit
}

这样的话，如果存在多个module都需要引用okhttp库，需要配置的代码就非常简短了，只需在每个module的build.gradle文件中都做这个配置即可：implementation deps.okhttp

第二种方式较第一种方式已经有很大的进步了，统一了依赖库的版本号和依赖项的全名，但是在AndroidStudio中，你会发现在写依赖项时，IDE没有给出代码提示，这虽然是个小问题，通过复制粘贴能确保不出错，但是依然有更好的办法来改进。

buildSrc方式

这种方式管理Android项目的依赖步骤如下：

  1. 在Android项目根目录下创建buildSrc目录，然后make项目，buildSrc目录下会自动创建一些文件

  2. 在buildSrc目录下新建src/main/java目录，在其中新建一个kt文件用于定义依赖版本和依赖项，代码如下：

    // Deps.kt
object Versions {
    val okhttp = "5.0.0-alpha.2"
    val eventbus = "3.2.0"
    val glide = "4.12.0"
    val rxjava = "3.0.13"
    val mmkv = "1.2.10"
    val retrofit = "2.9.0"
}

object Deps {
    val okhttp = "com.squareup.okhttp3:okhttp:${Versions.okhttp}"
    val eventbus = "org.greenrobot:eventbus:${Versions.eventbus}"
    val glide = "com.github.bumptech.glide:glide:${Versions.glide}"
    val glideCompiler = "com.github.bumptech.glide:compiler:${Versions.glide}"
    val rxjava = "io.reactivex.rxjava3:rxjava:${Versions.rxjava}"
    val mmkv = "com.tencent:mmkv-static:${Versions.mmkv}"
    val retrofit = "com.squareup.retrofit2:retrofit:${Versions.retrofit}"
}

  3. 在buildSrc目录下创建build.gradle.kts文件，加入如下代码：

    plugins {
    `kotlin-dsl`
}
repositories{
    jcenter()
}

  4. 在module的build.gradle文件中，可以这么引用依赖项了：

    dependencies {
    implementation Deps.okhttp
    implementation Deps.eventbus
    implementation Deps.glide
    annotationProcessor Deps.glideCompiler
    implementation Deps.rxjava
    implementation Deps.mmkv
    implementation Deps.retrofit
}

使用这种方式做依赖管理，你会发现在修改build.gradle文件时，会出现代码提示了，如下图所示：
在这里插入图片描述
buildSrc这种方式较前两种方式已经非常好了，它支持代码跟踪，编写依赖项时有代码提示，但是它并不是最完美的一种方式，因为如果某个依赖项版本做了更新，使用buildSrc方式会导致整个项目都重新构建，导致编译速度变慢。

Composing builds方式

这种方式管理依赖的步骤如下：

  1. 在项目根目录下创建一个新的Java Library，这里我取名为version-plugin，包名为com.example.plugin

  2. 修改version-plugin根目录下的build.gradle文件，内容如下：

    buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        // 因为使用的 Kotlin 需要需要添加 Kotlin 插件
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"
    }
}

apply plugin: 'kotlin'
apply plugin: 'java-gradle-plugin'

repositories {
    // 需要添加 jcenter 否则会提示找不到 gradlePlugin
    jcenter()
    google()
}

dependencies {
    implementation gradleApi()
    implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"
}

compileKotlin {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

gradlePlugin {
    plugins {
        version {
            // 在 app 模块需要通过 id 引用这个插件
            id = 'com.example.plugin'
            // 实现这个插件的类的路径
            implementationClass = 'com.example.plugin.VersionPlugin'
        }
    }
}

  3. 在version-plugin中的src/main/java/com/example/plugin目录下创建Deps.kt文件，内容如下：

    package com.example.plugin

object Versions {
    val okhttp = "5.0.0-alpha.2"
    val eventbus = "3.2.0"
    val glide = "4.12.0"
    val rxjava = "3.0.13"
    val mmkv = "1.2.10"
    val retrofit = "2.9.0"
}

object Dependencies {
    val okhttp = "com.squareup.okhttp3:okhttp:${Versions.okhttp}"
    val eventbus = "org.greenrobot:eventbus:${Versions.eventbus}"
    val glide = "com.github.bumptech.glide:glide:${Versions.glide}"
    val glideCompiler = "com.github.bumptech.glide:compiler:${Versions.glide}"
    val rxjava = "io.reactivex.rxjava3:rxjava:${Versions.rxjava}"
    val mmkv = "com.tencent:mmkv-static:${Versions.mmkv}"
    val retrofit = "com.squareup.retrofit2:retrofit:${Versions.retrofit}"
}

  4. 在version-plugin中的src/main/java/com/example/plugin目录下创建VersionPlugin.kt文件，内容如下：

    package com.example.plugin

import org.gradle.api.Plugin
import org.gradle.api.Project

class VersionPlugin : Plugin<Project> {
    override fun apply(target: Project) {

    }
}

    虽然这个类是对Plugin接口的一个空实现，但是一定要有，否则后面的构建会报错。

  5. 在Android项目根目录下的settings.gradle文件中，添加如下配置：

    includeBuild("version-plugin")

    注意删除之前创建version-plugin时自动在这个文件中添加的include ':version-plugin'配置。

  6. 在module根目录下的build.gradle文件中引用上面创建的插件，然后就可以引用到插件里定义的依赖了，如下代码：

    import com.example.plugin.Dependencies  // 配置1

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'com.example.plugin' // 配置2
}

// 下面就能引用插件中的Dependencies类中定义的常量了
dependencies {
    implementation Dependencies.okhttp
    implementation Dependencies.eventbus
    implementation Dependencies.glide
    annotationProcessor Dependencies.glideCompiler
    implementation Dependencies.rxjava
    implementation Dependencies.mmkv
    implementation Dependencies.retrofit
}

这种方式是目前最为推荐的管理Android项目依赖的方式，它比buildSrc方式更优秀的地方在于，某个依赖项更新了不会触发整个项目的重新构建。

源码

https://github.com/yubo725/android-dependencies-demo

参考

以上是关于Android项目管理依赖方式总结的主要内容，如果未能解决你的问题，请参考以下文章

Android项目管理依赖方式总结

Android项目管理依赖方式总结

Android项目管理依赖方式总结

Android片段和依赖注入

Android 片段和依赖注入

使用循环片段依赖关系模块化单活动Android应用程序