spring/spring-boot
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-boot.git synced 2026-10-05 16:59:28 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch '4.0.x'

Browse Source 
Closes gh-48956
This commit is contained in:
Phillip Webb
2026-01-23 16:05:50 -08:00
parent 27e3ddc7fb 5f5217d5a0
commit 5cc0e4b7b9
6 changed files with 140 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files
buildSrc/src/main/java/org/springframework/boot/build/ConventionsPlugin.java
+1 -1
View File
@@ -46,7 +46,7 @@ public class ConventionsPlugin implements Plugin<Project> {
SystemRequirementsExtension systemRequirements = project.getExtensions()
.create("systemRequirements", SystemRequirementsExtension.class);
new NoHttpConventions().apply(project);
new JavaConventions(systemRequirements.getJava()).apply(project);
new JavaConventions(systemRequirements).apply(project);
new MavenPublishingConventions().apply(project);
new AntoraConventions().apply(project);
new KotlinConventions().apply(project);
buildSrc/src/main/java/org/springframework/boot/build/EclipseConventions.java
+33 -6
View File
@@ -16,13 +16,17 @@
package org.springframework.boot.build;
import org.gradle.api.DomainObjectCollection;
import org.gradle.api.JavaVersion;
import org.gradle.api.Project;
import org.gradle.api.plugins.JavaBasePlugin;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.plugins.ide.api.XmlFileContentMerger;
import org.gradle.plugins.ide.eclipse.EclipsePlugin;
import org.gradle.plugins.ide.eclipse.model.Classpath;
import org.gradle.plugins.ide.eclipse.model.ClasspathEntry;
import org.gradle.plugins.ide.eclipse.model.EclipseClasspath;
import org.gradle.plugins.ide.eclipse.model.EclipseJdt;
import org.gradle.plugins.ide.eclipse.model.EclipseModel;
import org.gradle.plugins.ide.eclipse.model.Library;
@@ -35,12 +39,35 @@ import org.gradle.plugins.ide.eclipse.model.Library;
class EclipseConventions {
void apply(Project project) {
project.getPlugins()
.withType(EclipsePlugin.class,
(eclipse) -> project.getPlugins().withType(JavaBasePlugin.class, (javaBase) -> {
EclipseModel eclipseModel = project.getExtensions().getByType(EclipseModel.class);
eclipseModel.classpath(this::configureClasspath);
}));
project.getPlugins().withType(EclipsePlugin.class, (eclipse) -> configure(project, eclipse));
}
private DomainObjectCollection<JavaBasePlugin> configure(Project project, EclipsePlugin eclipsePlugin) {
TaskProvider<EclipseSynchronizeJdtSettings> eclipseSynchronizeJdtSettings = registerEclipseSynchronizeJdtSettingsTask(
project);
return project.getPlugins().withType(JavaBasePlugin.class, (javaBase) -> {
EclipseModel model = project.getExtensions().getByType(EclipseModel.class);
model.synchronizationTasks(eclipseSynchronizeJdtSettings);
model.jdt(this::configureJdt);
model.classpath(this::configureClasspath);
});
}
private TaskProvider<EclipseSynchronizeJdtSettings> registerEclipseSynchronizeJdtSettingsTask(Project project) {
TaskProvider<EclipseSynchronizeJdtSettings> taskProvider = project.getTasks()
.register("eclipseSynchronizateJdt", EclipseSynchronizeJdtSettings.class);
taskProvider.configure((task) -> {
task.setDescription("Synchronizate the Eclipse JDT settings file from Buildship.");
task.setOutputFile(project.file(".settings/org.eclipse.jdt.core.prefs"));
task.setInputFile(project.file(".settings/org.eclipse.jdt.core.prefs"));
});
return taskProvider;
}
private void configureJdt(EclipseJdt jdt) {
jdt.setSourceCompatibility(JavaVersion.toVersion(JavaConventions.RUNTIME_JAVA_VERSION));
jdt.setTargetCompatibility(JavaVersion.toVersion(JavaConventions.RUNTIME_JAVA_VERSION));
jdt.setJavaRuntimeName("JavaSE-" + JavaConventions.BUILD_JAVA_VERSION);
}
private void configureClasspath(EclipseClasspath classpath) {
buildSrc/src/main/java/org/springframework/boot/build/EclipseSynchronizeJdtSettings.java
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright 2025 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;
import java.util.Properties;
import org.gradle.api.Task;
import org.gradle.api.internal.PropertiesTransformer;
import org.gradle.plugins.ide.api.PropertiesGeneratorTask;
import org.gradle.plugins.ide.internal.generator.PropertiesPersistableConfigurationObject;
import org.springframework.boot.build.EclipseSynchronizeJdtSettings.Configuration;
/**
* {@link Task} to do something.
*
* @author Phillip Webb
*/
public abstract class EclipseSynchronizeJdtSettings extends PropertiesGeneratorTask<Configuration> {
@Override
protected Configuration create() {
return new Configuration(getTransformer());
}
@Override
protected void configure(Configuration configuration) {
}
static class Configuration extends PropertiesPersistableConfigurationObject {
Configuration(PropertiesTransformer transformer) {
super(transformer);
}
@Override
protected String getDefaultResourceName() {
return null;
}
@Override
protected void load(Properties properties) {
}
@Override
protected void store(Properties properties) {
properties.put("org.eclipse.jdt.core.compiler.release", "true");
}
}
}
buildSrc/src/main/java/org/springframework/boot/build/JavaConventions.java
+35 -11
View File
@@ -16,8 +16,10 @@
package org.springframework.boot.build;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -32,6 +34,8 @@ import io.spring.gradle.nullability.NullabilityPluginExtension;
import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
import io.spring.javaformat.gradle.tasks.CheckFormat;
import io.spring.javaformat.gradle.tasks.Format;
import org.gradle.api.GradleException;
import org.gradle.api.JavaVersion;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.artifacts.Configuration;
@@ -52,8 +56,10 @@ import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.api.tasks.testing.Test;
import org.gradle.external.javadoc.CoreJavadocOptions;
import org.gradle.jvm.toolchain.JavaCompiler;
import org.gradle.jvm.toolchain.JavaInstallationMetadata;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.springframework.boot.build.SystemRequirementsExtension.JavaSpec;
import org.springframework.boot.build.architecture.ArchitecturePlugin;
import org.springframework.boot.build.classpath.CheckClasspathForProhibitedDependencies;
import org.springframework.boot.build.optional.OptionalDependenciesPlugin;
@@ -127,10 +133,14 @@ import org.springframework.util.StringUtils;
*/
class JavaConventions {
private final JavaSpec javaSpec;
public static final int BUILD_JAVA_VERSION = 25;
JavaConventions(JavaSpec javaSpec) {
this.javaSpec = javaSpec;
public static final int RUNTIME_JAVA_VERSION = 17;
private final SystemRequirementsExtension systemRequirements;
JavaConventions(SystemRequirementsExtension systemRequirements) {
this.systemRequirements = systemRequirements;
}
void apply(Project project) {
@@ -169,7 +179,8 @@ class JavaConventions {
jar.manifest((manifest) -> {
Map<String, Object> attributes = new TreeMap<>();
attributes.put("Automatic-Module-Name", project.getName().replace("-", "."));
attributes.put("Build-Jdk-Spec", this.javaSpec.getVersion());
// Build-Jdk-Spec is used by buildpacks to pick the JRE to install
attributes.put("Build-Jdk-Spec", this.systemRequirements.getJava().getVersion());
attributes.put("Built-By", "Spring");
attributes.put("Implementation-Title",
determineImplementationTitle(project, sourceJarTaskNames, javadocJarTaskNames, jar));
@@ -248,17 +259,30 @@ class JavaConventions {
private void configureJavaConventions(Project project) {
project.getTasks().withType(JavaCompile.class, (compile) -> {
compile.doFirst((task) -> assertCompatible(compile));
compile.getOptions().setEncoding("UTF-8");
compile.getOptions().getRelease().set(this.javaSpec.getVersion());
List<String> args = compile.getOptions().getCompilerArgs();
if (!args.contains("-parameters")) {
args.add("-parameters");
}
args.addAll(Arrays.asList("-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes",
compile.getOptions().getRelease().set(RUNTIME_JAVA_VERSION);
Set<String> args = new LinkedHashSet<>(compile.getOptions().getCompilerArgs());
args.addAll(List.of("-parameters", "-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes",
"-Xlint:varargs"));
compile.getOptions().setCompilerArgs(new ArrayList<>(args));
});
}
private void assertCompatible(JavaCompile compile) {
JavaVersion requiredVersion = JavaVersion.toVersion(BUILD_JAVA_VERSION);
JavaVersion actualVersion = compile.getJavaCompiler()
.map(JavaCompiler::getMetadata)
.map(JavaInstallationMetadata::getLanguageVersion)
.map(JavaLanguageVersion::asInt)
.map(JavaVersion::toVersion)
.orElse(JavaVersion.current())
.get();
if (!actualVersion.isCompatibleWith(requiredVersion)) {
throw new GradleException("This project should be built with Java %s or above".formatted(requiredVersion));
}
}
private void configureSpringJavaFormat(Project project) {
project.getPlugins().apply(SpringJavaFormatPlugin.class);
project.getTasks().withType(Format.class, (Format) -> Format.setEncoding("UTF-8"));
buildSrc/src/main/java/org/springframework/boot/build/SystemRequirementsExtension.java
+2 -16
View File
@@ -19,10 +19,7 @@ package org.springframework.boot.build;
import javax.inject.Inject;
import org.gradle.api.Action;
import org.gradle.api.Project;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
/**
* DSL extension for configuring a project's system requirements.
@@ -34,8 +31,8 @@ public class SystemRequirementsExtension {
private final JavaSpec javaSpec;
@Inject
public SystemRequirementsExtension(Project project, ObjectFactory objects) {
this.javaSpec = objects.newInstance(JavaSpec.class, project);
public SystemRequirementsExtension(ObjectFactory objects) {
this.javaSpec = objects.newInstance(JavaSpec.class);
}
public void java(Action<JavaSpec> action) {
@@ -48,24 +45,13 @@ public class SystemRequirementsExtension {
public abstract static class JavaSpec {
private final Project project;
private int version = 17;
@Inject
public JavaSpec(Project project) {
this.project = project;
}
public int getVersion() {
return this.version;
}
public void setVersion(int version) {
JavaLanguageVersion javaVersion = JavaLanguageVersion.of(version);
JavaPluginExtension javaPluginExtension = this.project.getExtensions().getByType(JavaPluginExtension.class);
javaPluginExtension.setSourceCompatibility(javaVersion);
javaPluginExtension.setTargetCompatibility(javaVersion);
this.version = version;
}
buildSrc/src/main/java/org/springframework/boot/build/toolchain/ToolchainExtension.java
+3 -3
View File
@@ -22,7 +22,6 @@ import org.gradle.api.provider.Property;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.springframework.boot.build.SystemRequirementsExtension;
import org.springframework.boot.build.SystemRequirementsExtension.JavaSpec;
/**
* DSL extension for {@link ToolchainPlugin}.
@@ -36,9 +35,10 @@ public abstract class ToolchainExtension {
public ToolchainExtension(Project project) {
String toolchainVersion = (String) project.findProperty("toolchainVersion");
this.javaVersion = (toolchainVersion != null) ? JavaLanguageVersion.of(toolchainVersion) : null;
JavaSpec javaSpec = project.getExtensions().getByType(SystemRequirementsExtension.class).getJava();
SystemRequirementsExtension systemRequirements = project.getExtensions()
.getByType(SystemRequirementsExtension.class);
getMinimumCompatibleJavaVersion()
.convention(project.provider(() -> JavaLanguageVersion.of(javaSpec.getVersion())));
.convention(project.provider(() -> JavaLanguageVersion.of(systemRequirements.getJava().getVersion())));
}
public abstract Property<JavaLanguageVersion> getMinimumCompatibleJavaVersion();