root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 12 Packages Projects Releases Wiki Activity

Polish "Allow the project to be built with Java 16" 

See gh-25171
This commit is contained in:
Andy Wilkinson 2021-03-04 18:54:18 +00:00
parent 1ccd8dae8a
commit 1ce6e796fe
4 changed files with 43 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,9 +16,8 @@
package org.springframework.boot.build.toolchain;
import java.util.Optional;
import org.gradle.api.Project;
import org.gradle.api.provider.Property;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
/**
@ -28,41 +27,22 @@ import org.gradle.jvm.toolchain.JavaLanguageVersion;
*/
public class ToolchainExtension {
private final Project project;
private final Property<JavaLanguageVersion> maximumCompatibleJavaVersion;
private int maximumCompatibleJavaVersion;
private final JavaLanguageVersion javaVersion;
public ToolchainExtension(Project project) {
this.project = project;
this.maximumCompatibleJavaVersion = project.getObjects().property(JavaLanguageVersion.class);
String toolchainVersion = (String) project.findProperty("toolchainVersion");
this.javaVersion = (toolchainVersion != null) ? JavaLanguageVersion.of(toolchainVersion) : null;
}
public void setMaximumCompatibleJavaVersion(int maximumVersion) {
this.maximumCompatibleJavaVersion = maximumVersion;
public Property<JavaLanguageVersion> getMaximumCompatibleJavaVersion() {
return this.maximumCompatibleJavaVersion;
}
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();
JavaLanguageVersion getJavaVersion() {
return this.javaVersion;
}
}

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

@ -18,16 +18,14 @@ 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.plugins.JavaPluginExtension;
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;
/**
@ -44,19 +42,28 @@ public class ToolchainPlugin implements Plugin<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);
}
}
});
JavaLanguageVersion toolchainVersion = toolchain.getJavaVersion();
if (toolchainVersion != null) {
project.afterEvaluate((evaluated) -> configure(evaluated, toolchain));
}
}
private void configure(Project project, ToolchainExtension toolchain) {
if (!isJavaVersionSupported(toolchain, toolchain.getJavaVersion())) {
disableToolchainTasks(project);
}
else {
JavaToolchainSpec toolchainSpec = project.getExtensions().getByType(JavaPluginExtension.class)
.getToolchain();
toolchainSpec.getLanguageVersion().set(toolchain.getJavaVersion());
configureJavaCompileToolchain(project, toolchain);
configureTestToolchain(project, toolchain);
}
}
public boolean isJavaVersionSupported(ToolchainExtension toolchain, JavaLanguageVersion toolchainVersion) {
return toolchain.getMaximumCompatibleJavaVersion().map((version) -> version.canCompileOrRun(toolchainVersion))
.getOrElse(true);
}
private void disableToolchainTasks(Project project) {
@ -67,50 +74,20 @@ public class ToolchainPlugin implements Plugin<Project> {
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));
});
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 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);
});
// 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());
}
}

2
spring-boot-project/spring-boot-cli/build.gradle
View File

@ -8,7 +8,7 @@ plugins {
description = "Spring Boot CLI"
toolchain {
maximumCompatibleJavaVersion = 15
maximumCompatibleJavaVersion = JavaLanguageVersion.of(15)
}
configurations {

2
spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/build.gradle
View File

@ -11,7 +11,7 @@ plugins {
description = "Spring Boot Gradle Plugin"
toolchain {
maximumCompatibleJavaVersion = 15
maximumCompatibleJavaVersion = JavaLanguageVersion.of(15)
}
configurations {