PoC: integrate Eclipse Formatter Profile into Maven Spotless Plugin

buildSrc/build.gradle

@@ -1,8 +1,15 @@
 plugins {
 	id 'java-gradle-plugin'
-	id 'checkstyle'
+	id 'com.diffplug.spotless' version '7.0.4'
+}
+allprojects {
+	spotless {
+		java {
+			removeUnusedImports()
+			palantirJavaFormat()
+		}
+	}
 }
-
 repositories {
 	mavenCentral()
 	gradlePluginPortal()
@@ -18,9 +25,9 @@ ext {
 }
 
 dependencies {
-	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
 	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
 	implementation "com.tngtech.archunit:archunit:1.4.0"
+	implementation "com.diffplug.spotless:spotless-plugin-gradle:7.0.4"
 	implementation "org.gradle:test-retry-gradle-plugin:1.6.2"
 	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
 	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"

buildSrc/src/main/java/org/springframework/build/ConventionsPlugin.java

@@ -41,7 +41,8 @@ public class ConventionsPlugin implements Plugin<Project> {
 	public void apply(Project project) {
 		project.getExtensions().create("springFramework", SpringFrameworkExtension.class);
 		new ArchitecturePlugin().apply(project);
-		new CheckstyleConventions().apply(project);
+//		new CheckstyleConventions().apply(project);
+		new SpotlessConventions().apply(project);
 		new JavaConventions().apply(project);
 		new KotlinConventions().apply(project);
 		new TestConventions().apply(project);

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

@@ -18,7 +18,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
@@ -37,101 +36,121 @@
  */
 public class JavaConventions {
 
-	private static final List<String> COMPILER_ARGS;
-
-	private static final List<String> TEST_COMPILER_ARGS;
-
-	/**
-	 * The Java version we should use as the JVM baseline for building the project.
-	 * <p>NOTE: If you update this value, you should also update the value used in
-	 * the {@code javadoc} task in {@code framework-api.gradle}.
-	 */
-	private static final JavaLanguageVersion DEFAULT_LANGUAGE_VERSION = JavaLanguageVersion.of(24);
+    private static final List<String> COMPILER_ARGS;
 
-	/**
-	 * The Java version we should use as the baseline for the compiled bytecode
-	 * (the "-release" compiler argument).
-	 */
-	private static final JavaLanguageVersion DEFAULT_RELEASE_VERSION = JavaLanguageVersion.of(17);
+    private static final List<String> TEST_COMPILER_ARGS;
 
-	static {
-		List<String> commonCompilerArgs = List.of(
-				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options",
-				"-parameters"
-		);
-		COMPILER_ARGS = new ArrayList<>();
-		COMPILER_ARGS.addAll(commonCompilerArgs);
-		COMPILER_ARGS.addAll(List.of(
-				"-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
-				"-Xlint:unchecked", "-Werror"
-		));
-		TEST_COMPILER_ARGS = new ArrayList<>();
-		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
-		TEST_COMPILER_ARGS.addAll(List.of("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-				"-Xlint:-deprecation", "-Xlint:-unchecked"));
-	}
+    /**
+     * The Java version we should use as the JVM baseline for building the project.
+     *
+     * <p>NOTE: If you update this value, you should also update the value used in the {@code javadoc}
+     * task in {@code framework-api.gradle}.
+     */
+    private static final JavaLanguageVersion DEFAULT_LANGUAGE_VERSION = JavaLanguageVersion.of(24);
 
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> {
-			applyToolchainConventions(project);
-			applyJavaCompileConventions(project);
-		});
-	}
+    /**
+     * The Java version we should use as the baseline for the compiled bytecode (the "-release"
+     * compiler argument).
+     */
+    private static final JavaLanguageVersion DEFAULT_RELEASE_VERSION = JavaLanguageVersion.of(17);
 
-	/**
-	 * Configure the Toolchain support for the project.
-	 * @param project the current project
-	 */
-	private static void applyToolchainConventions(Project project) {
-		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
-			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
-			toolchain.getLanguageVersion().set(DEFAULT_LANGUAGE_VERSION);
-		});
-	}
+    static {
+        List<String> commonCompilerArgs = List.of(
+                "-Xlint:serial",
+                "-Xlint:cast",
+                "-Xlint:classfile",
+                "-Xlint:dep-ann",
+                "-Xlint:divzero",
+                "-Xlint:empty",
+                "-Xlint:finally",
+                "-Xlint:overrides",
+                "-Xlint:path",
+                "-Xlint:processing",
+                "-Xlint:static",
+                "-Xlint:try",
+                "-Xlint:-options",
+                "-parameters");
+        COMPILER_ARGS = new ArrayList<>();
+        COMPILER_ARGS.addAll(commonCompilerArgs);
+        COMPILER_ARGS.addAll(List.of(
+                "-Xlint:varargs",
+                "-Xlint:fallthrough",
+                "-Xlint:rawtypes",
+                "-Xlint:deprecation",
+                "-Xlint:unchecked",
+                "-Werror"));
+        TEST_COMPILER_ARGS = new ArrayList<>();
+        TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
+        TEST_COMPILER_ARGS.addAll(List.of(
+                "-Xlint:-varargs",
+                "-Xlint:-fallthrough",
+                "-Xlint:-rawtypes",
+                "-Xlint:-deprecation",
+                "-Xlint:-unchecked"));
+    }
 
-	/**
-	 * Apply the common Java compiler options for main sources, test fixture sources, and
-	 * test sources.
-	 * @param project the current project
-	 */
-	private void applyJavaCompileConventions(Project project) {
-		project.afterEvaluate(p -> {
-			p.getTasks().withType(JavaCompile.class)
-					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_JAVA_TASK_NAME))
-					.forEach(compileTask -> {
-						compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
-						compileTask.getOptions().setEncoding("UTF-8");
-						setJavaRelease(compileTask);
-					});
-			p.getTasks().withType(JavaCompile.class)
-					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
-							|| compileTask.getName().equals("compileTestFixturesJava"))
-					.forEach(compileTask -> {
-						compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
-						compileTask.getOptions().setEncoding("UTF-8");
-						setJavaRelease(compileTask);
-					});
+    public void apply(Project project) {
+        project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> {
+            applyToolchainConventions(project);
+            applyJavaCompileConventions(project);
+        });
+    }
 
-		});
-	}
+    /**
+     * Configure the Toolchain support for the project.
+     *
+     * @param project the current project
+     */
+    private static void applyToolchainConventions(Project project) {
+        project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
+            toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
+            toolchain.getLanguageVersion().set(DEFAULT_LANGUAGE_VERSION);
+        });
+    }
 
-	/**
-	 * We should pick the {@link #DEFAULT_RELEASE_VERSION} for all compiled classes,
-	 * unless the current task is compiling multi-release JAR code with a higher version.
-	 */
-	private void setJavaRelease(JavaCompile task) {
-		int defaultVersion = DEFAULT_RELEASE_VERSION.asInt();
-		int releaseVersion = defaultVersion;
-		int compilerVersion = task.getJavaCompiler().get().getMetadata().getLanguageVersion().asInt();
-		for (int version = defaultVersion ; version <= compilerVersion ; version++) {
-			if (task.getName().contains("Java" + version)) {
-				releaseVersion = version;
-				break;
-			}
-		}
-		task.getOptions().getRelease().set(releaseVersion);
-	}
+    /**
+     * Apply the common Java compiler options for main sources, test fixture sources, and test
+     * sources.
+     *
+     * @param project the current project
+     */
+    private void applyJavaCompileConventions(Project project) {
+        project.afterEvaluate(p -> {
+            p.getTasks()
+                    .withType(JavaCompile.class)
+                    .matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_JAVA_TASK_NAME))
+                    .forEach(compileTask -> {
+                        compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
+                        compileTask.getOptions().setEncoding("UTF-8");
+                        setJavaRelease(compileTask);
+                    });
+            p.getTasks()
+                    .withType(JavaCompile.class)
+                    .matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
+                            || compileTask.getName().equals("compileTestFixturesJava"))
+                    .forEach(compileTask -> {
+                        compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
+                        compileTask.getOptions().setEncoding("UTF-8");
+                        setJavaRelease(compileTask);
+                    });
+        });
+    }
 
+    /**
+     * We should pick the {@link #DEFAULT_RELEASE_VERSION} for all compiled classes, unless the
+     * current task is compiling multi-release JAR code with a higher version.
+     */
+    private void setJavaRelease(JavaCompile task) {
+        int defaultVersion = DEFAULT_RELEASE_VERSION.asInt();
+        int releaseVersion = defaultVersion;
+        int compilerVersion =
+                task.getJavaCompiler().get().getMetadata().getLanguageVersion().asInt();
+        for (int version = defaultVersion; version <= compilerVersion; version++) {
+            if (task.getName().contains("Java" + version)) {
+                releaseVersion = version;
+                break;
+            }
+        }
+        task.getOptions().getRelease().set(releaseVersion);
+    }
 }

buildSrc/src/main/java/org/springframework/build/KotlinConventions.java

@@ -27,25 +27,25 @@
  */
 public class KotlinConventions {
 
-	void apply(Project project) {
-		project.getPlugins().withId("org.jetbrains.kotlin.jvm",
-				(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
-	}
-
-	private void configure(KotlinCompile compile) {
-		compile.compilerOptions(options -> {
-			options.getApiVersion().set(KotlinVersion.KOTLIN_2_1);
-			options.getLanguageVersion().set(KotlinVersion.KOTLIN_2_1);
-			options.getJvmTarget().set(JvmTarget.JVM_17);
-			options.getJavaParameters().set(true);
-			options.getAllWarningsAsErrors().set(true);
-			options.getFreeCompilerArgs().addAll(
-					"-Xsuppress-version-warnings",
-					"-Xjsr305=strict", // For dependencies using JSR 305
-					"-opt-in=kotlin.RequiresOptIn",
-					"-Xjdk-release=17" // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
-			);
-		});
-	}
+    void apply(Project project) {
+        project.getPlugins().withId("org.jetbrains.kotlin.jvm", (plugin) -> project.getTasks()
+                .withType(KotlinCompile.class, this::configure));
+    }
 
+    private void configure(KotlinCompile compile) {
+        compile.compilerOptions(options -> {
+            options.getApiVersion().set(KotlinVersion.KOTLIN_2_1);
+            options.getLanguageVersion().set(KotlinVersion.KOTLIN_2_1);
+            options.getJvmTarget().set(JvmTarget.JVM_17);
+            options.getJavaParameters().set(true);
+            options.getAllWarningsAsErrors().set(true);
+            options.getFreeCompilerArgs()
+                    .addAll(
+                            "-Xsuppress-version-warnings",
+                            "-Xjsr305=strict", // For dependencies using JSR 305
+                            "-opt-in=kotlin.RequiresOptIn",
+                            "-Xjdk-release=17" // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
+                            );
+        });
+    }
 }

buildSrc/src/main/java/org/springframework/build/SpotlessConventions.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002-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.build;
+
+import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
+import io.spring.nohttp.gradle.NoHttpExtension;
+import io.spring.nohttp.gradle.NoHttpPlugin;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.DependencySet;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.plugins.quality.CheckstyleExtension;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+
+/**
+ * {@link Plugin} that applies conventions for checkstyle.
+ *
+ * @author Brian Clozel
+ */
+public class SpotlessConventions {
+
+	/**
+	 * Applies the Spring Java Format and Spotless plugins with the project conventions.
+	 * @param project the current project
+	 */
+	public void apply(Project project) {
+		project.getPlugins().withType(JavaBasePlugin.class, (_) -> {
+			project.getPlugins().apply(com.diffplug.gradle.spotless.SpotlessPlugin.class);
+			project.getTasks().withType(Spotless.class).forEach(spotless -> spotless.getMaxHeapSize().set("1g"));
+		});
+	}
+
+}