Put project deps in app layer and make customization easier

Previously, when building a layered jar with Gradle, project
dependencies were treated the same as any other dependency, being
included in the dependencies or snapshot dependencies layer based
on their version.

This commit updates the default layering when using Gradle to include
project dependencies in the application layer by default. The DSL has
also been updated to allow their layer to be customized using new
includeProjectDependencies() and excludeProjectDependencies() methods
rather than relying on including and excluding them via a
group:artifact:version pattern.

Closes gh-23431

Author: wilkinsona

spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/docs/asciidoc/packaging.adoc

@@ -282,10 +282,10 @@ Layered jars use the same layout as regular boot packaged jars, but include an a
 
 By default, the following layers are defined:
 
-* `dependencies` for any dependency whose version does not contain `SNAPSHOT`.
+* `dependencies` for any non-project dependency whose version does not contain `SNAPSHOT`.
 * `spring-boot-loader` for the jar loader classes.
-* `snapshot-dependencies` for any dependency whose version contains `SNAPSHOT`.
-* `application` for application classes and resources.
+* `snapshot-dependencies` for any non-project dependency whose version contains `SNAPSHOT`.
+* `application` for project dependencies, application classes, and resources.
 
 The layers order is important as it determines how likely previous layers can be cached when part of the application changes.
 The default order is `dependencies`, `spring-boot-loader`, `snapshot-dependencies`, `application`.
@@ -355,13 +355,15 @@ Any content not claimed by an earlier `intoLayer` closure remains available for
 The `intoLayer` closure claims content using nested `include` and `exclude` calls.
 The `application` closure uses Ant-style patch matching for include/exclude parameters.
 The `dependencies` section uses `group:artifact[:version]` patterns.
+It also provides `includeProjectDependencies()` and `excludeProjectDependencies()` methods that can be used to include or exclude project dependencies.
 
 If no `include` call is made, then all content (not claimed by an earlier closure) is considered.
 
 If no `exclude` call is made, then no exclusions are applied.
 
-Looking at the `dependencies` closure in the example above, we can see that the first `intoLayer` will claim all SNAPSHOT dependencies for the `snapshot-dependencies` layer.
-The subsequent `intoLayer` will claim anything left (in this case, any dependency that is not a SNAPSHOT) for the `dependencies` layer.
+Looking at the `dependencies` closure in the example above, we can see that the first `intoLayer` will claim all project dependencies for the `application` layer.
+The next `intoLayer` will claim all SNAPSHOT dependencies for the `snapshot-dependencies` layer.
+The third and final `intoLayer` will claim anything left (in this case, any dependency that is not a project dependency or a SNAPSHOT) for the `dependencies` layer.
 
 The `application` closure has similar rules.
 First claiming `org/springframework/boot/loader/**` content for the `spring-boot-loader` layer.

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

@@ -17,6 +17,9 @@ bootJar {
 			intoLayer("application")
 		}
 		dependencies {
+			intoLayer("application") {
+				includeProjectDependencies()
+			}
 			intoLayer("snapshot-dependencies") {
 				include "*:*:*SNAPSHOT"
 			}

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

@@ -21,9 +21,9 @@
 import org.gradle.api.file.FileCopyDetails;
 import org.gradle.api.specs.Spec;
 
+import org.springframework.boot.gradle.tasks.bundling.ResolvedDependencies.DependencyDescriptor;
 import org.springframework.boot.loader.tools.Layer;
 import org.springframework.boot.loader.tools.Library;
-import org.springframework.boot.loader.tools.LibraryCoordinates;
 
 /**
  * Resolver backed by a {@link LayeredSpec} that provides the destination {@link Layer}
@@ -76,8 +76,10 @@ Iterable<Layer> getLayers() {
 
 	private Library asLibrary(FileCopyDetails details) {
 		File file = details.getFile();
-		LibraryCoordinates coordinates = this.resolvedDependencies.find(file);
-		return new Library(null, file, null, coordinates, false);
+		DependencyDescriptor dependency = this.resolvedDependencies.find(file);
+		return (dependency != null)
+				? new Library(null, file, null, dependency.getCoordinates(), false, dependency.isProjectDependency())
+				: new Library(file, null);
 	}
 
 }

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

@@ -227,31 +227,33 @@ public abstract static class IntoLayersSpec implements Serializable {
 
 		private final List<IntoLayerSpec> intoLayers;
 
+		private final Function<String, IntoLayerSpec> specFactory;
+
 		boolean isEmpty() {
 			return this.intoLayers.isEmpty();
 		}
 
-		IntoLayersSpec(IntoLayerSpec... spec) {
+		IntoLayersSpec(Function<String, IntoLayerSpec> specFactory, IntoLayerSpec... spec) {
 			this.intoLayers = new ArrayList<>(Arrays.asList(spec));
+			this.specFactory = specFactory;
 		}
 
 		public void intoLayer(String layer) {
-			this.intoLayers.add(new IntoLayerSpec(layer));
+			this.intoLayers.add(this.specFactory.apply(layer));
 		}
 
 		public void intoLayer(String layer, Closure<?> closure) {
 			intoLayer(layer, ConfigureUtil.configureUsing(closure));
 		}
 
 		public void intoLayer(String layer, Action<IntoLayerSpec> action) {
-			IntoLayerSpec spec = new IntoLayerSpec(layer);
+			IntoLayerSpec spec = this.specFactory.apply(layer);
 			action.execute(spec);
 			this.intoLayers.add(spec);
 		}
 
-		<T> List<ContentSelector<T>> asSelectors(Function<String, ContentFilter<T>> filterFactory) {
-			return this.intoLayers.stream().map((content) -> content.asSelector(filterFactory))
-					.collect(Collectors.toList());
+		<T> List<ContentSelector<T>> asSelectors(Function<IntoLayerSpec, ContentSelector<T>> selectorFactory) {
+			return this.intoLayers.stream().map(selectorFactory).collect(Collectors.toList());
 		}
 
 	}
@@ -279,8 +281,8 @@ public IntoLayerSpec(String intoLayer) {
 		/**
 		 * Adds patterns that control the content that is included in the layer. If no
 		 * includes are specified then all content is included. If includes are specified
-		 * then content must match an inclusion pattern and not match any exclusion
-		 * patterns to be included.
+		 * then content must match an inclusion and not match any exclusions to be
+		 * included.
 		 * @param patterns the patterns to be included
 		 */
 		public void include(String... patterns) {
@@ -291,7 +293,7 @@ public void include(String... patterns) {
 		 * Adds patterns that control the content that is excluded from the layer. If no
 		 * excludes a specified no content is excluded. If exclusions are specified then
 		 * any content that matches an exclusion will be excluded irrespective of whether
-		 * it matches an include pattern.
+		 * it matches an include.
 		 * @param patterns the patterns to be excluded
 		 */
 		public void exclude(String... patterns) {
@@ -303,6 +305,76 @@ <T> ContentSelector<T> asSelector(Function<String, ContentFilter<T>> filterFacto
 			return new IncludeExcludeContentSelector<>(layer, this.includes, this.excludes, filterFactory);
 		}
 
+		String getIntoLayer() {
+			return this.intoLayer;
+		}
+
+		List<String> getIncludes() {
+			return this.includes;
+		}
+
+		List<String> getExcludes() {
+			return this.excludes;
+		}
+
+	}
+
+	/**
+	 * Spec that controls the dependencies that should be part of a particular layer.
+	 *
+	 * @since 2.4.0
+	 */
+	public static class DependenciesIntoLayerSpec extends IntoLayerSpec {
+
+		private boolean includeProjectDependencies;
+
+		private boolean excludeProjectDependencies;
+
+		/**
+		 * Creates a new {@code IntoLayerSpec} that will control the content of the given
+		 * layer.
+		 * @param intoLayer the layer
+		 */
+		public DependenciesIntoLayerSpec(String intoLayer) {
+			super(intoLayer);
+		}
+
+		/**
+		 * Configures the layer to include project dependencies. If no includes are
+		 * specified then all content is included. If includes are specified then content
+		 * must match an inclusion and not match any exclusions to be included.
+		 */
+		public void includeProjectDependencies() {
+			this.includeProjectDependencies = true;
+		}
+
+		/**
+		 * Configures the layer to exclude project dependencies. If no excludes a
+		 * specified no content is excluded. If exclusions are specified then any content
+		 * that matches an exclusion will be excluded irrespective of whether it matches
+		 * an include.
+		 */
+		public void excludeProjectDependencies() {
+			this.excludeProjectDependencies = true;
+		}
+
+		ContentSelector<Library> asLibrarySelector(Function<String, ContentFilter<Library>> filterFactory) {
+			Layer layer = new Layer(getIntoLayer());
+			List<ContentFilter<Library>> includeFilters = getIncludes().stream().map(filterFactory)
+					.collect(Collectors.toList());
+			if (this.includeProjectDependencies) {
+				includeFilters = new ArrayList<>(includeFilters);
+				includeFilters.add(Library::isLocal);
+			}
+			List<ContentFilter<Library>> excludeFilters = getExcludes().stream().map(filterFactory)
+					.collect(Collectors.toList());
+			if (this.excludeProjectDependencies) {
+				excludeFilters = new ArrayList<>(includeFilters);
+				excludeFilters.add(Library::isLocal);
+			}
+			return new IncludeExcludeContentSelector<>(layer, includeFilters, excludeFilters);
+		}
+
 	}
 
 	/**
@@ -317,30 +389,49 @@ public static class ApplicationSpec extends IntoLayersSpec {
 		 * included
 		 */
 		public ApplicationSpec(IntoLayerSpec... contents) {
-			super(contents);
+			super(new IntoLayerSpecFactory(), contents);
 		}
 
 		List<ContentSelector<String>> asSelectors() {
-			return asSelectors(ApplicationContentFilter::new);
+			return asSelectors((spec) -> spec.asSelector(ApplicationContentFilter::new));
+		}
+
+		private static final class IntoLayerSpecFactory implements Function<String, IntoLayerSpec>, Serializable {
+
+			@Override
+			public IntoLayerSpec apply(String layer) {
+				return new IntoLayerSpec(layer);
+			}
+
 		}
 
 	}
 
 	/**
 	 * An {@link IntoLayersSpec} that controls the layers to which dependencies belong.
 	 */
-	public static class DependenciesSpec extends IntoLayersSpec {
+	public static class DependenciesSpec extends IntoLayersSpec implements Serializable {
 
 		/**
 		 * Creates a new {@code DependenciesSpec} with the given {@code contents}.
 		 * @param contents specs for the layers in which dependencies should be included
 		 */
-		public DependenciesSpec(IntoLayerSpec... contents) {
-			super(contents);
+		public DependenciesSpec(DependenciesIntoLayerSpec... contents) {
+			super(new IntoLayerSpecFactory(), contents);
 		}
 
 		List<ContentSelector<Library>> asSelectors() {
-			return asSelectors(LibraryContentFilter::new);
+			return asSelectors(
+					(spec) -> ((DependenciesIntoLayerSpec) spec).asLibrarySelector(LibraryContentFilter::new));
+		}
+
+		private static final class IntoLayerSpecFactory implements Function<String, IntoLayerSpec>, Serializable {
+
+			@Override
+			public IntoLayerSpec apply(String layer) {
+				return new DependenciesIntoLayerSpec(layer);
+			}
+
 		}
 
 	}

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

@@ -19,9 +19,12 @@
 import java.io.File;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.artifacts.ProjectDependency;
 import org.gradle.api.artifacts.ResolvedArtifact;
 import org.gradle.api.artifacts.ResolvedConfiguration;
 
@@ -42,15 +45,19 @@ class ResolvedDependencies {
 	private final Map<Configuration, ResolvedConfigurationDependencies> configurationDependencies = new LinkedHashMap<>();
 
 	void processConfiguration(Configuration configuration) {
+		Set<String> projectDependencyIds = configuration.getAllDependencies().withType(ProjectDependency.class).stream()
+				.map((projectDependency) -> projectDependency.getGroup() + ":" + projectDependency.getName() + ":"
+						+ projectDependency.getVersion())
+				.collect(Collectors.toSet());
 		this.configurationDependencies.put(configuration,
-				new ResolvedConfigurationDependencies(configuration.getResolvedConfiguration()));
+				new ResolvedConfigurationDependencies(projectDependencyIds, configuration.getResolvedConfiguration()));
 	}
 
-	LibraryCoordinates find(File file) {
+	DependencyDescriptor find(File file) {
 		for (ResolvedConfigurationDependencies dependencies : this.configurationDependencies.values()) {
-			LibraryCoordinates coordinates = dependencies.find(file);
-			if (coordinates != null) {
-				return coordinates;
+			DependencyDescriptor dependency = dependencies.find(file);
+			if (dependency != null) {
+				return dependency;
 			}
 		}
 		return null;
@@ -61,19 +68,23 @@ LibraryCoordinates find(File file) {
 	 */
 	private static class ResolvedConfigurationDependencies {
 
-		private final Map<File, LibraryCoordinates> artifactCoordinates = new LinkedHashMap<>();
+		private final Map<File, DependencyDescriptor> dependencies = new LinkedHashMap<>();
 
-		ResolvedConfigurationDependencies(ResolvedConfiguration resolvedConfiguration) {
+		ResolvedConfigurationDependencies(Set<String> projectDependencyIds,
+				ResolvedConfiguration resolvedConfiguration) {
 			if (!resolvedConfiguration.hasError()) {
 				for (ResolvedArtifact resolvedArtifact : resolvedConfiguration.getResolvedArtifacts()) {
-					this.artifactCoordinates.put(resolvedArtifact.getFile(),
-							new ModuleVersionIdentifierLibraryCoordinates(resolvedArtifact.getModuleVersion().getId()));
+					ModuleVersionIdentifier id = resolvedArtifact.getModuleVersion().getId();
+					boolean projectDependency = projectDependencyIds
+							.contains(id.getGroup() + ":" + id.getName() + ":" + id.getVersion());
+					this.dependencies.put(resolvedArtifact.getFile(), new DependencyDescriptor(
+							new ModuleVersionIdentifierLibraryCoordinates(id), projectDependency));
 				}
 			}
 		}
 
-		LibraryCoordinates find(File file) {
-			return this.artifactCoordinates.get(file);
+		DependencyDescriptor find(File file) {
+			return this.dependencies.get(file);
 		}
 
 	}
@@ -111,4 +122,28 @@ public String toString() {
 
 	}
 
+	/**
+	 * Describes a dependency in a {@link ResolvedConfiguration}.
+	 */
+	static final class DependencyDescriptor {
+
+		private final LibraryCoordinates coordinates;
+
+		private final boolean projectDependency;
+
+		private DependencyDescriptor(LibraryCoordinates coordinates, boolean projectDependency) {
+			this.coordinates = coordinates;
+			this.projectDependency = projectDependency;
+		}
+
+		LibraryCoordinates getCoordinates() {
+			return this.coordinates;
+		}
+
+		boolean isProjectDependency() {
+			return this.projectDependency;
+		}
+
+	}
+
 }