Refine layer customization for Maven and Gradle

Simplify layer customization logic for both Maven and Gradle and
refactor some internals of the Gradle plugin.

Both Maven and Gradle now use a simpler customization format that
consists of `application`, `dependencies` and `layer order` sections.
The `application`, `dependencies` configurations support one or more
`into` blocks that are used to select content for a specific layer.

Closes gh-20526

Author: philwebb

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/packaging/boot-jar-layered-custom.gradle

@@ -9,27 +9,17 @@ bootJar {
 
 // tag::layered[]
 bootJar {
-	layers {
-		layersOrder "dependencies", "snapshot-dependencies", "application"
-		libraries {
-			layerContent("snapshot-dependencies") {
-				coordinates {
-					include "*:*:*SNAPSHOT"
-				}
-			}
-			layerContent("dependencies") {
-				coordinates {
-					include "*:*"
-				}
-			}
-		}
+	layered {
 		application {
-			layerContent("application") {
-				locations {
-					include "**"
-				}
+			intoLayer("application")
+		}
+		dependencies {
+			intoLayer("snapshot-dependencies") {
+				include "*:*:*SNAPSHOT"
 			}
+			intoLayer("dependencies")
 		}
+		layerOrder "dependencies", "snapshot-dependencies", "application"
 	}
 }
 // end::layered[]

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/packaging/boot-jar-layered-custom.gradle.kts

@@ -7,27 +7,17 @@ plugins {
 
 // tag::layered[]
 tasks.getByName<BootJar>("bootJar") {
-	layers {
-		layersOrder("dependencies", "snapshot-dependencies", "application")
-		libraries {
-			layerContent("snapshot-dependencies") {
-				coordinates {
-					include("*:*:*SNAPSHOT")
-				}
-			}
-			layerContent("dependencies") {
-				coordinates {
-					include("*:*")
-				}
-			}
-		}
+	layered {
 		application {
-			layerContent("application") {
-				locations {
-					include("**")
-				}
+			intoLayer("application")
+		}
+		dependencies {
+			intoLayer("snapshot-dependencies") {
+				include("*:*:*SNAPSHOT")
 			}
+			intoLayer("dependencies") {
 		}
+		layersOrder("dependencies", "snapshot-dependencies", "application")
 	}
 }
 // end::layered[]

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/packaging/boot-jar-layered.gradle

@@ -9,6 +9,6 @@ bootJar {
 
 // tag::layered[]
 bootJar {
-	layers()
+	layered()
 }
 // end::layered[]

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/gradle/packaging/boot-jar-layered.gradle.kts

@@ -11,6 +11,6 @@ tasks.getByName<BootJar>("bootJar") {
 
 // tag::layered[]
 tasks.getByName<BootJar>("bootJar") {
-	layers()
+	layered()
 }
 // end::layered[]

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

@@ -27,7 +27,6 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
-import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.internal.artifacts.dsl.LazyPublishArtifact;
 import org.gradle.api.plugins.ApplicationPlugin;
@@ -94,9 +93,6 @@ private TaskProvider<BootJar> configureBootJarTask(Project project) {
 			SourceSet mainSourceSet = javaPluginConvention(project).getSourceSets()
 					.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
 			bootJar.classpath((Callable<FileCollection>) mainSourceSet::getRuntimeClasspath);
-			Configuration runtimeClasspathConfiguration = project.getConfigurations()
-					.getByName(mainSourceSet.getRuntimeClasspathConfigurationName());
-			runtimeClasspathConfiguration.getIncoming().afterResolve(bootJar::resolvedDependencies);
 			bootJar.conventionMapping("mainClassName", new MainClassConvention(project, bootJar::getClasspath));
 		});
 	}

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/main/java/org/springframework/boot/gradle/tasks/bundling/BootArchiveSupport.java

@@ -27,13 +27,15 @@
 import java.util.TreeMap;
 import java.util.function.Function;
 
+import org.gradle.api.file.CopySpec;
 import org.gradle.api.file.FileCopyDetails;
 import org.gradle.api.file.FileTreeElement;
 import org.gradle.api.file.RelativePath;
 import org.gradle.api.internal.file.copy.CopyAction;
 import org.gradle.api.internal.file.copy.CopyActionProcessingStream;
 import org.gradle.api.internal.file.copy.FileCopyDetailsInternal;
 import org.gradle.api.java.archives.Attributes;
+import org.gradle.api.java.archives.Manifest;
 import org.gradle.api.specs.Spec;
 import org.gradle.api.specs.Specs;
 import org.gradle.api.tasks.WorkResult;
@@ -44,6 +46,9 @@
  * Support class for implementations of {@link BootArchive}.
  *
  * @author Andy Wilkinson
+ * @author Phillip Webb
+ * @see BootJar
+ * @see BootWar
  */
 class BootArchiveSupport {
 
@@ -61,46 +66,71 @@ class BootArchiveSupport {
 
 	private final PatternSet requiresUnpack = new PatternSet();
 
-	private final Function<FileCopyDetails, ZipCompression> compressionResolver;
-
 	private final PatternSet exclusions = new PatternSet();
 
 	private final String loaderMainClass;
 
+	private final Spec<FileCopyDetails> librarySpec;
+
+	private final Function<FileCopyDetails, ZipCompression> compressionResolver;
+
 	private LaunchScriptConfiguration launchScript;
 
 	private boolean excludeDevtools = true;
 
-	BootArchiveSupport(String loaderMainClass, Function<FileCopyDetails, ZipCompression> compressionResolver) {
+	BootArchiveSupport(String loaderMainClass, Spec<FileCopyDetails> librarySpec,
+			Function<FileCopyDetails, ZipCompression> compressionResolver) {
 		this.loaderMainClass = loaderMainClass;
+		this.librarySpec = librarySpec;
 		this.compressionResolver = compressionResolver;
 		this.requiresUnpack.include(Specs.satisfyNone());
 		configureExclusions();
 	}
 
-	void configureManifest(Jar jar, String mainClassName, String springBootClasses, String springBootLib) {
-		Attributes attributes = jar.getManifest().getAttributes();
+	void configureManifest(Manifest manifest, String mainClass, String classes, String lib, String classPathIndex,
+			String layersIndex) {
+		Attributes attributes = manifest.getAttributes();
 		attributes.putIfAbsent("Main-Class", this.loaderMainClass);
-		attributes.putIfAbsent("Start-Class", mainClassName);
-		attributes.computeIfAbsent("Spring-Boot-Version", (key) -> determineSpringBootVersion());
-		attributes.putIfAbsent("Spring-Boot-Classes", springBootClasses);
-		attributes.putIfAbsent("Spring-Boot-Lib", springBootLib);
+		attributes.putIfAbsent("Start-Class", mainClass);
+		attributes.computeIfAbsent("Spring-Boot-Version", (name) -> determineSpringBootVersion());
+		if (classes != null) {
+			attributes.putIfAbsent("Spring-Boot-Classes", classes);
+		}
+		if (lib != null) {
+			attributes.putIfAbsent("Spring-Boot-Lib", lib);
+		}
+		if (classPathIndex != null) {
+			attributes.putIfAbsent("Spring-Boot-Classpath-Index", classPathIndex);
+		}
+		if (layersIndex != null) {
+			attributes.putIfAbsent("Spring-Boot-Layers-Index", layersIndex);
+		}
 	}
 
 	private String determineSpringBootVersion() {
-		String implementationVersion = getClass().getPackage().getImplementationVersion();
-		return (implementationVersion != null) ? implementationVersion : "unknown";
+		String version = getClass().getPackage().getImplementationVersion();
+		return (version != null) ? version : "unknown";
 	}
 
 	CopyAction createCopyAction(Jar jar) {
-		CopyAction copyAction = new BootZipCopyAction(jar.getArchiveFile().get().getAsFile(),
-				jar.isPreserveFileTimestamps(), isUsingDefaultLoader(jar), this.requiresUnpack.getAsSpec(),
-				this.exclusions.getAsExcludeSpec(), this.launchScript, this.compressionResolver,
-				jar.getMetadataCharset());
-		if (!jar.isReproducibleFileOrder()) {
-			return copyAction;
-		}
-		return new ReproducibleOrderingCopyAction(copyAction);
+		return createCopyAction(jar, null, false);
+	}
+
+	CopyAction createCopyAction(Jar jar, LayerResolver layerResolver, boolean includeLayerTools) {
+		File output = jar.getArchiveFile().get().getAsFile();
+		Manifest manifest = jar.getManifest();
+		boolean preserveFileTimestamps = jar.isPreserveFileTimestamps();
+		boolean includeDefaultLoader = isUsingDefaultLoader(jar);
+		Spec<FileTreeElement> requiresUnpack = this.requiresUnpack.getAsSpec();
+		Spec<FileTreeElement> exclusions = this.exclusions.getAsExcludeSpec();
+		LaunchScriptConfiguration launchScript = this.launchScript;
+		Spec<FileCopyDetails> librarySpec = this.librarySpec;
+		Function<FileCopyDetails, ZipCompression> compressionResolver = this.compressionResolver;
+		String encoding = jar.getMetadataCharset();
+		CopyAction action = new BootZipCopyAction(output, manifest, preserveFileTimestamps, includeDefaultLoader,
+				includeLayerTools, requiresUnpack, exclusions, launchScript, librarySpec, compressionResolver, encoding,
+				layerResolver);
+		return jar.isReproducibleFileOrder() ? new ReproducibleOrderingCopyAction(action) : action;
 	}
 
 	private boolean isUsingDefaultLoader(Jar jar) {
@@ -132,7 +162,19 @@ void setExcludeDevtools(boolean excludeDevtools) {
 		configureExclusions();
 	}
 
-	boolean isZip(File file) {
+	void excludeNonZipLibraryFiles(FileCopyDetails details) {
+		if (this.librarySpec.isSatisfiedBy(details)) {
+			excludeNonZipFiles(details);
+		}
+	}
+
+	void excludeNonZipFiles(FileCopyDetails details) {
+		if (!isZip(details.getFile())) {
+			details.exclude();
+		}
+	}
+
+	private boolean isZip(File file) {
 		try {
 			try (FileInputStream fileInputStream = new FileInputStream(file)) {
 				return isZip(fileInputStream);
@@ -160,6 +202,17 @@ private void configureExclusions() {
 		this.exclusions.setExcludes(excludes);
 	}
 
+	void moveModuleInfoToRoot(CopySpec spec) {
+		spec.filesMatching("module-info.class", BootArchiveSupport::moveToRoot);
+	}
+
+	private static void moveToRoot(FileCopyDetails details) {
+		details.setRelativePath(details.getRelativeSourcePath());
+	}
+
+	/**
+	 * {@link CopyAction} variant that sorts entries to ensure reproducible ordering.
+	 */
 	private static final class ReproducibleOrderingCopyAction implements CopyAction {
 
 		private final CopyAction delegate;