Gradle Plugin 和 Dependencies 管理详解

Gradle Plugin 和 Dependencies 管理详解

在Android开发中，构建系统和依赖管理至关重要。Gradle提供了强大的插件（Plugins）和依赖（Dependencies）管理功能，帮助有效地管理项目结构和外部库。下面将深入探讨Gradle中的插件与依赖管理，特别是如何使用Gradle 7引入的Version Catalogs来统一管理依赖版本。

1. 插件 (Plugins) 和依赖 (Dependencies) 的区别

1.1 插件 (Plugins)

• 定义:

  插件是扩展Gradle功能的组件，用于自动化构建过程中的各种任务，如编译、打包、测试等。

• 用途:

  插件用于定义构建过程中的高级行为，比如Android应用的构建、测试、发布等。

• 示例:

  • com.android.application: 用于构建Android应用程序。插件定义了许多用于Android应用开发的任务，如编译代码、打包APK等。它扩展了默认的Gradle构建逻辑，专门用于处理Android项目的复杂性。
  • com.android.library: 用于构建Android库项目。

• 配置:

  插件通过plugins块在build.gradle文件中应用。

  plugins {
      id 'com.android.application' version '8.0.2' apply false
  }
  

• 运行原理:

  1. 插件的定义和注册

  • Gradle插件的定义：插件是用于扩展Gradle功能的模块。它们可以添加新的任务、新的DSL（领域特定语言）元素，或扩展现有的功能。
  • 插件的注册：插件通常通过plugins块或buildscript块在build.gradle文件中应用。插件可以是内置的，也可以是自定义或第三方提供的。

  2. 插件的生命周期

  • 配置阶段：Gradle首先加载所有的插件并执行它们的配置代码。这包括向项目中添加新的任务、扩展、属性等。此时，插件可以定义项目的整体构建逻辑。
  • 执行阶段：在配置阶段完成后，Gradle进入执行阶段，开始执行由插件定义的任务。每个任务可能依赖于其他任务的执行结果，因此任务的执行顺序也由插件控制。

1.2 依赖 (Dependencies)

• 定义:

  依赖是指项目中使用的外部库或模块，通常是从远程仓库下载的JAR文件或其他类型的包。

• 用途:

  用于引入项目中需要使用的第三方库或框架。

• 示例:

  • androidx.appcompat:appcompat: 用于兼容不同Android版本的UI组件。
  • com.google.android.material:material: 提供Material Design风格的UI组件。

• 配置:

  依赖通过dependencies块在build.gradle文件中声明。

  dependencies {
      implementation 'androidx.appcompat:appcompat:1.6.1'
      implementation 'com.google.android.material:material:1.9.0'
  }
  

• 运行原理:

  1. 依赖的定义和解析

  • 依赖的定义：依赖是指项目中引用的外部库、模块或其他项目。它们通过dependencies块在build.gradle文件中定义。

  • 依赖的解析：当Gradle构建项目时，它会解析所有定义的依赖。解析过程包括下载所需的库、处理版本冲突、确定依赖的完整依赖树等。

  2. 依赖的作用域

  • 实现作用域（implementation）：表示依赖只在编译和运行时可用，不会暴露给依赖该模块的其他模块。
  • API作用域（api）：表示依赖不仅在编译和运行时可用，而且会暴露给依赖该模块的其他模块。
  • 测试作用域（testImplementation）：表示依赖只在测试代码中可用。

  3. 依赖的传递性

  • 传递性依赖：当一个模块依赖另一个模块时，它也会继承该模块的依赖。这种传递性确保了所有必要的依赖都能在最终构建中包含。
  • 依赖树：Gradle会构建一个完整的依赖树，处理所有直接和间接依赖，并确保版本兼容性。

1.3插件和依赖的协同工作

• 插件管理依赖：某些插件会自动引入必要的依赖。例如，com.android.application插件会自动为项目添加Android SDK和其他基础依赖。
• 版本管理：通过Gradle的version catalogs，可以在整个项目中统一管理依赖的版本号，确保所有模块使用相同版本的依赖。插件可以配置和控制这些版本管理策略。

2. 版本依赖管理方式对比

Gradle提供了多种依赖管理方式，其中最常用的有ext、includeBuild和version catalogs。每种方法各有优缺点，适用于不同的项目需求。

2.1ext 扩展属性的使用详解

特点

ext 是 Gradle 中的一种扩展属性机制，允许在项目的 build.gradle 文件中定义全局变量。这些变量通常用于存储各种常量，例如依赖库的版本号、常用的路径或者其他配置参数。通过使用 ext，这些全局变量可以在整个项目或多个子项目中共享和引用，简化了配置管理。

优点

• 灵活性: 由于 ext 属性可以在项目的任何地方定义并引用，它为项目提供了极大的灵活性。可以在根项目的 build.gradle 文件中定义全局变量，然后在多个子项目中引用这些变量。
• 代码复用: 使用 ext 可以避免在多个子项目中重复定义相同的变量。例如，如果项目中有多个模块使用相同版本的依赖库，通过 ext 定义版本号后，所有模块都可以引用该版本号，从而减少了冗余代码。

缺点

• 规范性不足: 由于 ext 属性允许随意定义和使用变量，它容易导致不规范的代码。例如，不同模块可能会无意间定义相同的 ext 属性，导致意外的覆盖或者错误的引用。
• 难以维护: 随着项目规模的扩大，ext 属性的使用可能变得复杂且难以维护。特别是在大型项目中，ext 定义的变量可能散布在多个文件中，使得追踪和管理这些变量变得困难。
• 缺乏类型安全: ext 属性的值没有类型检查，这意味着在使用过程中容易出现类型错误，特别是在团队协作时。

使用示例

在一个 Android 项目中使用 ext 来管理依赖库的版本号和 SDK 版本号。可以在根项目的 build.gradle 文件中这样定义：

// 根项目的 build.gradle 文件
ext {
    compileSdkVersion = 34
    minSdkVersion = 21
    targetSdkVersion = 34
    versionCode = 1
    versionName = "1.0"

    versions = [
        appcompat      : "1.4.0",
        constraintlayout: "2.0.4",
        material       : "1.3.0"
    ]
}

在子项目的 build.gradle 文件中，可以这样引用这些 ext 属性：

// 子项目的 build.gradle 文件
android {
    compileSdkVersion rootProject.ext.compileSdkVersion

    defaultConfig {
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
        versionCode rootProject.ext.versionCode
        versionName rootProject.ext.versionName
    }
}

dependencies {
    implementation "androidx.appcompat:appcompat:${rootProject.ext.versions.appcompat}"
    implementation "androidx.constraintlayout:constraintlayout:${rootProject.ext.versions.constraintlayout}"
    implementation "com.google.android.material:material:${rootProject.ext.versions.material}"
}

ext 属性提供了一个简单、灵活的方式来在 Gradle 项目中定义和共享全局变量。尽管它在小型项目中非常实用，但随着项目的扩展，其维护成本和复杂性也会增加。因此，在大型项目中，可能需要考虑更规范的版本管理机制，如 Version Catalogs。

2.2 includeBuild

特点

includeBuild 是 Gradle 中的一种高级功能，允许通过嵌套构建将多个子项目组合在一起，形成一个多项目构建系统。这种方式特别适用于大型项目，其中各个模块（或子项目）可能需要独立构建、测试和发布。

优点

1. 模块化管理: includeBuild 允许将大型项目拆分成多个模块，各模块可以独立开发、测试和维护，有助于提高代码的可维护性和可扩展性。
2. 减少重复构建: 在多项目构建中，如果某个模块已经构建过了，includeBuild 可以避免重复构建该模块，从而节省时间和资源。
3. 灵活性: 可以方便地在开发过程中将模块作为独立的项目进行调试，或者将其合并到主项目中进行集成测试。

缺点

1. 版本号管理复杂:

   includeBuild 在管理各个子项目的版本号时，可能会带来一些挑战，特别是当需要在多个项目之间协调版本号时。

2. 动态调整困难:

   由于 includeBuild 的结构性特点，动态调整项目依赖或版本号可能需要更多的配置和管理工作。

使用方法

一个大型项目，并且希望将其拆分为多个模块，同时通过 includeBuild 将这些模块组合在一起。可以按以下步骤进行配置：

1. 创建子项目:

   • 在主项目的根目录下创建子项目。创建一个名为 library 的模块：

     mkdir library
     cd library
     gradle init --type java-library
     

2. 配置 settings.gradle 文件:

   • 在主项目的 settings.gradle 文件中，使用 includeBuild 将子项目引入主项目。

     includeBuild('library')
     

3. 引用子项目的构建输出:

   • 在主项目的 build.gradle 文件中，直接使用子项目的构建输出。使用 library 模块生成的 jar 文件：

     dependencies {
         implementation project(':library')
     }
     

4. 执行构建:

   • 当主项目中执行 gradle build 时，Gradle 会自动识别并构建所有包含的子项目。

5. 模块之间的依赖管理:

   • 使用 includeBuild 时，可以在各模块之间定义明确的依赖关系。通过在子项目中配置 build.gradle，可以指定该子项目需要的依赖项或插件。

这种方式使得大型项目的管理更加系统化，减少了代码重复，并增强了开发的灵活性。然而，在实际使用中，需要根据项目的复杂性调整配置，以确保各个模块能够顺利集成。

2.3 version catalogs

• 特点: Gradle 7引入的新特性，使用*.toml文件或*.properties文件来管理依赖项的版本信息。
• 优点: 统一管理所有模块的依赖，支持声明依赖bundles，减少重复代码，支持在项目间共享依赖。
• 缺点: 版本号不可修改，要求严格的语法和配置。

3.Gradle 7.6 用法与原理详解

1. Gradle 7.6 的关键特性

Gradle 7.6 在构建工具中引入了一些新的功能和优化，以提升构建速度、增强插件开发的灵活性，并进一步改进了依赖管理。

• 改进的依赖管理：Gradle 7.6 支持通过 version catalogs 更加清晰和模块化地管理依赖。version catalogs 提供了一个中心化的地方来定义项目中的所有依赖和插件版本，这有助于维护依赖的一致性。

• 插件开发的灵活性：Gradle 7.6 继续加强对插件开发的支持，提供了更好的API来开发和发布插件，使得在项目中使用插件更加简便和强大。

• 构建速度的提升：Gradle 7.6 通过优化构建缓存和并行执行策略，减少了重复构建的时间，提高了构建效率。

2. 项目配置中的各个文件详解

2.1. app/build.gradle 文件

这个文件是应用模块的核心配置文件，包含了与 Android 应用开发相关的所有配置信息。

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

• plugins：在这里声明了应用所需的插件，包括 com.android.application 和 org.jetbrains.kotlin.android，分别用于Android应用和Kotlin的支持。

android {
    namespace 'com.techme.jetpack_android_online'
    compileSdk buildsdk.versions.compilesdk.get().toInteger()
    
    // 配置应用的最低SDK版本、目标SDK版本等
    defaultConfig {
        applicationId "com.techme.jetpack_android_online"
        minSdk buildsdk.versions.minisdk.get().toInteger()
        targetSdk buildsdk.versions.targetsdk.get().toInteger()
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

• android：配置了与Android SDK版本、应用的包名、版本信息以及测试框架相关的内容。通过versionCatalogs引用 buildsdk 中定义的SDK版本号，使得这些版本号集中管理。

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

• buildTypes：定义了构建类型，这里声明了 release 类型的构建配置，并禁用了代码混淆（minifyEnabled false），同时指定了ProGuard的配置文件。

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }

• compileOptions & kotlinOptions：定义了Java和Kotlin编译的兼容性选项，这里分别将Java版本设定为11，Kotlin JVM目标设定为1.8，以确保代码能够在兼容的Java虚拟机上运行。

    viewBinding {
        enabled = true
    }
}

• viewBinding：启用了 View Binding 功能，使得在代码中能够安全地引用视图。

dependencies {
    implementation androidxLibs.bundles.androidx
    implementation androidxLibs.fastjson

    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
    implementation project(path: ':nav-plugin-runtime')
}

• dependencies：列出了该模块的所有依赖项。这里通过versionCatalogs引用了在 settings.gradle 中定义的依赖项，并使用了项目依赖（implementation project(path: ':nav-plugin-runtime')）来引入本地模块。

2.2. build.gradle（项目根目录）

这个文件通常用于管理整个项目的全局配置，如插件和构建脚本的依赖。

buildscript {
    dependencies {
        // 对于没有发布到gradlePluginPortal的插件，暂时沿用老的模式
        // classpath "com.alibaba:arouter-register:1.0.2"
    }
}

• buildscript：旧模式的插件管理方式，适用于尚未发布到Gradle Plugin Portal的插件。

plugins {
    id 'com.android.application' version '7.4.1' apply false
    id 'com.android.library' version '7.4.1' apply false
    id 'org.jetbrains.kotlin.android' version '1.8.0' apply false
    id 'org.jetbrains.kotlin.jvm' version '1.8.0' apply false
    id 'com.gradle.plugin-publish' version '1.1.0' apply false
}

• plugins：声明了项目中所使用的插件，但通过 apply false 来延迟应用，防止在根项目中多余地加载它们。

2.3. settings.gradle 文件

pluginManagement {
    repositories {
        mavenLocal()
        maven { allowInsecureProtocol = true; url 'http://dl.bintray.com/umsdk/release' }
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

• pluginManagement：配置插件管理的仓库，定义插件的查找路径。

enableFeaturePreview('VERSION_CATALOGS')
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenLocal()
        maven { url 'https://maven.aliyun.com/repository/releases' }
        google()
        mavenCentral()
    }
    versionCatalogs {
        create('androidxLibs') {
            // 别名 group artifact version
            library('core-ktx', 'androidx.core', 'core-ktx').version('1.7.0')
            library('appcompat', 'androidx.appcompat', 'appcompat').version('1.4.1')
            bundle('androidx', ['core-ktx', 'appcompat', 'constraintlayout'])
        }
        create('buildsdk') {
            version('compilesdk', '33')
            version('minisdk', '23')
            version('targetsdk', '33')
        }
    }
}

• enableFeaturePreview('VERSION_CATALOGS')：启用 Version Catalogs 功能，该功能允许在项目中集中定义并管理依赖版本，提升项目的一致性和维护性。
• dependencyResolutionManagement：定义了全局依赖的解析策略和仓库源，同时通过 versionCatalogs 集中管理了项目的依赖版本。

2.4.versionCatalogs代码详解

versionCatalogs 是 Gradle 7.0 引入的一项功能，旨在集中管理项目中的依赖版本和库定义。它允许将依赖项版本集中定义在一个地方，从而简化了多个模块之间的版本管理和依赖共享。

versionCatalogs 用于定义依赖库和版本号。这有助于在项目中保持一致性，并减少手动管理依赖版本的错误风险。

versionCatalogs {
    create('androidxLibs') {
        // 别名 group artifact version
        library('core-ktx', 'androidx.core', 'core-ktx').version('1.7.0')
        library('appcompat', 'androidx.appcompat', 'appcompat').version('1.4.1')
        bundle('androidx', ['core-ktx', 'appcompat', 'constraintlayout'])
    }
    create('buildsdk') {
        version('compilesdk', '33')
        version('minisdk', '23')
        version('targetsdk', '33')
    }
}

1. create('androidxLibs') 和 create('buildsdk')

• create('androidxLibs'): 这里创建了一个名为 androidxLibs 的版本目录（version catalog）。androidxLibs 目录中定义了一些特定的依赖库，这些库可以在整个项目中以简单的别名来引用。

• create('buildsdk'): 这个版本目录用于存储编译、最小和目标SDK的版本号。它为项目中使用的不同SDK版本提供了一致的定义。

2. library 方法

library 方法用于定义一个依赖库。这个方法接收三个参数：

• 别名（alias）: 为这个库指定一个简短的名称，例如 core-ktx。在引用这个库时，可以使用这个别名，而不是完整的 group 和 artifact 名称。

• group: 依赖库的组织名（例如 androidx.core），这是一个用于标识依赖的分组名称。

• artifact: 依赖库的工件ID（例如 core-ktx），这是依赖库在其分组中的唯一标识符。

• version: 通过 version() 方法来指定该依赖库的版本号。这里 core-ktx 被指定为 1.7.0 版本，而 appcompat 被指定为 1.4.1 版本。

library('core-ktx', 'androidx.core', 'core-ktx').version('1.7.0')
library('appcompat', 'androidx.appcompat', 'appcompat').version('1.4.1')

3. bundle 方法

bundle 方法允许将多个依赖项组合在一起，以简化对一组相关依赖项的引用。

• 别名: 定义一个组合的别名，如 androidx。
• 包含的依赖: 传入一个依赖库别名的列表，例如 ['core-ktx', 'appcompat', 'constraintlayout']。

在这个例子中，androidx 组合包括 core-ktx、appcompat 和 constraintlayout 三个库。可以通过引用这个组合别名来添加这些库，而不是单独添加它们。

bundle('androidx', ['core-ktx', 'appcompat', 'constraintlayout'])

4. version 方法

version 方法用于在版本目录中定义常量版本号。可以通过别名引用这些常量来确保版本一致性。

version('compilesdk', '33')
version('minisdk', '23')
version('targetsdk', '33')

在这个例子中，compilesdk、minisdk 和 targetsdk 分别定义了SDK版本为 33 和 23。

2.5.versionCatalogs扩展功能

versionCatalogs 功能可以进一步扩展，用于管理插件版本、依赖的模块化管理等。以下是一些未使用到的扩展功能：

1. 定义插件（Plugin）

除了定义依赖库外，还可以在 versionCatalogs 中定义插件。这使得插件版本的管理变得更加集中和一致。

plugins {
    alias(libs.plugins.kotlin).apply(false)
}

2. 使用version 来集中管理版本号

除了为每个库单独指定版本号外，可以使用 version 来集中管理这些版本号，然后在各个库定义中引用它们。

versionCatalogs {
    create('libs') {
        version('kotlin', '1.5.30')
        library('kotlin-stdlib', 'org.jetbrains.kotlin', 'kotlin-stdlib').versionRef('kotlin')
    }
}

3. 使用 bundles 创建多个库的组合

通过 bundles 创建更多的库组合，尤其是对于常用的一组库，例如 Jetpack 组件的整合。

bundles {
    jetpack = ['core-ktx', 'lifecycle-runtime-ktx', 'navigation-fragment-ktx']
}

2.6.如何在项目中使用 versionCatalogs

定义好 versionCatalogs 后，可以在项目的各个模块中使用这些集中定义的别名。

dependencies {
    implementation(libs.coreKtx)
    implementation(libs.androidx.appcompat)
    implementation(libs.bundles.androidx)
    testImplementation(libs.junit)
}

这种集中管理使得项目的依赖管理变得更加可维护和一致。

4.Gradle 8.7 用法与原理详解

Gradle 8.7 是一个强大的构建工具，提供了丰富的功能和灵活的配置方式，尤其在Android开发中被广泛使用。下面将详细探讨Gradle 8.7的用法和原理。

1. 项目代码解析

项目代码包括三个核心文件：

• app/build.gradle
• 根目录/build.gradle
• settings.gradle

这些文件分别定义了项目的模块配置、全局插件和依赖管理，以及项目的构建环境。

2. app/build.gradle 文件详解

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.jetbrains.kotlin.android)
}

android {
    namespace 'com.changqing.jetpack'
    compileSdk 34

    defaultConfig {
        applicationId "com.changqing.jetpack"
        minSdk 24
        targetSdk 34
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
            useSupportLibrary true
        }
    }

    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'
    }
    
    buildFeatures {
        compose true
    }
    
    composeOptions {
        kotlinCompilerExtensionVersion '1.5.1'
    }
    
    packaging {
        resources {
            excludes += '/META-INF/{AL2.0,LGPL2.1}'
        }
    }
}

dependencies {
    implementation libs.androidx.core.ktx
    implementation libs.androidx.lifecycle.runtime.ktx
    implementation libs.androidx.activity.compose

    implementation platform(libs.androidx.compose.bom)
    implementation libs.androidx.ui
    implementation libs.androidx.ui.graphics
    implementation libs.androidx.ui.tooling.preview
    implementation libs.androidx.material3

    testImplementation libs.junit
    androidTestImplementation libs.androidx.junit
    androidTestImplementation libs.androidx.espresso.core
    androidTestImplementation platform(libs.androidx.compose.bom)
    androidTestImplementation libs.androidx.ui.test.junit4
    debugImplementation libs.androidx.ui.tooling
    debugImplementation libs.androidx.ui.test.manifest
}

• 插件配置：使用 alias 关键字引用了插件，简化了插件的声明。这种方式依赖于 versionCatalogs，使插件版本管理更为简洁和统一。

• Android 配置块：

  • namespace：设置了应用程序的命名空间。
  • compileSdk：定义了编译SDK的版本，这里设置为34。
  • defaultConfig：包括应用的基本配置，如 applicationId、minSdk、targetSdk、versionCode、versionName等。
  • buildTypes：配置了构建类型，如 release 类型，关闭了代码混淆（minifyEnabled false），并指定了ProGuard配置文件。

• 编译选项：

  • compileOptions：设置Java版本兼容性为1.8。
  • kotlinOptions：设置Kotlin JVM目标版本为1.8。

• 构建功能：

  • buildFeatures：启用了Jetpack Compose。
  • composeOptions：指定了Compose编译器扩展的版本。

• 依赖管理：项目中的依赖通过 libs 进行引用，利用了 versionCatalogs 来管理库版本，确保一致性和简洁性。

3. 根目录/build.gradle 文件详解

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.jetbrains.kotlin.android) apply false
}

• 全局插件管理：根目录的 build.gradle 文件中定义了全局插件，这些插件不会自动应用到所有子模块，而是需要在具体的模块中手动应用。这种做法有助于保持模块的独立性和配置的灵活性。

4. settings.gradle 文件详解

pluginManagement {
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "jetpack-cw"
include ':app'

• 插件管理：pluginManagement 块用于全局配置插件的解析规则，指定了插件可以从 google、mavenCentral 和 gradlePluginPortal 中获取。

• 依赖解析管理：dependencyResolutionManagement 块通过设置 RepositoriesMode.FAIL_ON_PROJECT_REPOS 强制所有子项目使用根项目的仓库配置，避免子项目自行定义仓库。

• 项目结构：include ':app' 指定了项目包含的模块，这里只包含一个 app 模块。

5. 版本和库的配置详细说明

libs.versions.toml 文件用于集中管理项目中的版本号和库依赖，提供了一个清晰、统一的方式来配置项目的版本和依赖。以下是对文件内容的详细描述和使用方法：

5.1 版本管理 ([versions] 块)

[versions]
agp = "8.5.0"
kotlin = "1.9.0"
coreKtx = "1.10.1"
junit = "4.13.2"
junitVersion = "1.1.5"
espressoCore = "3.5.1"
lifecycleRuntimeKtx = "2.6.1"
activityCompose = "1.8.0"
composeBom = "2024.04.01"

• 定义版本号：在 [versions] 块中，可以定义项目中使用的各种版本号。这些版本号可以是库版本、插件版本等。通过集中管理版本号，可以确保项目中所有的依赖使用一致的版本，避免版本冲突。

  • agp：指定 Android Gradle 插件的版本。
  • kotlin：指定 Kotlin 插件的版本。
  • coreKtx、junit、junitVersion、espressoCore、lifecycleRuntimeKtx、activityCompose 和 composeBom 等：这些是其他依赖库的版本号，分别用于 AndroidX 库、JUnit 测试框架、Jetpack Compose 等。

5.2 库定义 ([libraries] 块)

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-material3 = { group = "androidx.compose.material3", name = "material3" }

• 定义库：在 [libraries] 块中，可以定义项目中使用的所有库。每个库由 group 和 name 组成，version.ref 用于引用在 [versions] 中定义的版本号。

  • androidx-core-ktx：定义了 androidx.core:core-ktx 库，版本使用 coreKtx。
  • junit：定义了 junit:junit 库，版本使用 junit。
  • androidx-junit：定义了 androidx.test.ext:junit 库，版本使用 junitVersion。
  • androidx-espresso-core：定义了 androidx.test.espresso:espresso-core 库，版本使用 espressoCore。
  • androidx-lifecycle-runtime-ktx：定义了 androidx.lifecycle:lifecycle-runtime-ktx 库，版本使用 lifecycleRuntimeKtx。
  • androidx-activity-compose：定义了 androidx.activity:activity-compose 库，版本使用 activityCompose。
  • androidx-compose-bom：定义了 androidx.compose:compose-bom 库，版本使用 composeBom。

  对于 Jetpack Compose 相关的库，如 androidx-ui、androidx-ui-graphics、androidx-ui-tooling 等，未指定版本号，因为这些库的版本由 BOM（Bill of Materials）管理。BOM 使得项目能够以一致的版本运行所有 Compose 相关库。

5.3 插件定义 ([plugins] 块)

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

• 定义插件：在 [plugins] 块中，可以定义项目中使用的插件及其版本。通过 id 指定插件的 ID，version.ref 用于引用在 [versions] 中定义的版本号。

  • android-application：定义了 com.android.application 插件，版本使用 agp。
  • jetbrains-kotlin-android：定义了 org.jetbrains.kotlin.android 插件，版本使用 kotlin。

  这种方式使插件版本的管理更加集中和简洁，避免了在多个 build.gradle 文件中重复定义插件版本。

5.4 定义 ([bundle] 块)

在 libs.versions.toml 文件中，也可以使用 bundle 来创建库集合，并将多个依赖项组合在一起，从而可以在 build.gradle 文件中一次性添加这些依赖项。比如 navigation-fragment、navigation-ui、appcompat 和 constraintlayout 等库都需要在 libs.versions.toml 中定义后才能被捆绑在一起。

1.定义依赖项：首先，需要在 libs.versions.toml 文件中为每个库定义 library 条目。

[libraries]
#navigation
navigation-fragment = { group = "androidx.navigation", name = "navigation-fragment-ktx", version.ref = "navigation" }
navigation-ui = { group = "androidx.navigation", name = "navigation-ui-ktx", version.ref = "navigation" }
appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }
material = { group = "com.google.android.material", name = "material", version.ref = "material" }  # 添加 Material 依赖
#nav-plugin
asm = { group = "org.ow2.asm", name = "asm", version.ref = "asm" }
nsm-tree = { group = "org.ow2.asm", name = "asm-tree", version.ref = "asm" }
commons-io = { group = "commons-io", name = "commons-io", version.ref = "commons-io" }
kotlinpoet = { group = "com.squareup", name = "kotlinpoet", version.ref = "kotlinpoet" }
agp = { group = "com.android.tools.build", name = "gradle", version.ref = "agp" }

2.创建 bundle：在 libs.versions.toml 文件中使用 bundle 定义一个集合，把这些库组合在一起。

[bundles]
androidx = ['navigation-fragment', 'navigation-ui', 'appcompat', 'constraintlayout', 'material']
nav-plugin = ['asm', 'nsm-tree', 'commons-io', 'kotlinpoet', 'agp']

3.在 build.gradle 文件中使用 bundle：

dependencies {
    implementation libs.bundles.androidx
}

5.5 使用 libs.versions.toml 文件

• 在 settings.gradle 中配置 versionCatalogs：

  在 settings.gradle 文件中，配置 versionCatalogs 以启用 libs.versions.toml 文件的使用：

  dependencyResolutionManagement {
      versionCatalogs {
          create("libs") {
              from(files("gradle/libs.versions.toml"))
          }
      }
  }
  

• 在 build.gradle 文件中引用库和插件：

  在 app/build.gradle 文件中，可以使用 libs 来引用 libs.versions.toml 中定义的库和插件：

  plugins {
      alias(libs.plugins.android.application)
      alias(libs.plugins.jetbrains.kotlin.android)
  }
  
  dependencies {
      implementation libs.androidx.core.ktx
      implementation libs.androidx.lifecycle.runtime.ktx
      implementation libs.androidx.activity.compose
  
      implementation platform(libs.androidx.compose.bom)
      implementation libs.androidx.ui
      implementation libs.androidx.ui.graphics
      implementation libs.androidx.ui.tooling.preview
      implementation libs.androidx.material3
  
      testImplementation libs.junit
      androidTestImplementation libs.androidx.junit
      androidTestImplementation libs.androidx.espresso.core
      androidTestImplementation platform(libs.androidx.compose.bom)
      androidTestImplementation libs.androidx.ui.test.junit4
      debugImplementation libs.androidx.ui.tooling
      debugImplementation libs.androidx.ui.test.manifest
  }
  

  • 插件：通过 alias(libs.plugins.android.application) 和 alias(libs.plugins.jetbrains.kotlin.android) 来应用插件。

  • 依赖：通过 libs.androidx.core.ktx、libs.androidx.lifecycle.runtime.ktx 等引用库。在使用 BOM 的情况下，例如 implementation platform(libs.androidx.compose.bom)，所有 Compose 相关库的版本由 BOM 统一管理。

6. Gradle 8.7 原理解析

Gradle 是一个基于DSL（领域特定语言）的构建工具，通过定义任务（Tasks）来描述构建过程。Gradle 8.7 引入了一些性能改进，特别是在依赖解析和任务执行方面。以下是构建过程的基本步骤：

1. 初始化阶段：Gradle 加载项目的设置文件（settings.gradle），确定项目的结构和模块。

2. 配置阶段：Gradle 解析所有的 build.gradle 文件，并生成任务图（Task Graph）。这个图描述了所有任务的依赖关系。

3. 执行阶段：Gradle 按照任务图的顺序执行任务，完成编译、测试、打包等工作。

Gradle 8.7 还优化了任务的增量构建、缓存机制，并提高了对大型项目的支持能力。通过使用 versionCatalogs 和 dependencyResolutionManagement，可以更好地管理项目中的依赖和插件版本，提升构建的可维护性和稳定性。

5. 总结

在Gradle中，插件和依赖管理是开发过程中不可或缺的一部分。通过合理利用不同的依赖管理方式，如ext、includeBuild和version catalogs，可以显著提高项目的可维护性和一致性。特别是Version Catalogs，它通过统一的配置管理，使得大型项目的依赖管理更加简洁、可靠。在实际项目中，选择适合自己团队和项目的方式尤为重要。