Spring/spring-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update BootRun to support Gradle's configuration cache

Browse Source 
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
Download Patch File Download Diff File Expand all files Collapse all files

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