如何使用gradle kotlin脚本创建胖罐

Question

正如标题所述,我想知道如何修改它gradle.build.kts以便创建一个独特jar的所有依赖项(包括kotlin lib)的任务.

我在Groovy中找到了这个示例:

//create a single Jar with all dependencies
task fatJar(type: Jar) {
    manifest {
        attributes 'Implementation-Title': 'Gradle Jar File Example',
            'Implementation-Version': version,
            'Main-Class': 'com.mkyong.DateUtils'
    }
    baseName = project.name + '-all'
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    with jar
}

但我不知道如何在kotlin中写出来,除了:

task("fatJar") {

}

Answer 1

这里有 4 种方法可以做到这一点。请注意，前 3 个方法修改了JarGradle 的现有任务。

方法一：将库文件放在结果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 要求我们对属性使用相对 URL Class-Path。所以，我们不能使用Gradle依赖的绝对路径（这也容易被改变并且在其他系统上不可用）。如果您想使用绝对路径，也许这个解决方法会起作用。

使用以下命令创建 JAR：

./gradlew jar

默认情况下，结果 JAR 将在build/libs/目录中创建。

创建 JAR 后，将库 JAR 复制到放置结果 JAR 的libs/子目录中。确保您的库 JAR 文件的文件名中不包含空格（其文件名应与${file.name}任务中上述变量指定的文件名匹配）。

方法 2：将库嵌入到结果 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 与之前的方法完全相同。

方法 3：使用Shadow 插件（创建 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"] = "com.example.MyMainClass"
}

使用以下命令创建 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

上述解决方案经过以下测试：

• 爪哇17
• Gradle 7.1（使用 Kotlin 1.4.31 进行.kts构建脚本）

有关创建 uber (fat) JAR 的信息，请参阅官方Gradle 文档。
有关清单的更多信息，请参阅Oracle Java 文档：使用清单文件。
有关 和 之间的区别，请tasks.create()参阅tasks.register()这篇文章。

您的资源文件将自动包含在 JAR 文件中（假设它们放置在类路径：/src/main/resources/目录中或在构建文件中设置为资源根目录的任何自定义目录中）。以下是如何在代码中访问资源文件（请注意/名称开头的 ）：

• 科特林

  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()
  

• 爪哇

  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"));
  

Answer 2

这是一个不使用插件的版本,更像是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)
    }
}

这里也解释了

Answer 3

以下是从 Gradle 6.5.1、Kotlin/Kotlin-Multiplatform 1.3.72 开始使用 build.gradle.kts 文件而不使用额外插件的方法，这对于多平台来说似乎是不必要且有问题的；

注意：实际上，据我所知，很少有插件可以很好地与多平台插件配合使用，这就是为什么我怀疑它的设计理念本身如此冗长。恕我直言，它实际上相当优雅，但不够灵活或没有足够的文档记录，因此即使没有额外的插件，设置也需要大量的反复试验。

希望这对其他人有帮助。

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)
                }
            }
        }
    }
}

Answer 4

你可以使用ShadowJar 插件来构建一个胖罐子：

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 日）。