Update BootRun to support Gradle's configuration cache

See gh-22922

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/running/application-plugin-main-class-name.gradle

@@ -10,8 +10,3 @@ application {
 }
 // end::main-class[]
 
-task configuredMainClass {
-	doLast {
-		println bootRun.main
-	}
-}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/running/application-plugin-main-class-name.gradle.kts

@@ -11,9 +11,3 @@ application {
 	mainClass.set("com.example.ExampleApplication")
 }
 // end::main-class[]
-
-task("configuredMainClass") {
-	doLast {
-		println(tasks.getByName<BootRun>("bootRun").main)
-	}
-}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/running/spring-boot-dsl-main-class-name.gradle

@@ -9,9 +9,3 @@ springBoot {
 	mainClass = 'com.example.ExampleApplication'
 }
 // end::main-class[]
-
-task configuredMainClass {
-	doLast {
-		println bootRun.main
-	}
-}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/running/spring-boot-dsl-main-class-name.gradle.kts

@@ -11,9 +11,3 @@ springBoot {
 	mainClass.set("com.example.ExampleApplication")
 }
 // end::main-class[]
-
-task("configuredMainClass") {
-	doLast {
-		println(tasks.getByName<BootRun>("bootRun").main)
-	}
-}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/main/java/org/springframework/boot/gradle/plugin/JavaPluginAction.java

@@ -17,6 +17,10 @@
 package org.springframework.boot.gradle.plugin;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
@@ -33,16 +37,21 @@ import org.gradle.api.attributes.Bundling;
 import org.gradle.api.attributes.LibraryElements;
 import org.gradle.api.attributes.Usage;
 import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.internal.artifacts.dsl.LazyPublishArtifact;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.plugins.ApplicationPlugin;
 import org.gradle.api.plugins.BasePlugin;
+import org.gradle.api.plugins.Convention;
+import org.gradle.api.plugins.JavaApplication;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.api.tasks.compile.JavaCompile;
 
+import org.springframework.boot.gradle.dsl.SpringBootExtension;
 import org.springframework.boot.gradle.tasks.bundling.BootBuildImage;
 import org.springframework.boot.gradle.tasks.bundling.BootJar;
 import org.springframework.boot.gradle.tasks.run.BootRun;
@@ -77,7 +86,8 @@ final class JavaPluginAction implements PluginApplicationAction {
 		TaskProvider<BootJar> bootJar = configureBootJarTask(project);
 		configureBootBuildImageTask(project, bootJar);
 		configureArtifactPublication(bootJar);
-		configureBootRunTask(project);
+		TaskProvider<ResolveMainClassName> resolveMainClassName = configureResolveMainClassNameTask(project);
+		configureBootRunTask(project, resolveMainClassName);
 		configureUtf8Encoding(project);
 		configureParametersCompilerArg(project);
 		configureAdditionalMetadataLocations(project);
@@ -92,6 +102,39 @@ final class JavaPluginAction implements PluginApplicationAction {
 				.configure((task) -> task.dependsOn(this.singlePublishedArtifact));
 	}
 
+	private TaskProvider<ResolveMainClassName> configureResolveMainClassNameTask(Project project) {
+		Convention convention = project.getConvention();
+		return project.getTasks().register("resolveMainClassName", ResolveMainClassName.class,
+				(resolveMainClassName) -> {
+					resolveMainClassName.setClasspath(
+							javaPluginConvention(project).getSourceSets().findByName(SourceSet.MAIN_SOURCE_SET_NAME)
+									.getRuntimeClasspath().filter(new JarTypeFileSpec()));
+					resolveMainClassName.getConfiguredMainClassName().convention(project.provider(() -> {
+						JavaApplication javaApplication = convention.findByType(JavaApplication.class);
+						String javaApplicationMainClass = null;
+						if (javaApplication != null) {
+							try {
+								javaApplicationMainClass = javaApplication.getMainClass().getOrNull();
+							}
+							catch (NoSuchMethodError ex) {
+								javaApplicationMainClass = javaApplication.getMainClassName();
+							}
+						}
+						if (javaApplicationMainClass != null) {
+							return javaApplicationMainClass;
+						}
+						SpringBootExtension springBootExtension = project.getExtensions()
+								.findByType(SpringBootExtension.class);
+						if (springBootExtension != null) {
+							return springBootExtension.getMainClass().getOrNull();
+						}
+						return null;
+					}));
+					resolveMainClassName.getOutputFile()
+							.set(project.getLayout().getBuildDirectory().file("spring-boot-main-class-name"));
+				});
+	}
+
 	private TaskProvider<BootJar> configureBootJarTask(Project project) {
 		return project.getTasks().register(SpringBootPlugin.BOOT_JAR_TASK_NAME, BootJar.class, (bootJar) -> {
 			bootJar.setDescription(
@@ -129,7 +172,7 @@ final class JavaPluginAction implements PluginApplicationAction {
 		this.singlePublishedArtifact.addCandidate(artifact);
 	}
 
-	private void configureBootRunTask(Project project) {
+	private void configureBootRunTask(Project project, TaskProvider<ResolveMainClassName> resolveMainClassName) {
 		project.getTasks().register("bootRun", BootRun.class, (run) -> {
 			run.setDescription("Runs this project as a Spring Boot application.");
 			run.setGroup(ApplicationPlugin.APPLICATION_GROUP);
@@ -141,7 +184,30 @@ final class JavaPluginAction implements PluginApplicationAction {
 				}
 				return Collections.emptyList();
 			});
-			run.conventionMapping("main", new MainClassConvention(project, run::getClasspath));
+			run.dependsOn(resolveMainClassName);
+			run.getInputs().file(resolveMainClassName.map((task) -> task.getOutputFile()));
+			try {
+				run.getMainClass().set(resolveMainClassName.flatMap((task) -> readMainClassName(task.getOutputFile())));
+			}
+			catch (NoSuchMethodError ex) {
+				run.conventionMapping("main",
+						() -> resolveMainClassName.flatMap((task) -> readMainClassName(task.getOutputFile())).get());
+			}
+		});
+	}
+
+	private Provider<String> readMainClassName(RegularFileProperty outputFile) {
+		return outputFile.map((file) -> {
+			Path output = file.getAsFile().toPath();
+			if (!Files.exists(output)) {
+				return null;
+			}
+			try {
+				return new String(Files.readAllBytes(output), StandardCharsets.UTF_8);
+			}
+			catch (IOException ex) {
+				throw new RuntimeException("Failed to read main class name from '" + output + "'");
+			}
 		});
 	}
 

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/main/java/org/springframework/boot/gradle/plugin/ResolveMainClassName.java

+/*
+ * Copyright 2012-2020 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.gradle.plugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.Objects;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.InvalidUserDataException;
+import org.gradle.api.Task;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+
+import org.springframework.boot.loader.tools.MainClassFinder;
+
+/**
+ * {@link Task} for resolving the name of the application's main class.
+ *
+ * @author Andy Wilkinson
+ * @since 2.4
+ */
+public class ResolveMainClassName extends DefaultTask {
+
+	private static final String SPRING_BOOT_APPLICATION_CLASS_NAME = "org.springframework.boot.autoconfigure.SpringBootApplication";
+
+	private final RegularFileProperty outputFile;
+
+	private final Property<String> configuredMainClass;
+
+	private FileCollection classpath;
+
+	/**
+	 * Creates a new instance of the {@code ResolveMainClassName} task.
+	 */
+	public ResolveMainClassName() {
+		this.outputFile = getProject().getObjects().fileProperty();
+		this.configuredMainClass = getProject().getObjects().property(String.class);
+	}
+
+	/**
+	 * Returns the classpath that the task will examine when resolving the main class
+	 * name.
+	 * @return the classpath
+	 */
+	@Classpath
+	public FileCollection getClasspath() {
+		return this.classpath;
+	}
+
+	/**
+	 * Sets the classpath that the task will examine when resolving the main class name.
+	 * @param classpath the classpath
+	 */
+	public void setClasspath(FileCollection classpath) {
+		this.classpath = classpath;
+	}
+
+	/**
+	 * Returns the property for the task's output file that will contain the name of the
+	 * main class.
+	 * @return the output file
+	 */
+	@OutputFile
+	public RegularFileProperty getOutputFile() {
+		return this.outputFile;
+	}
+
+	/**
+	 * Returns the property for the explicitly configured main class name that should be
+	 * used in favour of resolving the main class name from the classpath.
+	 * @return the configured main class name property
+	 */
+	@Input
+	@Optional
+	public Property<String> getConfiguredMainClassName() {
+		return this.configuredMainClass;
+	}
+
+	@TaskAction
+	void resolveAndStoreMainClassName() throws IOException {
+		String mainClassName = resolveMainClassName();
+		File outputFile = this.outputFile.getAsFile().get();
+		outputFile.getParentFile().mkdirs();
+		Files.write(this.outputFile.get().getAsFile().toPath(), mainClassName.getBytes(StandardCharsets.UTF_8),
+				StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+	}
+
+	private String resolveMainClassName() {
+		String configuredMainClass = this.configuredMainClass.getOrNull();
+		if (configuredMainClass != null) {
+			return configuredMainClass;
+		}
+		return getClasspath().filter(File::isDirectory).getFiles().stream().map(this::findMainClass)
+				.filter(Objects::nonNull).findFirst().orElseThrow(() -> new InvalidUserDataException(
+						"Main class name has not been configured and it could not be resolved"));
+	}
+
+	private String findMainClass(File file) {
+		try {
+			return MainClassFinder.findSingleMainClass(file, SPRING_BOOT_APPLICATION_CLASS_NAME);
+		}
+		catch (IOException ex) {
+			return null;
+		}
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/main/java/org/springframework/boot/gradle/tasks/run/BootRun.java

@@ -16,7 +16,9 @@
 
 package org.springframework.boot.gradle.tasks.run;
 
+import java.io.File;
 import java.lang.reflect.Method;
+import java.util.Set;
 
 import org.gradle.api.file.SourceDirectorySet;
 import org.gradle.api.tasks.Input;
@@ -63,8 +65,9 @@ public class BootRun extends JavaExec {
 	 * @param sourceSet the source set
 	 */
 	public void sourceResources(SourceSet sourceSet) {
-		setClasspath(getProject().files(sourceSet.getResources().getSrcDirs(), getClasspath())
-				.filter((file) -> !file.equals(sourceSet.getOutput().getResourcesDir())));
+		File resourcesDir = sourceSet.getOutput().getResourcesDir();
+		Set<File> srcDirs = sourceSet.getResources().getSrcDirs();
+		setClasspath(getProject().files(srcDirs, getClasspath()).filter((file) -> !file.equals(resourcesDir)));
 	}
 
 	@Override

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/com/example/main/CustomMainClass.java

+/*
+ * Copyright 2012-2020 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 com.example.main;
+
+/**
+ * Application used for testing {@code BootRun}'s main class configuration.
+ *
+ * @author Andy Wilkinson
+ */
+public class CustomMainClass {
+
+	protected CustomMainClass() {
+
+	}
+
+	public static void main(String[] args) {
+		System.out.println(CustomMainClass.class.getName());
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/org/springframework/boot/gradle/docs/RunningDocumentationTests.java

@@ -17,7 +17,9 @@
 package org.springframework.boot.gradle.docs;
 
 import java.io.File;
+import java.io.FileWriter;
 import java.io.IOException;
+import java.io.PrintWriter;
 
 import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.condition.DisabledForJreRange;
@@ -43,20 +45,23 @@ class RunningDocumentationTests {
 	@TestTemplate
 	@DisabledForJreRange(min = JRE.JAVA_13)
 	void bootRunMain() throws IOException {
-		assertThat(this.gradleBuild.script("src/docs/gradle/running/boot-run-main").build("configuredMainClass")
-				.getOutput()).contains("com.example.ExampleApplication");
+		writeMainClass();
+		assertThat(this.gradleBuild.script("src/docs/gradle/running/boot-run-main").build("bootRun").getOutput())
+				.contains("com.example.ExampleApplication");
 	}
 
 	@TestTemplate
-	void applicationPluginMainClassName() {
+	void applicationPluginMainClassName() throws IOException {
+		writeMainClass();
 		assertThat(this.gradleBuild.script("src/docs/gradle/running/application-plugin-main-class-name")
-				.build("configuredMainClass").getOutput()).contains("com.example.ExampleApplication");
+				.build("bootRun").getOutput()).contains("com.example.ExampleApplication");
 	}
 
 	@TestTemplate
 	void springBootDslMainClassName() throws IOException {
-		assertThat(this.gradleBuild.script("src/docs/gradle/running/spring-boot-dsl-main-class-name")
-				.build("configuredMainClass").getOutput()).contains("com.example.ExampleApplication");
+		writeMainClass();
+		assertThat(this.gradleBuild.script("src/docs/gradle/running/spring-boot-dsl-main-class-name").build("bootRun")
+				.getOutput()).contains("com.example.ExampleApplication");
 	}
 
 	@TestTemplate
@@ -84,4 +89,18 @@ class RunningDocumentationTests {
 						.contains("com.example.property = custom");
 	}
 
+	private void writeMainClass() throws IOException {
+		File exampleApplication = new File(this.gradleBuild.getProjectDir(),
+				"src/main/java/com/example/ExampleApplication.java");
+		exampleApplication.getParentFile().mkdirs();
+		try (PrintWriter writer = new PrintWriter(new FileWriter(exampleApplication))) {
+			writer.println("package com.example;");
+			writer.println("public class ExampleApplication {");
+			writer.println("    public static void main(String[] args) {");
+			writer.println("        System.out.println(ExampleApplication.class.getName());");
+			writer.println("    }");
+			writer.println("}");
+		}
+	}
+
 }

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/org/springframework/boot/gradle/junit/GradleCompatibilityExtension.java

@@ -66,7 +66,8 @@ final class GradleCompatibilityExtension implements TestTemplateInvocationContex
 			boolean configurationCache = AnnotationUtils
 					.findAnnotation(context.getRequiredTestClass(), GradleCompatibility.class).get()
 					.configurationCache();
-			if (configurationCache && GradleVersion.version(version).compareTo(GradleVersion.version("6.6")) >= 0) {
+			if (configurationCache
+					&& GradleVersion.version(version).compareTo(GradleVersion.version("6.7-rc-1")) >= 0) {
 				invocationContexts.add(new GradleVersionTestTemplateInvocationContext(version, true));
 			}
 			return invocationContexts.stream();

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/org/springframework/boot/gradle/tasks/run/BootRunIntegrationTests.java

@@ -40,7 +40,7 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Andy Wilkinson
  */
-@GradleCompatibility
+@GradleCompatibility(configurationCache = true)
 class BootRunIntegrationTests {
 
 	GradleBuild gradleBuild;
@@ -68,23 +68,25 @@ class BootRunIntegrationTests {
 
 	@TestTemplate
 	void springBootExtensionMainClassNameIsUsed() throws IOException {
-		BuildResult result = this.gradleBuild.build("echoMainClassName");
-		assertThat(result.task(":echoMainClassName").getOutcome()).isEqualTo(TaskOutcome.UP_TO_DATE);
-		assertThat(result.getOutput()).contains("Main class name = com.example.CustomMainClass");
+		copyMainClassApplication();
+		BuildResult result = this.gradleBuild.build("bootRun");
+		assertThat(result.task(":bootRun").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(result.getOutput()).contains("com.example.main.CustomMainClass");
 	}
 
 	@TestTemplate
 	void applicationPluginMainClassNameIsUsed() throws IOException {
-		BuildResult result = this.gradleBuild.build("echoMainClassName");
-		assertThat(result.task(":echoMainClassName").getOutcome()).isEqualTo(TaskOutcome.UP_TO_DATE);
-		assertThat(result.getOutput()).contains("Main class name = com.example.CustomMainClass");
+		copyMainClassApplication();
+		BuildResult result = this.gradleBuild.build("bootRun");
+		assertThat(result.task(":bootRun").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(result.getOutput()).contains("com.example.main.CustomMainClass");
 	}
 
 	@TestTemplate
 	void applicationPluginMainClassNameIsNotUsedWhenItIsNull() throws IOException {
 		copyClasspathApplication();
-		BuildResult result = this.gradleBuild.build("echoMainClassName");
-		assertThat(result.task(":echoMainClassName").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		BuildResult result = this.gradleBuild.build("bootRun");
+		assertThat(result.task(":bootRun").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
 		assertThat(result.getOutput()).contains("Main class name = com.example.classpath.BootRunClasspathApplication");
 	}
 
@@ -135,6 +137,10 @@ class BootRunIntegrationTests {
 		assertThat(result.getOutput()).contains("standard.jar").doesNotContain("starter.jar");
 	}
 
+	private void copyMainClassApplication() throws IOException {
+		copyApplication("main");
+	}
+
 	private void copyClasspathApplication() throws IOException {
 		copyApplication("classpath");
 	}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/resources/org/springframework/boot/gradle/tasks/bundling/BootWarIntegrationTests-applicationPluginMainClassNameIsUsed.gradle

@@ -4,4 +4,4 @@ plugins {
 	id 'org.springframework.boot' version '{version}'
 }
 
-mainClass = 'com.example.CustomMain'
+mainClassName = 'com.example.CustomMain'

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/resources/org/springframework/boot/gradle/tasks/run/BootRunIntegrationTests-applicationPluginMainClassNameIsNotUsedWhenItIsNull.gradle

@@ -3,9 +3,8 @@ plugins {
 	id 'org.springframework.boot' version '{version}'
 }
 
-task echoMainClassName {
-	dependsOn compileJava
-	doLast {
-		println 'Main class name = ' + bootRun.main
+bootRun {
+	doFirst {
+		println "Main class name = ${bootRun.main}"
 	}
-}
+}
\ No newline at end of file

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/resources/org/springframework/boot/gradle/tasks/run/BootRunIntegrationTests-applicationPluginMainClassNameIsUsed.gradle

@@ -3,8 +3,4 @@ plugins {
 	id 'org.springframework.boot' version '{version}'
 }
 
-mainClassName = 'com.example.CustomMainClass'
-
-task echoMainClassName {
-	println 'Main class name = ' + bootRun.main
-}
+mainClassName = 'com.example.main.CustomMainClass'

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/resources/org/springframework/boot/gradle/tasks/run/BootRunIntegrationTests-springBootExtensionMainClassNameIsUsed.gradle

 plugins {
-	id 'application'
+	id 'java'
 	id 'org.springframework.boot' version '{version}'
 }
 
 springBoot {
-	mainClass = 'com.example.CustomMainClass'
-}
-
-task echoMainClassName {
-	println 'Main class name = ' + bootRun.main
+	mainClass = 'com.example.main.CustomMainClass'
 }