AGP7.0依赖版本管理version catalogs_versioncatalogs

依赖版本管理version catalogs的概念

version catalogs是AGP7.0之后推出的一种依赖版本管理的方式；

依赖版本管理version catalogs的好处

• 对所有module可见，可统一管理所有module的依赖
• 支持声明依赖bundles,组合打包依赖减少重复代码
• 支持在单独的libs.versions.toml文件中配置依赖，支持在项目间共享依赖。

依赖版本管理version catalogs的环境要求

依赖版本管理version catalogs的API

依赖版本管理version catalogs的使用

I.在setting.gradle中开启version catalogs【非必须】

enableFeaturePreview('VERSION_CATALOGS')
1

这一步，在gradle8.0以后不需要，7.0的时候还需要设置一下；

II.使用versionCatalogs创建分组，在每个组中可以使用library、bundle 、version、plugin创建版本管理内容

library【arr,jar版本管理】

1、在setting.gradle中做如下操作

enableFeaturePreview('VERSION_CATALOGS')//8.0的不需要这个
dependencyResolutionManagement {
    // 配置项目下载的maven源
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }

    //引入versionCatalogs
    versionCatalogs {
        //创建分组
        create('androidxLibs') {
            //library的参数分别对应 别名、group、artifact、version
            library('core-ktx', 'androidx.core', 'core-ktx').version('1.8.0')
            library('appcompat', 'androidx.appcompat', 'appcompat').version('1.4.1')
            library('constraintlayout', 'androidx.constraintlayout', 'constraintlayout').version('2.1.3')
			
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2，比如在app模块中引入library依赖

dependencies {
    implementation androidxLibs.core.ktx
    implementation androidxLibs.appcompat
    implementation androidxLibs.constraintlayout
    
}
1
2
3
4
5
6

bundle【依赖聚合管理】

1、在setting.gradle中做如下操作

enableFeaturePreview('VERSION_CATALOGS')//8.0的不需要这个
dependencyResolutionManagement {
    // 配置项目下载的maven源
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }

    //引入versionCatalogs
    versionCatalogs {
        //创建分组
        create('androidxLibs') {
            //library的参数分别对应 别名、group、artifact、version
            library('core-ktx', 'androidx.core', 'core-ktx').version('1.8.0')
            library('appcompat', 'androidx.appcompat', 'appcompat').version('1.4.1')
            library('constraintlayout', 'androidx.constraintlayout', 'constraintlayout').version('2.1.3')

            // androidX通用依赖
            bundle('androidx', ["core-ktx", 'appcompat', 'constraintlayout'])
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2，比如在app模块中引入bundle依赖

dependencies {
    implementation androidxLibs.bundles.androidx
}
1
2
3

version【版本号常量管理】

1、在setting.gradle中做如下操作

enableFeaturePreview('VERSION_CATALOGS')//8.0的不需要这个
dependencyResolutionManagement {
    // 配置项目下载的maven源
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }

    //引入versionCatalogs
    versionCatalogs {
        //创建分组
        /**
         * 在app/build.gradle中
         * compileSdk:buildsdk.versions.compilesdk.get().toInteger()
         */
        create('buildsdk') {
            version('compileSdk', '33')
            version('minSdk', '24')
            version('targetSdk', '33')
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2，比如在app模块中引入version依赖

android {
    namespace 'com.version.catalogs'
    compileSdk buildsdk.versions.compileSdk.get().toInteger()//引入

    defaultConfig {
        applicationId "com.version.catalogs"
        minSdk buildsdk.versions.minSdk.get().toInteger()//引入
        targetSdk buildsdk.versions.targetSdk.get().toInteger()//引入
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

plugin【gradle插件版本管理】

versionCatalogs下载插件是从gradlePluginPotal仓库中下载的；

一、发布到gradlePluginPortal的插件

​ 1、在setting.gradle中做如下操作

enableFeaturePreview('VERSION_CATALOGS')//8.0的不需要这个
dependencyResolutionManagement {
    // 配置项目下载的maven源
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }

    //引入versionCatalogs
    versionCatalogs {
        //1、只需在app/build.gradle中alias(pluginLibs.plugins.hilt.android)即可
        create('pluginLibs') {
            plugin('hilt-android', 'com.google.dagger.hilt.android').version('2.41')
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2，比如在app模块中引入plugin依赖[app.gradle]

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    alias(pluginLibs.plugins.hilt.android)
}
1
2
3
4
5

二、对于没有发布到gradlePluginPortal的插件，暂时沿用老的模式，

1、在项目的build.gradle模块中加入老的依赖

// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
    dependencies {
        // 对于没有发布到gradlePluginPortal的插件，暂时沿用老的模式，即buildScript { dependencies{  classpath 'xxx.xxx.xxx:1.0.0'}}
        classpath 'com.alibaba:arouter-register:1.0.2'
    }
}

plugins {
    id 'com.android.application' version '8.0.1' apply false
    id 'com.android.library' version '8.0.1' apply false
    id 'org.jetbrains.kotlin.android' version '1.8.20' apply false

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、在app模块引入

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    alias(pluginLibs.plugins.hilt.android)
    id 'com.alibaba.arouter'
}
1
2
3
4
5
6

以上是一种依赖版本管理的方式，还有一种以为文件的形式进行管理;

依赖版本管理version catalogs以文件的形式进行管理

1.在工程目录下创建一个libs.version.toml文件

如下图

2.libs.version.toml文件里面编写version 、plugins、libraires、bundles

代码如下：

[versions]
compileSdk = '33'
minSdk = '24'
targetSdk = '33'

[plugins]
android-application = { id = "com.android.application", version = "7.4.1" }
android-library = { id = "com.android.library", version = "7.4.1" }

[libraries]
appcompat = { module = "androidx.appcompat:appcompat", version = "1.4.1" }
material = { module = "com.google.android.material:material", version = "1.5.0" }
core-ktx = { module = "androidx.core:core-ktx", version = "1.7.0" }

[bundles]
androidx = ['appcompat', 'material', 'core-ktx']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.把libs.version.toml文件加加载进来來

//开启version-catalogs,新版本8.0不需要這句話
enableFeaturePreview('VERSION_CATALOGS')
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenLocal()
        google()
        mavenCentral()
    }
    //使用versionCatalogs标签
    versionCatalogs {
        //把libs.version.toml文件加加载进来來
        create('libs') {
            from(files("libs.version.toml"))
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.在app.gradle中使用

使用依赖

dependencies {
    //以library方式引入依赖
    implementation libs.appcompat
    implementation libs.material
    implementation libs.core.ktx

    //以bundle方式引入依赖
    implementation libs.bundles.androidx
    
}
1
2
3
4
5
6
7
8
9
10

使用插件

plugins {
    //id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    alias libs.plugins.android.application
}

android {
    namespace 'xxxxxx'
    compileSdk libs.versions.compileSdk.get().toInteger()

    defaultConfig {
        applicationId "xxxxxxx"
        minSdk libs.versions.minSdk.get().toInteger()
        targetSdk libs.versions.targetSdk.get().toInteger()
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19