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

Separate classpath of AOT tasks from source sets they populate

Browse Source 
Closes gh-32930
This commit is contained in:
Andy Wilkinson
2022-10-31 15:47:11 +00:00
parent 2b5a29d514
commit 2bb9b2640e
1 changed files with 42 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -21,7 +21,7 @@ import java.util.List;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.ConfigurationContainer;
import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.attributes.LibraryElements;
import org.gradle.api.attributes.Usage;
@@ -78,7 +78,7 @@ public class SpringBootAotPlugin implements Plugin<Project> {
SourceSet aotTestSourceSet = configureSourceSet(project, "aotTest", testSourceSet);
plugins.withType(SpringBootPlugin.class).all((bootPlugin) -> {
registerProcessAotTask(project, aotSourceSet, mainSourceSet);
registerProcessTestAotTask(project, aotTestSourceSet, testSourceSet);
registerProcessTestAotTask(project, mainSourceSet, aotTestSourceSet, testSourceSet);
});
});
}
@@ -89,18 +89,13 @@ public class SpringBootAotPlugin implements Plugin<Project> {
return sourceSets.create(newSourceSetName, (sourceSet) -> {
sourceSet.getJava().setSrcDirs(List.of("build/generated/" + newSourceSetName + "Sources"));
sourceSet.getResources().setSrcDirs(List.of("build/generated/" + newSourceSetName + "Resources"));
sourceSet.setCompileClasspath(sourceSet.getCompileClasspath().plus(existingSourceSet.getCompileClasspath())
.plus(existingSourceSet.getOutput()));
existingSourceSet.setRuntimeClasspath(existingSourceSet.getRuntimeClasspath().plus(sourceSet.getOutput()));
ConfigurationContainer configurations = project.getConfigurations();
Configuration implementation = configurations.getByName(sourceSet.getImplementationConfigurationName());
implementation
.extendsFrom(configurations.getByName(existingSourceSet.getImplementationConfigurationName()));
implementation.extendsFrom(configurations.getByName(existingSourceSet.getRuntimeOnlyConfigurationName()));
configurations.getByName(sourceSet.getCompileClasspathConfigurationName()).attributes((attributes) -> {
configureClassesAndResourcesLibraryElementsAttribute(project, attributes);
configureJavaRuntimeUsageAttribute(project, attributes);
});
project.getDependencies().add(existingSourceSet.getRuntimeClasspathConfigurationName(),
project.files(sourceSet.getOutput()));
project.getConfigurations().getByName(sourceSet.getCompileClasspathConfigurationName())
.attributes((attributes) -> {
configureClassesAndResourcesLibraryElementsAttribute(project, attributes);
configureJavaRuntimeUsageAttribute(project, attributes);
});
});
}
@@ -119,11 +114,17 @@ public class SpringBootAotPlugin implements Plugin<Project> {
TaskProvider<ResolveMainClassName> resolveMainClassName = project.getTasks()
.named(SpringBootPlugin.RESOLVE_MAIN_CLASS_NAME_TASK_NAME, ResolveMainClassName.class);
Provider<Directory> aotClasses = project.getLayout().getBuildDirectory().dir("generated/aotClasses");
Configuration aotClasspath = createAotProcessingClasspath(project, PROCESS_AOT_TASK_NAME, mainSourceSet);
project.getDependencies().add(aotClasspath.getName(), project.files(mainSourceSet.getOutput()));
Configuration compileClasspath = project.getConfigurations()
.getByName(aotSourceSet.getCompileClasspathConfigurationName());
compileClasspath.extendsFrom(aotClasspath);
TaskProvider<ProcessAot> processAot = project.getTasks().register(PROCESS_AOT_TASK_NAME, ProcessAot.class,
(task) -> {
configureAotTask(project, aotSourceSet, task, aotClasses, mainSourceSet);
task.getApplicationClass()
.set(resolveMainClassName.flatMap(ResolveMainClassName::readMainClassName));
task.setClasspath(aotClasspath);
});
project.getDependencies().add(aotSourceSet.getImplementationConfigurationName(), project.files(aotClasses));
aotSourceSet.getOutput().dir(aotClasses);
@@ -132,7 +133,6 @@ public class SpringBootAotPlugin implements Plugin<Project> {
private void configureAotTask(Project project, SourceSet sourceSet, AbstractAot task,
Provider<Directory> generatedClasses, SourceSet inputSourceSet) {
task.setClasspath(sourceSet.getCompileClasspath());
task.getSourcesOutput().set(sourceSet.getJava().getSrcDirs().iterator().next());
task.getResourcesOutput().set(sourceSet.getResources().getSrcDirs().iterator().next());
task.getClassesOutput().set(generatedClasses);
@@ -141,6 +141,25 @@ public class SpringBootAotPlugin implements Plugin<Project> {
task.setClasspathRoots(inputSourceSet.getOutput().getClassesDirs());
}
@SuppressWarnings("unchecked")
private Configuration createAotProcessingClasspath(Project project, String taskName, SourceSet inputSourceSet) {
Configuration base = project.getConfigurations()
.getByName(inputSourceSet.getRuntimeClasspathConfigurationName());
Configuration aotClasspath = project.getConfigurations().create(taskName + "Classpath", (classpath) -> {
classpath.setCanBeConsumed(false);
classpath.setCanBeResolved(true);
classpath.setDescription("Classpath of the " + taskName + " task.");
base.getExtendsFrom().forEach(classpath::extendsFrom);
classpath.attributes((attributes) -> {
AttributeContainer baseAttributes = base.getAttributes();
for (Attribute<?> attribute : baseAttributes.keySet()) {
attributes.attribute((Attribute<Object>) attribute, baseAttributes.getAttribute(attribute));
}
});
});
return aotClasspath;
}
private void configureDependsOn(Project project, SourceSet aotSourceSet,
TaskProvider<? extends AbstractAot> processAot) {
project.getTasks().named(aotSourceSet.getCompileJavaTaskName())
@@ -149,11 +168,18 @@ public class SpringBootAotPlugin implements Plugin<Project> {
.configure((processResources) -> processResources.dependsOn(processAot));
}
private void registerProcessTestAotTask(Project project, SourceSet aotTestSourceSet, SourceSet testSourceSet) {
private void registerProcessTestAotTask(Project project, SourceSet mainSourceSet, SourceSet aotTestSourceSet,
SourceSet testSourceSet) {
Provider<Directory> aotTestClasses = project.getLayout().getBuildDirectory().dir("generated/aotTestClasses");
Configuration aotClasspath = createAotProcessingClasspath(project, PROCESS_TEST_AOT_TASK_NAME, testSourceSet);
Configuration compileClasspath = project.getConfigurations()
.getByName(aotTestSourceSet.getCompileClasspathConfigurationName());
compileClasspath.extendsFrom(aotClasspath);
TaskProvider<ProcessTestAot> processTestAot = project.getTasks().register(PROCESS_TEST_AOT_TASK_NAME,
ProcessTestAot.class, (task) -> {
configureAotTask(project, aotTestSourceSet, task, aotTestClasses, testSourceSet);
task.setClasspath(project.getObjects().fileCollection().from(aotClasspath,
mainSourceSet.getOutput(), testSourceSet.getOutput()));
task.setTestRuntimeClasspath(
project.getConfigurations().getByName(testSourceSet.getImplementationConfigurationName()));
});