Gradle 在Kotlin多平台上使用渐变阴影

有没有办法用Kotlin多平台项目来设置Gradle？我使用的是一个多平台项目的“新”版本，在这个版本中，我的所有源代码集定义/依赖项都在一个文件中。这是我的构建文件：

buildscript {
    ext.ktor_version = "1.0.0-beta-3"

    repositories {
       maven { url "https://plugins.gradle.org/m2/"}
    }

    dependencies {
        classpath "com.github.jengelman.gradle.plugins:shadow:4.0.2"
    }
}


plugins {
    id 'kotlin-multiplatform' version '1.3.0'
    id 'com.github.johnrengelman.shadow' version '4.0.2'
    id 'application'
}

version = '1.0'
group = '[redacted]'
mainClassName = '[redacted]'

repositories {
    maven { url "https://dl.bintray.com/kotlin/exposed" }
    maven { url "https://dl.bintray.com/kotlin/ktor" }
    mavenCentral()
    jcenter()
}
kotlin {
    targets {
        fromPreset(presets.jvm, 'jvm')
        fromPreset(presets.js, 'js')
    }
    sourceSets {
        commonMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
            }
        }
        commonTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-common'
                implementation 'org.jetbrains.kotlin:kotlin-test-annotations-common'
            }
        }
        jvmMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
                implementation 'org.jetbrains.exposed:exposed:0.11.2'
                implementation "org.mindrot:jbcrypt:0.4"
                implementation "org.slf4j:slf4j-simple:1.8.0-beta2"
                implementation "io.ktor:ktor-server-netty:$ktor_version"
                implementation "io.ktor:ktor-jackson:$ktor_version"
                implementation "mysql:mysql-connector-java:8.0.13"
            }
        }
        jvmTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test'
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
            }
        }
        jsMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-js'
            }
        }
        jsTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-js'
            }
        }
    }
}

shadowJar {
    baseName = '[redacted]'
    version = 1.0
}

尝试使用它，我得到了一个JAR文件的悲惨结果，只有META-INF（304字节）。老实说，我不知道从哪里开始，这让我思考和困惑了好几个小时。任何人的帮助都将不胜感激

我的项目框架：

├── build.gradle
├── gradle.properties
├── settings.gradle
└── src
    ├── commonMain
    │   └── kotlin
    │       ├── PasswordValidator.kt
    │       └── Responses.kt
    └── jvmMain
        └── kotlin
            └── XXX
                └── XXXXXX
                    └── ticketing
                        ├── Auth.kt
                        ├── Registration.kt
                        ├── Server.kt
                        ├── requests
                        │   ├── Auth.kt
                        │   ├── Register.kt
                        │   └── account
                        │       ├── Close.kt
                        │       ├── List.kt
                        │       ├── ModifyPassword.kt
                        │       ├── New.kt
                        │       └── SetAdmin.kt
                        └── services
                            ├── AsyncHandler.kt
                            ├── Exception.kt
                            ├── RateLimiter.kt
                            └── Token.kt

---

实际上，你不需要阴影。 只需在kotlin>targets（build.gradle）块中添加以下代码

---

build/libs

中生成的Jar文件将在清单中包含指定的

Main类。所有必需的类也已经存在。生成的jar已经可以使用了（别忘了在您使用jar的项目中指定外部依赖项——我设法让它在GradleJava项目上工作）
 我确实有一个解决方案，可以使用
kotlin多平台
插件版本
1.3.31
和一个通过IntelliJ
New project/kotlin/JS Client和JVM Server | Gradle
选项生成的项目

buildscript {
  repositories {
    jcenter()
  }
}

plugins {
  id 'com.github.johnrengelman.shadow' version '5.0.0'
  id 'kotlin-multiplatform' version '1.3.31'
}

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

repositories {
  jcenter()
  maven { url "https://dl.bintray.com/kotlin/ktor" }
  mavenCentral()
}
def ktor_version = '1.2.1'
def logback_version = '1.2.3'

kotlin {
  jvm()
  js() {
    compilations.all {
      kotlinOptions {
        languageVersion = "1.3"
        moduleKind = "umd"
        sourceMap = true
        metaInfo = true
      }
    }
  }
  sourceSets {
    commonMain {
      dependencies {
        implementation kotlin('stdlib-common')
      }
    }
    commonTest {
      dependencies {
        implementation kotlin('test-common')
        implementation kotlin('test-annotations-common')
      }
    }
    jvmMain {
      dependencies {
        implementation kotlin('stdlib-jdk8')
        implementation "io.ktor:ktor-server-netty:$ktor_version"
        implementation "io.ktor:ktor-html-builder:$ktor_version"
        implementation "io.ktor:ktor-jackson:$ktor_version"
        implementation "ch.qos.logback:logback-classic:$logback_version"
      }
    }
    jvmTest {
      dependencies {
        implementation kotlin('test')
        implementation kotlin('test-junit')
        implementation "io.ktor:ktor-server-test-host:$ktor_version"
      }
    }
    jsMain {
      dependencies {
        implementation kotlin('stdlib-js')
      }
    }
    jsTest {
      dependencies {
        implementation kotlin('test-js')
      }
    }
  }
}

def webFolder = new File(project.buildDir, "web")
def jsCompilations = kotlin.targets.js.compilations

task populateWebFolder(dependsOn: [jsMainClasses]) {
  doLast {
    copy {
      from jsCompilations.main.output
      from kotlin.sourceSets.jsMain.resources.srcDirs
      jsCompilations.test.runtimeDependencyFiles.each {
        if (it.exists() && !it.isDirectory()) {
          from zipTree(it.absolutePath).matching { include '*.js' }
        }
      }
      into webFolder
    }
  }
}

jsJar.dependsOn(populateWebFolder)

def mainServerClassName = "org.pongasoft.jamba.quickstart.server.be.ServerKt"

task run(type: JavaExec, dependsOn: [jvmMainClasses, jsJar]) {
  main = mainServerClassName
  ignoreExitValue = true
  classpath {
    [
        kotlin.targets.jvm.compilations.main.output.allOutputs.files,
        configurations.jvmRuntimeClasspath,
    ]
  }
  args = ["-P:org.pongasoft.jamba.quickstart.server.staticWebDir=${webFolder.canonicalPath}"]
}

task shadowJar(type: ShadowJar, dependsOn: [jvmJar]) {
  from jvmJar.archiveFile
  configurations = [project.configurations.jvmRuntimeClasspath]
  manifest {
      attributes 'Main-Class': mainServerClassName
  }
}

我认为，根据文件，它不起作用的主要原因是：

From:，Shadow是一个反应式插件。这意味着应用阴影本身不会对项目执行任何配置。相反，Shadow的反应是，这意味着对于大多数用户来说，必须显式地应用java或groovy插件才能达到预期的效果

因此，kotlin multiplatform插件采用非传统的设置，它无法开箱即用。因此，诀窍是定义一个
ShadowJar
任务，该任务依赖于
jvmJar
，并使用工件作为其
（
jvmJar.archiveFile
）和
project.configurations.jvmRuntimeClasspath
配置中的
，以包含所有运行时依赖项。这也是为清单定义
主类
条目的地方

请注意，此版本没有绑定编译的javascript部分生成的静态资源。
谢谢！很高兴看到使用外部插件来实现这一点是没有必要的，这是行不通的<代码>id“kotlin multiplatform”版本“1.3.21”
这会编译，但不包括kotlin依赖项，我无法运行
java-jar…
True。它不能完全正常工作。您必须在IntelliJ中创建java项目，将生成的jar文件添加为依赖项，然后在build.gradle中指定所需的依赖项（jar仅包含您的代码）。我不知道为什么这会被标记为“良好”响应，因为它根本不起作用。jvmJar目标不包括任何kotlin依赖项，这就是您首先需要使用shadowJar的原因（由：java.lang.ClassNotFoundException:io.ktor.application.application引起）。
buildscript {
  repositories {
    jcenter()
  }
}

plugins {
  id 'com.github.johnrengelman.shadow' version '5.0.0'
  id 'kotlin-multiplatform' version '1.3.31'
}

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

repositories {
  jcenter()
  maven { url "https://dl.bintray.com/kotlin/ktor" }
  mavenCentral()
}
def ktor_version = '1.2.1'
def logback_version = '1.2.3'

kotlin {
  jvm()
  js() {
    compilations.all {
      kotlinOptions {
        languageVersion = "1.3"
        moduleKind = "umd"
        sourceMap = true
        metaInfo = true
      }
    }
  }
  sourceSets {
    commonMain {
      dependencies {
        implementation kotlin('stdlib-common')
      }
    }
    commonTest {
      dependencies {
        implementation kotlin('test-common')
        implementation kotlin('test-annotations-common')
      }
    }
    jvmMain {
      dependencies {
        implementation kotlin('stdlib-jdk8')
        implementation "io.ktor:ktor-server-netty:$ktor_version"
        implementation "io.ktor:ktor-html-builder:$ktor_version"
        implementation "io.ktor:ktor-jackson:$ktor_version"
        implementation "ch.qos.logback:logback-classic:$logback_version"
      }
    }
    jvmTest {
      dependencies {
        implementation kotlin('test')
        implementation kotlin('test-junit')
        implementation "io.ktor:ktor-server-test-host:$ktor_version"
      }
    }
    jsMain {
      dependencies {
        implementation kotlin('stdlib-js')
      }
    }
    jsTest {
      dependencies {
        implementation kotlin('test-js')
      }
    }
  }
}

def webFolder = new File(project.buildDir, "web")
def jsCompilations = kotlin.targets.js.compilations

task populateWebFolder(dependsOn: [jsMainClasses]) {
  doLast {
    copy {
      from jsCompilations.main.output
      from kotlin.sourceSets.jsMain.resources.srcDirs
      jsCompilations.test.runtimeDependencyFiles.each {
        if (it.exists() && !it.isDirectory()) {
          from zipTree(it.absolutePath).matching { include '*.js' }
        }
      }
      into webFolder
    }
  }
}

jsJar.dependsOn(populateWebFolder)

def mainServerClassName = "org.pongasoft.jamba.quickstart.server.be.ServerKt"

task run(type: JavaExec, dependsOn: [jvmMainClasses, jsJar]) {
  main = mainServerClassName
  ignoreExitValue = true
  classpath {
    [
        kotlin.targets.jvm.compilations.main.output.allOutputs.files,
        configurations.jvmRuntimeClasspath,
    ]
  }
  args = ["-P:org.pongasoft.jamba.quickstart.server.staticWebDir=${webFolder.canonicalPath}"]
}

task shadowJar(type: ShadowJar, dependsOn: [jvmJar]) {
  from jvmJar.archiveFile
  configurations = [project.configurations.jvmRuntimeClasspath]
  manifest {
      attributes 'Main-Class': mainServerClassName
  }
}