使用Gradle Application插件，如何简化Kotlin主程序代码（无需伴生对象与@JvmStatic）

Great question! Let's break this down—Kotlin gives you a much cleaner way to handle entry points without relying on companion object or @JvmStatic, and it plays perfectly with the Gradle Application plugin. Here's how to do it:

1. Use a Top-Level main Function (No Companion Object Needed) #

Kotlin allows you to define functions directly at the file level (top-level), which eliminates the need to wrap your main method inside a class or companion object. This is the most idiomatic and clean approach for Kotlin entry points.

For example, create a file like src/main/kotlin/com/example/MyApplication.kt with:

// No class, no companion object—just a top-level function
fun main(args: Array<String>) {
    // Your application logic here
    println("Running my Kotlin app with Gradle!")
}

Bonus: Even Shorter Main Function #

If you don't need to process command-line arguments, you can omit the parameter entirely—Kotlin will automatically generate the correct Java-compatible main method signature:

fun main() {
    println("No arguments? No problem!")
}

2. Configure Gradle Application Plugin to Recognize the Top-Level Function #

When you define a top-level main function, the Kotlin compiler generates a synthetic class with a name matching your file, appended with Kt. For our example above, the class would be com.example.MyApplicationKt.

You just need to tell the Gradle Application plugin about this class in your build script:

For Kotlin DSL (build.gradle.kts) #

plugins {
    application
    kotlin("jvm") version "1.9.20" // Use your project's Kotlin version
}

application {
    // Point to the synthetic class generated for your top-level main
    mainClass.set("com.example.MyApplicationKt")
}

For Groovy DSL (build.gradle) #

plugins {
    id 'application'
    id 'org.jetbrains.kotlin.jvm' version '1.9.20'
}

application {
    mainClass = 'com.example.MyApplicationKt'
}

Why This Works #

The synthetic MyApplicationKt class contains a static main method that adheres to Java's entry point requirements, so the Gradle Application plugin can package your app into an executable JAR, or generate run scripts (like ./gradlew run) just like it would with a Java main class.

This approach keeps your Kotlin code concise, avoids boilerplate from companion object and @JvmStatic, and follows Kotlin's idiomatic practices.

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