如何在Kotlin版Gradle中按组管理子项目并配置公共依赖？

针对你的需求，推荐通过分组映射+批量配置的方式实现，无需逐个指定子项目，后续维护分组或子项目时只需修改映射关系即可。

实现思路 #

1. 定义「分组-子项目」的对应关系，明确每个子项目归属哪些分组；
2. 定义「分组-依赖/配置」的对应关系，把每个分组需要的公共依赖、插件或编译配置封装好；
3. 遍历所有子项目，自动匹配其所属分组并应用对应配置。

基础版实现（仅配置依赖） #

在根项目的build.gradle.kts中添加以下代码：

// 1. 定义分组与子项目的映射关系
val projectGroupMapping = mapOf(
    "Foo" to setOf("A", "B", "D"),
    "Bar" to setOf("B", "C"),
    "Baz" to setOf("C", "D", "E")
)

// 2. 定义各分组对应的公共依赖
val groupDependencyMapping = mapOf(
    "Foo" to listOf(
        "com.example:foo-core:1.0.0",
        "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    ),
    "Bar" to listOf(
        "com.example:bar-web:2.3.0",
        "org.springframework.boot:spring-boot-starter-web"
    ),
    "Baz" to listOf(
        "com.example:baz-reactive:4.5.0",
        "io.reactivex.rxjava3:rxjava:3.1.5"
    )
)

// 3. 为子项目自动匹配分组并应用依赖
subprojects {
    // 获取当前子项目所属的所有分组
    val assignedGroups = projectGroupMapping.filterValues { it.contains(project.name) }.keys
    assignedGroups.forEach { group ->
        dependencies {
            groupDependencyMapping[group]?.forEach { dep ->
                implementation(dep)
            }
        }
    }
}

进阶版实现（支持全量配置） #

如果分组不仅需要配置依赖，还要统一管理插件、编译参数、测试配置等，可以把分组逻辑封装成扩展函数，更易于维护：

// 1. 为每个分组定义专属配置函数
fun Project.configureFooGroup() {
    // 应用插件
    plugins.apply("kotlin-jvm")
    
    // 配置依赖
    dependencies {
        implementation("com.example:foo-core:1.0.0")
        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
        testImplementation("junit:junit:4.13.2")
    }
    
    // 配置编译选项
    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
        kotlinOptions.jvmTarget = "17"
    }
}

fun Project.configureBarGroup() {
    plugins.apply("org.springframework.boot")
    plugins.apply("io.spring.dependency-management")
    
    dependencies {
        implementation("com.example:bar-web:2.3.0")
        implementation("org.springframework.boot:spring-boot-starter-web")
        testImplementation("org.springframework.boot:spring-boot-starter-test")
    }
}

fun Project.configureBazGroup() {
    plugins.apply("kotlin-jvm")
    
    dependencies {
        implementation("com.example:baz-reactive:4.5.0")
        implementation("io.reactivex.rxjava3:rxjava:3.1.5")
        testImplementation("io.reactivex.rxjava3:rxjava-test:3.1.5")
    }
}

// 2. 定义分组与配置函数的映射
val groupConfiguratorMapping = mapOf(
    "Foo" to Project::configureFooGroup,
    "Bar" to Project::configureBarGroup,
    "Baz" to Project::configureBazGroup
)

// 3. 定义分组与子项目的映射
val projectGroupMapping = mapOf(
    "Foo" to setOf("A", "B", "D"),
    "Bar" to setOf("B", "C"),
    "Baz" to setOf("C", "D", "E")
)

// 4. 批量应用配置
subprojects {
    projectGroupMapping.filterValues { it.contains(project.name) }.keys.forEach { group ->
        groupConfiguratorMapping[group]?.invoke(this)
    }
}

注意事项 #

• 确保子项目名称与projectGroupMapping中的名称完全一致，且已在settings.gradle.kts中正确include；
• 若需要调整分组或子项目归属，只需修改对应的映射关系，无需修改大量重复配置；
• 这种方式基于Gradle的惰性配置机制，不会额外增加构建开销。

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