下面是一个不使用插件的版本，更像是Groovy版本。

import org.gradle.jvm.tasks.Jar
val fatJar = task("fatJar", type = Jar::class) {
    baseName = "${project.name}-fat"
    manifest {
        attributes["Implementation-Title"] = "Gradle Jar File Example"
        attributes["Implementation-Version"] = version
        attributes["Main-Class"] = "com.mkyong.DateUtils"
    }
    from(configurations.runtime.map({ if (it.isDirectory) it else zipTree(it) }))
    with(tasks["jar"] as CopySpec)
}
tasks {
    "build" {
        dependsOn(fatJar)
    }
}

Also explained here
一些评论者指出，这在较新的Gradle版本中不再起作用。

import org.gradle.jvm.tasks.Jar
val fatJar = task("fatJar", type = Jar::class) {
    baseName = "${project.name}-fat"
    manifest {
        attributes["Implementation-Title"] = "Gradle Jar File Example"
        attributes["Implementation-Version"] = version
        attributes["Main-Class"] = "com.mkyong.DateUtils"
    }
    from(configurations.runtimeClasspath.get().map({ if (it.isDirectory) it else zipTree(it) }))
    with(tasks.jar.get() as CopySpec)
}
tasks {
    "build" {
        dependsOn(fatJar)
    }
}

请注意configurations.runtimeClasspath.get()和with(tasks.jar.get() as CopySpec)的差异。

请注意，前3种方法修改Gradle现有的Jar任务。

方法1：将库文件放在结果JAR旁边

此方法不需要application或任何其他插件。

tasks.jar {
    manifest.attributes["Main-Class"] = "com.example.MyMainClass"
    manifest.attributes["Class-Path"] = configurations
        .runtimeClasspath
        .get()
        .joinToString(separator = " ") { file ->
            "libs/${file.name}"
        }
}

请注意，Java要求我们对Class-Path属性使用相对URL。因此，我们不能使用Gradle依赖项的绝对路径（这也容易被更改，并且在其他系统上不可用）。如果您想使用绝对路径，也许this workaround可以。
使用以下命令创建JAR：

./gradlew jar

默认情况下，生成的JAR将在 build/libs/ 目录中创建。
创建JAR后，将库JAR复制到放置结果JAR的 libs/ 子目录中。确保库JAR文件的文件名中不包含空格（它们的文件名应与上面任务中的${file.name}变量指定的文件名匹配）。

方法二：在结果JAR文件（fat或uber JAR）中嵌入库

此方法也不需要任何Gradle插件。

tasks.jar {
    manifest.attributes["Main-Class"] = "com.example.MyMainClass"
    val dependencies = configurations
        .runtimeClasspath
        .get()
        .map(::zipTree) // OR .map { zipTree(it) }
    from(dependencies)
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

创建JAR与前面的方法完全相同。

方法三：使用Shadow plugin（创建一个fat或uber JAR）

plugins {
    id("com.github.johnrengelman.shadow") version "6.0.0"
}
// Shadow task depends on Jar task, so these configs are reflected for Shadow as well
tasks.jar {
    manifest.attributes["Main-Class"] = "org.example.MainKt"
}

使用以下命令创建JAR：

./gradlew shadowJar

有关配置插件的更多信息，请参见Shadow文档。

方法四：创建新任务（而不是修改Jar任务）

tasks.create("MyFatJar", Jar::class) {
    group = "my tasks" // OR, for example, "build"
    description = "Creates a self-contained fat JAR of the application that can be run."
    manifest.attributes["Main-Class"] = "com.example.MyMainClass"
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    val dependencies = configurations
        .runtimeClasspath
        .get()
        .map(::zipTree)
    from(dependencies)
    with(tasks.jar.get())
}

运行创建的JAR

java -jar my-artifact.jar

使用以下试剂检测上述溶液：

• Java 17语言
• Gradle 7.1（使用Kotlin1.4.31进行 .kts 构建脚本）

请参阅官方Gradle文档以了解如何创建超级（胖）JAR。
如需信息清单的详细信息，请参阅Oracle Java Documentation: Working with Manifest files。
有关tasks.create()和tasks.register()之间的差异，请参见this post。
请注意，您的resource files will be included in the JAR file automatically（假设它们被放置在 /src/main/resources/ 目录或任何在构建文件中设置为资源根目录的自定义目录中）。要访问应用程序中的资源文件，请使用以下代码（注意名称开头的/）：

• Kotlin

val vegetables = MyClass::class.java.getResource("/vegetables.txt").readText()
// Alternative ways:
// val vegetables = object{}.javaClass.getResource("/vegetables.txt").readText()
// val vegetables = MyClass::class.java.getResourceAsStream("/vegetables.txt").reader().readText()
// val vegetables = object{}.javaClass.getResourceAsStream("/vegetables.txt").reader().readText()

• Java语言

var stream = MyClass.class.getResource("/vegetables.txt").openStream();
// OR var stream = MyClass.class.getResourceAsStream("/vegetables.txt");
var reader = new BufferedReader(new InputStreamReader(stream));
var vegetables = reader.lines().collect(Collectors.joining("\n"));

以下是从Gradle 6.5.1，Kotlin/Kotlin-Multiplatform 1.3.72开始的实现方法，使用一个build.gradle.kts文件，而不使用额外的插件，这看起来确实是不必要的，而且在多平台环境下会出现问题;
注意：在现实中，很少有插件能很好地与多平台插件一起工作，这就是为什么我怀疑它的设计理念是如此冗长。它实际上是相当优雅的IMHO，但不够灵活或文档化，所以它需要大量的试验和错误来安装，即使没有额外的插件。
希望这对其他人有帮助。

kotlin {
    jvm {
        compilations {
            val main = getByName("main")
            tasks {
                register<Jar>("fatJar") {
                    group = "application"
                    manifest {
                        attributes["Implementation-Title"] = "Gradle Jar File Example"
                        attributes["Implementation-Version"] = archiveVersion
                        attributes["Main-Class"] = "[[mainClassPath]]"
                    }
                    archiveBaseName.set("${project.name}-fat")
                    from(main.output.classesDirs, main.compileDependencyFiles)
                    with(jar.get() as CopySpec)
                }
            }
        }
    }
}

您可以使用ShadowJar plugin构建一个fat jar：

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
buildscript {
    repositories {
        mavenCentral()
        gradleScriptKotlin()
    }
    dependencies {
        classpath(kotlinModule("gradle-plugin"))
        classpath("com.github.jengelman.gradle.plugins:shadow:1.2.3")
    }
}
apply {
    plugin("kotlin")
    plugin("com.github.johnrengelman.shadow")
}
repositories {
    mavenCentral()
}
val shadowJar: ShadowJar by tasks
shadowJar.apply {
    manifest.attributes.apply {
        put("Implementation-Title", "Gradle Jar File Example")
        put("Implementation-Version" version)
        put("Main-Class", "com.mkyong.DateUtils")
    }
    baseName = project.name + "-all"
}

只需使用“shadowJar”运行任务。
注意：这假设您使用的是GSK 0.7.0（最新版本截至2017年2月13日）。