Ktor+Android全栈项目Gradle多模块及公共模块搭建咨询

一、调整项目目录结构 #

先整理出最终的项目层级，将原有项目迁移到父项目下，新增KMP共享模块：

root-project/
├── gradle/
│   ├── wrapper/
│   │   ├── gradle-wrapper.jar
│   │   └── gradle-wrapper.properties
│   └── libs.versions.toml
├── frontend/          # 原Android Compose项目，删除自身gradle文件夹
│   ├── app/
│   └── ...（保留原项目其他文件）
├── backend/           # 原Ktor后端项目，删除自身gradle文件夹
│   ├── src/
│   └── ...（保留原项目其他文件）
├── common/            # 新建KMP共享模块
│   ├── src/
│   │   ├── commonMain/
│   │   │   ├── kotlin/
│   │   │   │   └── com/yourdomain/common/model/  # 存放共享序列化数据类
│   │   │   └── resources/
│   │   └── commonTest/
│   └── build.gradle.kts
├── build.gradle.kts   # 父项目构建脚本
├── settings.gradle.kts
└── gradlew/gradlew.bat

二、统一Gradle Wrapper版本 #

1. 选择兼容Android和Ktor的Gradle版本（例如8.5+，对应Android Gradle Plugin 8.2+），在父项目根目录执行命令生成统一Wrapper：

./gradlew wrapper --gradle-version 8.5 --distribution-type all

2. 删除frontend和backend各自的gradle文件夹，强制所有子模块使用父项目的Wrapper。

三、父项目核心配置 #

1. settings.gradle.kts（声明子模块） #

rootProject.name = "YourRootProjectName"

// 根据实际子模块路径调整，比如frontend如果是单模块直接写":frontend"
include(":frontend:app")
include(":backend")
include(":common")

2. build.gradle.kts（父项目全局配置） #

统一插件版本管理，配置子模块通用仓库：

plugins {
    // 声明插件版本，子模块通过id引用即可，无需重复指定版本
    id("com.android.application") version libs.plugins.android.application apply false
    id("org.jetbrains.kotlin.android") version libs.plugins.kotlin.android apply false
    id("io.ktor.plugin") version libs.plugins.ktor apply false
    id("org.jetbrains.kotlin.multiplatform") version libs.plugins.kotlin.multiplatform apply false
    id("org.jetbrains.kotlin.plugin.serialization") version libs.plugins.kotlin.serialization apply false
}

// 给所有子模块统一配置仓库
subprojects {
    repositories {
        google()
        mavenCentral()
    }
}

3. gradle/libs.versions.toml（统一依赖版本） #

合并原两个项目的版本配置，集中管理所有依赖版本：

[versions]
kotlin = "1.9.20"
androidGradlePlugin = "8.2.2"
ktor = "2.3.7"
kotlinxSerialization = "1.6.3"
composeBom = "2023.10.01"

[plugins]
android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
ktor = { id = "io.ktor.plugin", version.ref = "ktor" }
kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

[libraries]
# 公共序列化依赖
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerialization" }
# Android Compose相关
compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" }
# Ktor服务端/客户端依赖
ktor-server-core = { module = "io.ktor:ktor-server-core-jvm", version.ref = "ktor" }
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }

四、KMP公共模块配置（common/build.gradle.kts） #

配置支持Android和JVM后端的共享模块，专门存放跨端复用的序列化数据类：

plugins {
    id("org.jetbrains.kotlin.multiplatform")
    id("org.jetbrains.kotlin.plugin.serialization")
}

kotlin {
    // 声明目标平台：适配Android和后端JVM
    androidTarget {
        compilations.all {
            kotlinOptions {
                jvmTarget = "1.8"
            }
        }
    }
    jvm("backend") {
        compilations.all {
            kotlinOptions {
                jvmTarget = "17" // 匹配后端项目的JVM版本
            }
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(libs.kotlinx.serialization.json)
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
            }
        }
        val androidMain by getting
        val backendMain by getting
    }
}

在common/src/commonMain/kotlin/com/yourdomain/common/model/下创建共享数据类示例：

package com.yourdomain.common.model

import kotlinx.serialization.Serializable

@Serializable
data class User(
    val id: String,
    val name: String,
    val email: String
)

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    val data: T?,
    val message: String?
)

五、子模块依赖公共模块 #

1. Android前端模块（frontend/app/build.gradle.kts） #

添加对common模块的依赖：

dependencies {
    // 保留原有依赖，新增共享模块依赖
    implementation(project(":common"))
    // Ktor客户端序列化依赖（按需添加）
    implementation(libs.ktor.client.serialization)
}

2. Ktor后端模块（backend/build.gradle.kts） #

添加对common模块的依赖：

dependencies {
    // 保留原有依赖，新增共享模块依赖
    implementation(project(":common"))
    // Ktor服务端序列化依赖（按需添加）
    implementation(libs.ktor.server.serialization)
}

六、注意事项 #

• 子模块中所有插件和依赖版本，必须通过父项目的libs.versions.toml引用，禁止硬编码版本号。
• 原项目中的自定义Gradle配置（如签名、打包规则），需迁移到对应子模块中。
• 同步项目后，测试数据类在两端的序列化/反序列化逻辑是否正常。

内容的提问来源于stack exchange，提问作者Chaoz