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

Update BootRun to support Gradle's configuration cache 

See gh-22922
This commit is contained in:
Andy Wilkinson 2020-10-02 15:04:58 +01:00
parent d1f543fc1d
commit c078a48064
15 changed files with 289 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

131
spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/main/java/org/springframework/boot/gradle/plugin/ResolveMainClassName.java Normal file
View File

@ -0,0 +1,131 @@
/*
* 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;
}
}
}

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

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

34
spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/com/example/main/CustomMainClass.java Normal file
View File

@ -0,0 +1,34 @@
/*
* 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());
}
}

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

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

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

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

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

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

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

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

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

@ -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}"
}
}
}

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

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

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

@ -1,12 +1,8 @@
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'
}