Allow the project to be built with Java 16

See gh-25171

buildSrc/src/main/java/org/springframework/boot/build/JavaConventions.java

@@ -16,14 +16,12 @@
 
 package org.springframework.boot.build;
 
-import java.io.File;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
-import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 import io.spring.javaformat.gradle.FormatTask;
@@ -49,6 +47,7 @@ import org.gradle.testretry.TestRetryTaskExtension;
 
 import org.springframework.boot.build.optional.OptionalDependenciesPlugin;
 import org.springframework.boot.build.testing.TestFailuresPlugin;
+import org.springframework.boot.build.toolchain.ToolchainPlugin;
 
 /**
  * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
@@ -103,6 +102,7 @@ class JavaConventions {
 			configureTestConventions(project);
 			configureJarManifestConventions(project);
 			configureDependencyManagement(project);
+			configureToolchain(project);
 		});
 	}
 
@@ -145,7 +145,6 @@ class JavaConventions {
 
 	private void configureTestConventions(Project project) {
 		project.getTasks().withType(Test.class, (test) -> {
-			withOptionalBuildJavaHome(project, (javaHome) -> test.setExecutable(javaHome + "/bin/java"));
 			test.useJUnitPlatform();
 			test.setMaxHeapSize("1024M");
 		});
@@ -165,38 +164,25 @@ class JavaConventions {
 	}
 
 	private void configureJavadocConventions(Project project) {
-		project.getTasks().withType(Javadoc.class, (javadoc) -> {
-			javadoc.getOptions().source("1.8").encoding("UTF-8");
-			withOptionalBuildJavaHome(project, (javaHome) -> javadoc.setExecutable(javaHome + "/bin/javadoc"));
-		});
+		project.getTasks().withType(Javadoc.class, (javadoc) -> javadoc.getOptions().source("1.8").encoding("UTF-8"));
 	}
 
 	private void configureJavaCompileConventions(Project project) {
 		project.getTasks().withType(JavaCompile.class, (compile) -> {
 			compile.getOptions().setEncoding("UTF-8");
-			withOptionalBuildJavaHome(project, (javaHome) -> {
-				compile.getOptions().setFork(true);
-				compile.getOptions().getForkOptions().setJavaHome(new File(javaHome));
-				compile.getOptions().getForkOptions().setExecutable(javaHome + "/bin/javac");
-			});
+			compile.setSourceCompatibility("1.8");
+			compile.setTargetCompatibility("1.8");
 			List<String> args = compile.getOptions().getCompilerArgs();
 			if (!args.contains("-parameters")) {
 				args.add("-parameters");
 			}
-			if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
+			if (!project.hasProperty("toolchainVersion") && JavaVersion.current() == JavaVersion.VERSION_1_8) {
 				args.addAll(Arrays.asList("-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes",
 						"-Xlint:varargs"));
 			}
 		});
 	}
 
-	private void withOptionalBuildJavaHome(Project project, Consumer<String> consumer) {
-		String buildJavaHome = (String) project.findProperty("buildJavaHome");
-		if (buildJavaHome != null && !buildJavaHome.isEmpty()) {
-			consumer.accept(buildJavaHome);
-		}
-	}
-
 	private void configureSpringJavaFormat(Project project) {
 		project.getPlugins().apply(SpringJavaFormatPlugin.class);
 		project.getTasks().withType(FormatTask.class, (formatTask) -> formatTask.setEncoding("UTF-8"));
@@ -228,4 +214,8 @@ class JavaConventions {
 				.getByName(OptionalDependenciesPlugin.OPTIONAL_CONFIGURATION_NAME).extendsFrom(dependencyManagement));
 	}
 
+	private void configureToolchain(Project project) {
+		project.getPlugins().apply(ToolchainPlugin.class);
+	}
+
 }

buildSrc/src/main/java/org/springframework/boot/build/toolchain/ToolchainExtension.java

+/*
+ * Copyright 2012-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.build.toolchain;
+
+import java.util.Optional;
+
+import org.gradle.api.Project;
+import org.gradle.jvm.toolchain.JavaLanguageVersion;
+
+/**
+ * DSL extension for {@link ToolchainPlugin}.
+ *
+ * @author Christoph Dreis
+ */
+public class ToolchainExtension {
+
+	private final Project project;
+
+	private int maximumCompatibleJavaVersion;
+
+	public ToolchainExtension(Project project) {
+		this.project = project;
+	}
+
+	public void setMaximumCompatibleJavaVersion(int maximumVersion) {
+		this.maximumCompatibleJavaVersion = maximumVersion;
+	}
+
+	public Optional<JavaLanguageVersion> getToolchainVersion() {
+		String toolchainVersion = (String) this.project.findProperty("toolchainVersion");
+		if (toolchainVersion == null) {
+			return Optional.empty();
+		}
+		int version = Integer.parseInt(toolchainVersion);
+		return getJavaLanguageVersion(version);
+	}
+
+	public boolean isJavaVersionSupported() {
+		Optional<JavaLanguageVersion> maximumVersion = getJavaLanguageVersion(this.maximumCompatibleJavaVersion);
+		if (!maximumVersion.isPresent()) {
+			return true;
+		}
+		Optional<JavaLanguageVersion> toolchainVersion = getToolchainVersion();
+		return toolchainVersion.isPresent() && maximumVersion.get().canCompileOrRun(toolchainVersion.get());
+	}
+
+	private Optional<JavaLanguageVersion> getJavaLanguageVersion(int version) {
+		if (version >= 8) {
+			return Optional.of(JavaLanguageVersion.of(version));
+		}
+		return Optional.empty();
+	}
+
+}

buildSrc/src/main/java/org/springframework/boot/build/toolchain/ToolchainPlugin.java

+/*
+ * Copyright 2012-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.build.toolchain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.api.tasks.javadoc.Javadoc;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.jvm.toolchain.JavaLanguageVersion;
+import org.gradle.jvm.toolchain.JavaToolchainService;
+import org.gradle.jvm.toolchain.JavaToolchainSpec;
+
+/**
+ * {@link Plugin} for customizing Gradle's toolchain support.
+ *
+ * @author Christoph Dreis
+ */
+public class ToolchainPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		configureToolchain(project);
+	}
+
+	private void configureToolchain(Project project) {
+		ToolchainExtension toolchain = project.getExtensions().create("toolchain", ToolchainExtension.class, project);
+		project.afterEvaluate((evaluated) -> {
+			Optional<JavaLanguageVersion> toolchainVersion = toolchain.getToolchainVersion();
+			if (toolchainVersion.isPresent()) {
+				if (!toolchain.isJavaVersionSupported()) {
+					disableToolchainTasks(project);
+				}
+				else {
+					configureJavaCompileToolchain(project, toolchain);
+					configureJavadocToolchain(project, toolchain);
+					configureTestToolchain(project, toolchain);
+				}
+			}
+		});
+	}
+
+	private void disableToolchainTasks(Project project) {
+		project.getTasks().withType(JavaCompile.class, (task) -> task.setEnabled(false));
+		project.getTasks().withType(Javadoc.class, (task) -> task.setEnabled(false));
+		project.getTasks().withType(Test.class, (task) -> task.setEnabled(false));
+	}
+
+	private void configureJavaCompileToolchain(Project project, ToolchainExtension toolchain) {
+		project.getTasks().withType(JavaCompile.class, (compile) -> {
+			withOptionalJavaToolchain(toolchain).ifPresent((action) -> {
+				JavaToolchainService service = getJavaToolchainService(project);
+				compile.getJavaCompiler().set(service.compilerFor(action));
+				compile.getOptions().setFork(true);
+				// See https://github.com/gradle/gradle/issues/15538
+				List<String> forkArgs = Arrays.asList("--add-opens",
+						"jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED");
+				compile.getOptions().getForkOptions().getJvmArgs().addAll(forkArgs);
+			});
+		});
+	}
+
+	private void configureJavadocToolchain(Project project, ToolchainExtension toolchain) {
+		project.getTasks().withType(Javadoc.class, (javadoc) -> {
+			withOptionalJavaToolchain(toolchain).ifPresent((action) -> {
+				JavaToolchainService service = getJavaToolchainService(project);
+				javadoc.getJavadocTool().set(service.javadocToolFor(action));
+			});
+		});
+	}
+
+	private void configureTestToolchain(Project project, ToolchainExtension toolchain) {
+		project.getTasks().withType(Test.class, (test) -> {
+			withOptionalJavaToolchain(toolchain).ifPresent((action) -> {
+				JavaToolchainService service = getJavaToolchainService(project);
+				test.getJavaLauncher().set(service.launcherFor(action));
+				// See https://github.com/spring-projects/spring-ldap/issues/570
+				List<String> arguments = Arrays.asList("--add-exports=java.naming/com.sun.jndi.ldap=ALL-UNNAMED",
+						"--illegal-access=warn");
+				test.jvmArgs(arguments);
+			});
+		});
+	}
+
+	private JavaToolchainService getJavaToolchainService(Project project) {
+		return project.getExtensions().getByType(JavaToolchainService.class);
+	}
+
+	private Optional<Action<JavaToolchainSpec>> withOptionalJavaToolchain(ToolchainExtension toolchain) {
+		return toolchain.getToolchainVersion().map((toolchainVersion) -> {
+			Action<JavaToolchainSpec> action = (javaToolchainSpec) -> javaToolchainSpec.getLanguageVersion()
+					.convention(toolchainVersion);
+			return Optional.of(action);
+		}).orElse(Optional.empty());
+	}
+
+}

settings.gradle

@@ -31,8 +31,8 @@ rootProject.name="spring-boot-build"
 settings.gradle.projectsLoaded {
 	gradleEnterprise {
 		buildScan {
-			if (settings.gradle.rootProject.hasProperty('buildJavaHome')) {
-				value('Build Java home', settings.gradle.rootProject.getProperty('buildJavaHome'))
+			if (settings.gradle.rootProject.hasProperty('toolchainVersion')) {
+				value('Toolchain Version', settings.gradle.rootProject.getProperty('toolchainVersion'))
 			}
 
 			settings.gradle.rootProject.getBuildDir().mkdirs()

spring-boot-project/spring-boot-cli/build.gradle

@@ -7,6 +7,10 @@ plugins {
 
 description = "Spring Boot CLI"
 
+toolchain {
+	maximumCompatibleJavaVersion = 15
+}
+
 configurations {
 	dependenciesBom
 	loader

spring-boot-project/spring-boot-test/src/test/java/org/springframework/boot/test/json/JsonbTesterTests.java

 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/build.gradle

@@ -10,6 +10,10 @@ plugins {
 
 description = "Spring Boot Gradle Plugin"
 
+toolchain {
+	maximumCompatibleJavaVersion = 15
+}
+
 configurations {
 	asciidoctorExtensions {
 		extendsFrom dependencyManagement

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/build.gradle

@@ -69,7 +69,7 @@ processResources {
 }
 
 compileJava {
-	if ((!project.hasProperty("buildJavaHome")) && JavaVersion.current() == JavaVersion.VERSION_1_8) {
+	if ((!project.hasProperty("toolchainVersion")) && JavaVersion.current() == JavaVersion.VERSION_1_8) {
 		options.compilerArgs += ['-Xlint:-sunapi', '-XDenableSunApiLintControl']	
 	}	
 }

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/intTest/java/org/springframework/boot/maven/JarIntegrationTests.java

@@ -30,6 +30,8 @@ import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 
 import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.condition.DisabledForJreRange;
+import org.junit.jupiter.api.condition.JRE;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.loader.tools.FileUtils;
@@ -247,6 +249,7 @@ class JarIntegrationTests extends AbstractArchiveIntegrationTests {
 		});
 	}
 
+	@DisabledForJreRange(min = JRE.JAVA_16) // Remove this once Kotlin supports Java 16
 	@TestTemplate
 	void whenAProjectUsesKotlinItsModuleMetadataIsRepackagedIntoBootInfClasses(MavenBuild mavenBuild) {
 		mavenBuild.project("jar-with-kotlin-module").execute((project) -> {