Merge branch '2.4.x'

Closes gh-25497
pull/25499/head
Andy Wilkinson 4 years ago
commit 961a34a5ee

@ -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);
}
}

@ -0,0 +1,48 @@
/*
* 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 org.gradle.api.Project;
import org.gradle.api.provider.Property;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
/**
* DSL extension for {@link ToolchainPlugin}.
*
* @author Christoph Dreis
*/
public class ToolchainExtension {
private final Property<JavaLanguageVersion> maximumCompatibleJavaVersion;
private final JavaLanguageVersion javaVersion;
public ToolchainExtension(Project project) {
this.maximumCompatibleJavaVersion = project.getObjects().property(JavaLanguageVersion.class);
String toolchainVersion = (String) project.findProperty("toolchainVersion");
this.javaVersion = (toolchainVersion != null) ? JavaLanguageVersion.of(toolchainVersion) : null;
}
public Property<JavaLanguageVersion> getMaximumCompatibleJavaVersion() {
return this.maximumCompatibleJavaVersion;
}
JavaLanguageVersion getJavaVersion() {
return this.javaVersion;
}
}

@ -0,0 +1,93 @@
/*
* 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 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.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);
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) {
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) -> {
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) -> {
// 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);
});
}
}

@ -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()

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

@ -1,5 +1,5 @@
/*
* 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.

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

@ -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']
}
}

@ -25,6 +25,8 @@ import java.util.jar.JarFile;
import java.util.stream.Collectors;
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) -> {

Loading…
Cancel
Save