Gradle Kotlin Convention Plugins for Modularized Structure & Shared Build Logic

Gradle Kotlin Convention Plugins 是一种 Gradle 插件，它提供了一种约定式的方式来组织和构建 Kotlin 项目，特别是适用于模块化结构的项目。该插件提供了一些默认的约定和配置，使得开发人员可以更加轻松地管理模块之间的依赖关系和构建逻辑，并且可以实现构建逻辑的共享和重用。

在本教程中，我们将介绍如何使用 Gradle Kotlin Convention Plugins 来构建一个简单的模块化 Kotlin 项目。该项目包含两个模块：一个是核心模块，一个是应用程序模块。我们将使用 Gradle Kotlin Convention Plugins 来设置模块之间的依赖关系和构建逻辑，并且通过共享构建逻辑来简化构建过程。

步骤一：创建项目

首先，我们需要创建一个新的 Kotlin 项目，并且使用 Gradle 作为构建工具。可以使用任何 IDE 来创建项目，例如 Android Studio 或者 IntelliJ IDEA。在创建项目时，请确保选择 Kotlin 语言作为项目的主要语言，并且选择 Gradle 作为项目的构建工具。

步骤二：添加 Gradle Kotlin Convention Plugins

在项目根目录下的 build.gradle.kts 文件中，添加 Gradle Kotlin Convention Plugins：

plugins {
    id("org.jetbrains.kotlin.jvm") version "1.5.0"
    id("org.jetbrains.kotlin.plugin.serialization") version "1.5.0"
    id("org.jetbrains.kotlin.plugin.allopen") version "1.5.0"
    id("org.jetbrains.kotlin.plugin.noarg") version "1.5.0"
    id("com.github.ben-manes.versions") version "0.39.0"
    id("org.jlleitschuh.gradle.ktlint") version "10.2.0"
    id("org.gretty") version "3.0.2"
    id("org.jetbrains.kotlin.plugin.idea") version "1.5.0"
    id("org.jetbrains.kotlin.gradle.plugin") version "1.5.0"
    id("org.jetbrains.kotlinx.serialization") version "1.2.2"
    id("com.google.protobuf") version "0.8.17"
    id("io.spring.dependency-management") version "1.0.11.RELEASE"
}

这些插件包括了 Kotlin 相关的插件，以及其他常用的构建插件，例如 Gradle Versions Plugin 和 Gradle Ktlint Plugin。

步骤三：创建模块

在项目中创建两个模块：core 和 app。core 模块是项目的核心模块，它包含了一些通用的类和方法，可以被其他模块所依赖。app 模块是项目的应用程序模块，它依赖于 core 模块，并且包含了项目的主要业务逻辑和 UI 界面。

在项目根目录下，创建 core 模块的目录结构：

core
  src
    main
      kotlin
        com.example.core
          Example.kt

在 Example.kt 中，添加一些简单的代码：

package com.example.core

class Example {
    fun sayHello(): String = "Hello from core module!"
}

在项目根目录下，创建 app 模块的目录结构：

app
  src
    main
      kotlin
        com.example.app
          App.kt

在 App.kt 中，添加一些简单的代码：

package com.example.app

import com.example.core.Example

fun main() {
    val example = Example()
    println(example.sayHello())
}

步骤四：设置模块之间的依赖关系

在 core 模块的 build.gradle.kts 文件中，设置 core 模块的依赖关系：

dependencies {
    implementation(kotlin("stdlib-jdk8"))
}

在 app模块的 build.gradle.kts 文件中，设置 app 模块的依赖关系，并且引入 core 模块：

dependencies {
    implementation(project(":core"))
}

步骤五：共享构建逻辑

我们可以使用 buildSrc 目录来共享构建逻辑。在项目根目录下，创建 buildSrc 目录，并且添加一个名为 build.gradle.kts 的文件，用于设置构建逻辑的共享。

在 buildSrc 目录下，创建一个名为 Dependencies.kt 的文件，用于定义项目中使用的依赖项：

object Versions {
    const val kotlinVersion = "1.5.0"
    const val ktlintVersion = "0.42.1"
}

object Libs {
    const val kotlinStdlibJdk8 = "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${Versions.kotlinVersion}"
    const val ktlint = "com.pinterest:ktlint:${Versions.ktlintVersion}"
}

在 buildSrc 目录下，创建一个名为 CommonPlugins.kt 的文件，用于定义项目中使用的 Gradle 插件：

object CommonPlugins {
    const val kotlinJvm = "org.jetbrains.kotlin.jvm"
    const val kotlinSerialization = "org.jetbrains.kotlin.plugin.serialization"
    const val kotlinAllOpen = "org.jetbrains.kotlin.plugin.allopen"
    const val kotlinNoArg = "org.jetbrains.kotlin.plugin.noarg"
    const val versions = "com.github.ben-manes.versions"
    const val ktlint = "org.jlleitschuh.gradle.ktlint"
    const val gretty = "org.gretty"
    const val kotlinIdea = "org.jetbrains.kotlin.plugin.idea"
    const val kotlinGradlePlugin = "org.jetbrains.kotlin.gradle.plugin"
    const val kotlinSerializationPlugin = "org.jetbrains.kotlinx.serialization"
    const val protobufPlugin = "com.google.protobuf"
    const val springDependencyManagement = "io.spring.dependency-management"
}

在 buildSrc 目录下，创建一个名为 CommonConfig.kt 的文件，用于定义项目中使用的配置项：

object CommonConfig {
    const val kotlinJvmTarget = "1.8"
    const val ktlintVersion = Versions.ktlintVersion
}

在项目根目录下的 build.gradle.kts 文件中，添加以下代码，以引入 buildSrc 目录中的共享构建逻辑：

buildscript {
    dependencies {
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.0")
    }
    repositories {
        mavenCentral()
    }
}

plugins {
    kotlin(CommonPlugins.kotlinGradlePlugin) version Versions.kotlinVersion
}

apply(from = "buildSrc/CommonPlugins.kt")
apply(from = "buildSrc/Dependencies.kt")
apply(from = "buildSrc/CommonConfig.kt")

现在，我们可以在 core 和 app 模块的 build.gradle.kts 文件中，使用 Libs 和 CommonPlugins 中定义的依赖项和插件，例如：

plugins {
    id(CommonPlugins.kotlinJvm) version Versions.kotlinVersion
    id(CommonPlugins.kotlinSerialization) version Versions.kotlinVersion
    id(CommonPlugins.kotlinAllOpen) version Versions.kotlinVersion
    id(CommonPlugins.kotlinNoArg) version Versions.kotlinVersion
}

dependencies {
    implementation(Libs.kotlinStdlibJdk8)
}

tasks.withType<KotlinCompile> {
    kotlinOptions {
        jvmTarget = CommonConfig.kotlinJvmTarget
    }
}

步骤六：构建项目

现在，我们可以使用 Gradle 来构建项目了。在项目根目录下，执行以下命令：

$ ./gradlew build

Gradle 将会自动构建 core 模块和 app 模块，并且处理它们之间的依赖关系。如果一切顺利，构建过程将会成功，并且在 app/build/libs 目录下生成一个可执行的 JAR 文件。

步骤七：运行应用程序

最后，我们可以运行应用程序来测试它的功能。在项目根目录下，执行以下命令：

$ java -jar app/build/libs/app.jar

如果一切正常，应用程序将会输出以下内容：

Hello from core module!

这表明 app 模块成功地依赖于 core 模块，并且可以使用 core 模块中的类和方法。

总结

使用 Gradle Kotlin Convention Plugins 可以帮助我们更加轻松地构建模块化的 Kotlin 项目，并且可以实现构建逻辑的共享和重用。我们通过创建一个简单的模块化 Kotlin 项目来演示了如何使用 Gradle Kotlin Convention Plugins，并且介绍了如何设置模块之间的依赖关系和共享构建逻辑。希望这篇教程能够帮助您更好地理解 Gradle Kotlin Convention Plugins 的使用方法。

模块化是不断增长的项目的主要关注点，以解决许多问题：代码库大小、可扩展性、可读性、代码质量、代码重复等。我们通常通过隔离特征代码将项目拆分为面向功能的模块。更多内容可以参考Google Android团队也发布的应用程序模块化指南。 Go to

玖叶教程网

前端编程开发入门

用于模块化结构的 Gradle Kotlin（适用于模块开发的应用架构）