How to set up Kotlin's byte code version in Gradle project to Java 8?

In Kotlin project, what is a proper Gradle script to make sure my classes will be compiled to byte code ver 52 (Java 8)?

For some reason my classes are compiled as ver 50 (Java 6) even though I set up source and target compatibility. At least this is what Idea shows me when I open file from directory build/classes/... after building the project.

My current set up looks like this.

buildscript {
ext {
kotlinVersion = '1.0.5-2'
springBootVersion = '1.4.2.RELEASE'
}
repositories { mavenCentral() }
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
}
}


apply plugin: 'kotlin'
apply plugin: 'org.springframework.boot'


tasks.withType(JavaCompile) {
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
}


## I also tried this and it hasn't helped
#sourceCompatibility = 1.8
#targetCompatibility = 1.8


repositories { mavenCentral() }


dependencies {
compile("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")
compile('org.springframework.cloud:spring-cloud-starter-stream-rabbit')
}


dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:Camden.SR2" } }
57460 次浏览
小开

Kotlin 1.0 always produces Java 6 class files. Kotlin 1.1 will support generating Java 8 class files by passing -jvm-target 1.8 to the compiler. See

https://blog.jetbrains.com/kotlin/2016/07/first-glimpse-of-kotlin-1-1-coroutines-type-aliases-and-more/

for a discussion of Java 7/8 support.

小开

Kotlin 1.1 in Gradle. in console you have error about inline (your installed compiler is 1.0.x) If run gradle task in IntelliJ IDEA, your code compiled by kotlin 1.1 compiler

compileKotlin {
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8


kotlinOptions {
jvmTarget = "1.8"
apiVersion = "1.1"
languageVersion = "1.1"
}
}
小开

For anyone like me who use maven to build mixed code of kotlin and java in intellij , you need to set 

<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>

because maven build doesn't respect jvmTarget set in project setting.

小开
最佳答案

As Mark pointed out on Debop's answer, you have to configure both compileKotlin and compileTestKotlin. You can do it without duplication this way:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
kotlinOptions {
jvmTarget = "1.8"
}
}

For a pure Kotlin project, I don't think the options sourceCompatibility and targetCompatibility do anything, so you may be able to remove them.

Ref: https://kotlinlang.org/docs/reference/using-gradle.html#compiler-options

小开

In case someone uses gradle with kotlin-dsl instead of groovy:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile


// compile bytecode to java 8 (default is java 6)
tasks.withType<KotlinCompile> {
kotlinOptions.jvmTarget = "1.8"
}
小开

thx for seanf's anwser ,but if your DSL kotlin is 1.3.0: 

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class.java).all {
kotlinOptions {
jvmTarget = "1.8"
}
}
小开 
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile


// JVM target applied to all Kotlin tasks across all subprojects


// Kotlin DSL
tasks.withType<KotlinCompile> {
kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
}


//Groovy
tasks.withType(KotlinCompile) {
kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8
}
小开

In your build.gradle.kts:

    tasks {
val java = "11"


compileKotlin {
kotlinOptions { jvmTarget = java }
sourceCompatibility = java
}
}

Or like this:

tasks {
withType<KotlinCompile> { kotlinOptions { jvmTarget = "11" } }
}
小开

If you're getting an error like this: Cannot inline bytecode built with JVM target 1.8 into bytecode that is being built with JVM target 1.6. Please specify proper '-jvm-target' option.

Then, you can simply add the following in build.gradle (in Groovy) in order to tell kotlin to build using 1.8.

compileKotlin {
kotlinOptions {
jvmTarget = "1.8"
}
}
小开

Since gradle 6.7 there is so called java toolchain support in gradle which I find easiest to use.

It allows you to configure the JDK to use for this project and will even download the required version if needed.

All you need is a compatible JRE to start gradle and this block in your gradle build file:

kotlin dsl

kotlin {
jvmToolchain {
// for gradle kotlin plugin < 1.7:
(this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(17))
// for gradle kotlin plugin >= 1.7:
languageVersion.set(JavaLanguageVersion.of(17))
}
}

groovy dsl

kotlin {
jvmToolchain {
languageVersion.set(JavaLanguageVersion.of(17))
}
}

Note: This will update the java compiler settings as well, so you don't need anything else in your build.gradle.kts

Read more about this in the docs:

https://kotlinlang.org/docs/gradle.html#set-custom-jdk-home

https://docs.gradle.org/current/userguide/toolchains.html


提交答案