Toolchains for JVM projects

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(11))
    }
}

tasks.withType(JavaCompile).configureEach {
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
    }
}
task('testsOn14', type: Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(14)
    }
}

tasks.withType<JavaCompile>().configureEach {
    javaCompiler.set(javaToolchains.compilerFor {
        languageVersion.set(JavaLanguageVersion.of(8))
    })
}

tasks.register<Test>("testsOn14") {
    javaLauncher.set(javaToolchains.launcherFor {
        languageVersion.set(JavaLanguageVersion.of(14))
    })
}

task('runOn14', type: JavaExec) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(14)
    }

    classpath = sourceSets.main.runtimeClasspath
    mainClass = application.mainClass
}

tasks.register<JavaExec>("runOn14") {
    javaLauncher.set(javaToolchains.launcherFor {
        languageVersion.set(JavaLanguageVersion.of(14))
    })

    classpath = sourceSets["main"].runtimeClasspath
    mainClass.set(application.mainClass)
}

import javax.inject.Inject;

abstract class CustomTaskUsingToolchains extends DefaultTask {

    @Nested
    abstract Property<JavaLauncher> getLauncher()

    @Inject
    CustomTaskUsingToolchains() {
        // Access the default toolchain
        def toolchain = project.getExtensions().getByType(JavaPluginExtension.class).toolchain

        // acquire a provider that returns the launcher for the toolchain
        JavaToolchainService service = project.getExtensions().getByType(JavaToolchainService.class)
        Provider<JavaLauncher> defaultLauncher = service.launcherFor(toolchain);

        // use it as our default for the property
        launcher.convention(defaultLauncher);
    }

    @TaskAction
    def showConfiguredToolchain() {
        println launcher.get().executablePath
        println launcher.get().metadata.installationPath
    }
}

plugins {
    id 'java'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(8)
    }
}

tasks.register('showDefaultToolchain', CustomTaskUsingToolchains)

tasks.register('showCustomToolchain', CustomTaskUsingToolchains) {
    launcher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(16)
    }
}

import javax.inject.Inject;

abstract class CustomTaskUsingToolchains : DefaultTask {

    @get:Nested
    abstract val launcher: Property<JavaLauncher>

    @Inject
    constructor() {
        // Access the default toolchain
        val toolchain = project.extensions.getByType<JavaPluginExtension>().toolchain

        // acquire a provider that returns the launcher for the toolchain
        val service = project.extensions.getByType<JavaToolchainService>()
        val defaultLauncher = service.launcherFor(toolchain)

        // use it as our default for the property
        launcher.convention(defaultLauncher);
    }

    @TaskAction
    fun showConfiguredToolchain() {
        println(launcher.get().executablePath)
        println(launcher.get().metadata.installationPath)
    }
}

plugins {
    java
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(8))
    }
}

tasks.register<CustomTaskUsingToolchains>("showDefaultToolchain")

tasks.register<CustomTaskUsingToolchains>("showCustomToolchain") {
    launcher.set(javaToolchains.launcherFor {
        languageVersion.set(JavaLanguageVersion.of(16))
    })
}